sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
c6b678fa60
nuttx-apps/system/vi/vi.c

5948 lines
152 KiB
C
Raw Blame History

/****************************************************************************
* apps/system/vi/vi.c
*
* Copyright (C) 2014, 2018 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
* Major Edits 2019, Ken Pettit <pettitkd@gmail.com>
*
* 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/stat.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <syslog.h>
#include <errno.h>
#include <debug.h>
#include <system/termcurses.h>
#include <graphics/curses.h>
#include <nuttx/ascii.h>
#include <nuttx/vt100.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#ifndef CONFIG_SYSTEM_VI_ROWS
# define CONFIG_SYSTEM_VI_ROWS 16
#endif
#ifndef CONFIG_SYSTEM_VI_COLS
# define CONFIG_SYSTEM_VI_COLS 64
#endif
/* 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
#ifndef CONFIG_SYSTEM_VI_YANK_THRESHOLD
#define CONFIG_SYSTEM_VI_YANK_THRESHOLD 128
#endif
/* Control characters */
#undef CTRL
#define CTRL(a) ((a) & 0x1f)
#define VI_BEL(vi) vi_putch(vi,CTRL('G'))
/* Sizes of things */
#define MAX_STRING 64 /* The maximum size of a filename or search string */
#define MAX_FILENAME 128 /* The maximum size of a filename or search string */
#define SCRATCH_BUFSIZE 128 /* The maximum size of the scratch buffer */
#define CMD_BUFSIZE 128 /* The maximum size of the scratch buffer */
#define TEXT_GULP_SIZE 512 /* Text buffer allocations are managed with this unit */
#define TEXT_GULP_MASK 511 /* Mask for aligning buffer allocation sizes */
#define ALIGN_GULP(x) (((x) + TEXT_GULP_MASK) & ~TEXT_GULP_MASK)
#define VI_TABSIZE 8 /* A TAB is eight characters */
#define TABMASK 7 /* Mask for TAB alignment */
#define NEXT_TAB(p) (((p) + VI_TABSIZE) & ~TABMASK)
/* Parsed command action bits */
#define CMD_READ (1 << 0) /* Bit 0: Read */
#define CMD_WRITE_MASK (3 << 1) /* Bits 1-2: x1=Write operation */
# define CMD_WRITE (1 << 1) /* 01=Write (without overwriting) */
# define CMD_OWRITE (3 << 1) /* 11=Overwrite */
#define CMD_QUIT_MASK (3 << 3) /* Bits 3-4: x1=Quit operation */
# define CMD_QUIT (1 << 3) /* 01=Quit if saved */
# define CMD_DISCARD (3 << 3) /* 11=Quit without saving */
#define CMD_NONE (0) /* No command */
#define CMD_WRITE_QUIT (CMD_WRITE | CMD_QUIT) /* Write file and quit command */
#define CMD_OWRITE_QUIT (CMD_OWRITE | CMD_QUIT) /* Overwrite file and quit command */
#define IS_READ(a) (((uint8_t)(a) & CMD_READ) != 0)
#define IS_WRITE(a) (((uint8_t)(a) & CMD_WRITE) != 0)
#define IS_OWRITE(a) (((uint8_t)(a) & CMD_WRITE_MASK) == CMD_OWRITE)
#define IS_NOWRITE(a) (((uint8_t)(a) & CMD_WRITE_MASK) == CMD_WRITE)
#define IS_QUIT(a) (((uint8_t)(a) & CMD_QUIT) != 0)
#define IS_DISCARD(a) (((uint8_t)(a) & CMD_QUIT_MASK) == CMD_DISCARD)
#define IS_NDISCARD(a) (((uint8_t)(a) & CMD_QUIT_MASK) == CMD_QUIT && !IS_WRITE(a))
#define CMD_FILE_MASK (CMD_READ | CMD_WRITE)
#define USES_FILE(a) (((uint8_t)(a) & CMD_FILE_MASK) != 0)
/* Search control */
#define VI_CHAR_SPACE 0
#define VI_CHAR_ALPHA 1
#define VI_CHAR_PUNCT 2
#define VI_CHAR_CRLF 3
/* Output */
#define vi_error(vi, fmt, ...) vi_printf(vi, "ERROR: ", fmt, ##__VA_ARGS__)
#define vi_message(vi, fmt, ...) vi_printf(vi, NULL, fmt, ##__VA_ARGS__)
/* Debug */
#ifndef CONFIG_SYSTEM_VI_DEBUGLEVEL
# define CONFIG_SYSTEM_VI_DEBUGLEVEL 0
#endif
#ifdef CONFIG_CPP_HAVE_VARARGS
# if CONFIG_SYSTEM_VI_DEBUGLEVEL > 0
# define vidbg(format, ...) \
syslog(LOG_DEBUG, EXTRA_FMT format EXTRA_ARG, ##__VA_ARGS__)
# define vvidbg(format, ap) \
vsyslog(LOG_DEBUG, format, ap)
# else
# define vidbg(x...)
# define vvidbg(x...)
# endif
# if CONFIG_SYSTEM_VI_DEBUGLEVEL > 1
# define viinfo(format, ...) \
syslog(LOG_DEBUG, EXTRA_FMT format EXTRA_ARG, ##__VA_ARGS__)
# else
# define viinfo(x...)
# endif
#else
# if CONFIG_SYSTEM_VI_DEBUGLEVEL > 0
# define vidbg vi_debug
# define vvidbg vi_vdebug
# else
# define vidbg (void)
# define vvidbg (void)
# endif
# if CONFIG_SYSTEM_VI_DEBUGLEVEL > 1
# define viinfo vi_debug
# else
# define viinfo (void)
# endif
#endif
/* Uncomment to enable bottom line debug printing. Useful during yank /
* paste debugging, etc.
*/
/* #define ENABLE_BOTTOM_LINE_DEBUG */
/****************************************************************************
* Private Types
****************************************************************************/
/* VI Key Bindings */
enum vi_cmdmode_key_e
{
KEY_CMDMODE_BEGINLINE = '0', /* Move cursor to start of current line */
KEY_CMDMODE_APPEND = 'a', /* Enter insertion mode after current character */
KEY_CMDMODE_WORDBACK = 'b', /* Scan to previous word */
KEY_CMDMODE_CHANGE = 'c', /* Delete text and enter insert mode */
KEY_CMDMODE_DEL_LINE = 'd', /* "dd" deletes a lines */
KEY_CMDMODE_FINDINLINE = 'f', /* Find within current line */
KEY_CMDMODE_GOTOTOP = 'g', /* Two of these sends cursor to the top */
KEY_CMDMODE_LEFT = 'h', /* Move left one character */
KEY_CMDMODE_INSERT = 'i', /* Enter insertion mode before current character */
KEY_CMDMODE_DOWN = 'j', /* Move down one line */
KEY_CMDMODE_UP = 'k', /* Move up one line */
KEY_CMDMODE_RIGHT = 'l', /* Move right one character */
KEY_CMDMODE_MARK = 'm', /* Place a mark beginning at the current cursor position */
KEY_CMDMODE_FINDNEXT = 'n', /* Find next */
KEY_CMDMODE_OPENBELOW = 'o', /* Enter insertion mode in new line below current */
KEY_CMDMODE_PASTE = 'p', /* Paste line(s) from into text after current line */
KEY_CMDMODE_REPLACECH = 'r', /* Replace character(s) under cursor */
KEY_CMDMODE_SUBSTITUTE = 's', /* Substitute character with new text */
KEY_CMDMODE_TFINDINLINE = 't', /* Find within current line, cursor at previous char */
KEY_CMDMODE_WORDFWD = 'w', /* Scan to next word */
KEY_CMDMODE_DEL = 'x', /* Delete a single character */
KEY_CMDMODE_YANK = 'y', /* "yy" yanks the current line(s) into the buffer */
KEY_CMDMODE_CR = '\r', /* CR moves to first non-space on next line */
KEY_CMDMODE_NL = '\n', /* NL moves to first non-space on next line */
KEY_CMDMODE_APPENDEND = 'A', /* Enter insertion mode at the end of the current line */
KEY_CMDMODE_CHANGETOEOL = 'C', /* Change (del to EOL and go to insert mode */
KEY_CMDMODE_DELTOEOL = 'D', /* Delete to End Of Line */
KEY_CMDMODE_GOTO = 'G', /* Got to line */
KEY_CMDMODE_TOP = 'H', /* Got to top of screen */
KEY_CMDMODE_JOIN = 'J', /* Join line below with current line */
KEY_CMDMODE_BOTTOM = 'L', /* Got to bottom of screen */
KEY_CMDMODE_INSBEGIN = 'I', /* Enter insertion mode at the beginning of the current */
KEY_CMDMODE_MIDDLE = 'M', /* Got to middle of screen */
KEY_CMDMODE_FINDPREV = 'N', /* Find previous */
KEY_CMDMODE_OPENABOVE = 'O', /* Enter insertion mode in new line above current line */
KEY_CMDMODE_PASTEBEFORE = 'P', /* Paste text before cursor location */
KEY_CMDMODE_REPLACE = 'R', /* Replace character(s) under cursor until ESC */
KEY_CMDMODE_DELBACKWARD = 'X', /* Replace character(s) under cursor until ESC */
KEY_CMDMODE_SAVEQUIT = 'Z', /* Another one is the same as "wq" */
KEY_CMDMODE_COLONMODE = ':', /* The next character command prefaced with a colon */
KEY_CMDMODE_FINDMODE = '/', /* Enter forward search string */
KEY_CMDMODE_ENDLINE = '$', /* Move cursor to end of current line */
KEY_CMDMODE_REVFINDMODE = '?', /* Enter forward search string */
KEY_CMDMODE_REPEAT = '.', /* Repeat last command */
KEY_CMDMODE_FIRSTCHAR = '^', /* Find first non-whitespace character on line */
KEY_CMDMODE_NEXTLINE = '+', /* Find first non-whitespace character on line */
KEY_CMDMODE_PREVLINE = '-', /* Find first non-whitespace character on line */
KEY_CMDMODE_PAGEUP = CTRL('b'), /* Move backward one screen */
KEY_CMDMODE_HALFDOWN = CTRL('d'), /* Move down (forward) one half screen */
KEY_CMDMODE_PAGEDOWN = CTRL('f'), /* Move forward one screen */
KEY_CMDMODE_REDRAW = CTRL('l'), /* Redraws the screen */
KEY_CMDMODE_REDRAW2 = CTRL('r'), /* Redraws the screen, removing deleted lines */
KEY_CMDMODE_HALFUP = CTRL('u') /* Move up (back) one half screen */
};
enum vi_insmode_key_e
{
KEY_INSMODE_QUOTE = '\\', /* The next character is quote (use literal value) */
};
enum vi_colonmode_key_e
{
KEY_COLMODE_READ = 'r', /* Read file */
KEY_COLMODE_QUIT = 'q', /* Quit vi */
KEY_COLMODE_WRITE = 'w', /* Write file */
KEY_COLMODE_FORCE = '!', /* Force operation */
KEY_COLMODE_QUOTE = '\\' /* The next character is quote (use literal value) */
};
enum vi_findmode_key_e
{
KEY_FINDMODE_QUOTE = '\\' /* The next character is quote (use literal value) */
};
/* VI modes */
enum vi_mode_s
{
MODE_COMMAND = 0, /* ESC Command mode */
SUBMODE_COLON, /* : Command sub-mode */
SUBMODE_FIND, /* / Search sub-mode */
SUBMODE_REVFIND, /* ? Search sub-mode */
SUBMODE_REPLACECH, /* r Replace sub-mode 1 */
MODE_INSERT, /* i,I,a,A,o,O Insert mode */
MODE_REPLACE, /* R Replace sub-mode 2 */
MODE_FINDINLINE /* f Find in line sub-mode */
};
/* This structure represents a cursor position */
struct vi_pos_s
{
uint16_t row;
uint16_t column;
};
#ifdef CONFIG_SYSTEM_VI_INCLUDE_UNDO
/* The undo structure. Will be implemented soon. */
struct vi_undo_s
{
off_t curpos; /* Cursor position before operation */
off_t ybytes; /* Bytes yanked */
off_t ibytes; /* Bytes inserted */
FAR char *yank; /* The yanked bytes */
FAR char *insert; /* The inserted bytes */
uint8_t type; /* Type of operation */
uint8_t complete; /* Indicates if this operation complete */
};
#endif
/* This structure describes the overall state of the editor */
struct vi_s
{
struct vi_pos_s cursor; /* Current cursor position */
struct vi_pos_s cursave; /* Saved cursor position */
struct vi_pos_s display; /* Display size */
FAR struct termcurses_s * tcurs;
off_t curpos; /* The current cursor offset into the text buffer */
off_t textsize; /* The size of the text buffer */
off_t winpos; /* Offset corresponding to the start of the display */
off_t prevpos; /* Previous display position */
off_t vscroll; /* Vertical display offset in rows */
uint16_t hscroll; /* Horizontal display offset */
uint16_t value; /* Numeric value entered prior to a command */
uint16_t reqcolumn; /* Requested column when moving up/down */
uint8_t mode; /* See enum vi_mode_s */
uint8_t cmdlen; /* Length of the command in the scratch[] buffer */
bool modified; /* True: The file has modified */
bool error; /* True: There is an error message on the last line */
bool delarm; /* Delete text arm flag */
bool chgarm; /* Change text arm flag */
bool yankarm; /* Yank text arm flag */
bool toparm; /* One more 'g' and the cursor moves to the top */
bool wqarm; /* One more 'Z' is the same as :wq */
bool fullredraw; /* True to draw all lines on screen */
bool drawtoeos; /* True to draw all lines to end of screen */
bool redrawline; /* True to draw current line */
bool updatereqcol; /* True to update the requested column */
bool tfind; /* Find in line 't' mode */
bool revfind; /* In ? reverse find mode */
bool yankcharmode; /* Indicates yank buffer is char vs. line mode */
/* Buffers */
FAR char *text; /* Dynamically allocated text buffer */
size_t txtalloc; /* Current allocated size of the text buffer */
FAR char *yank; /* Dynamically allocated yank buffer */
size_t yankalloc; /* Current allocated size of the yank buffer */
size_t yanksize; /* Current size of the text in the yank buffer */
char filename[MAX_FILENAME]; /* Holds the currently selected filename */
char findstr[MAX_STRING]; /* Holds the current search string */
char scratch[SCRATCH_BUFSIZE]; /* For general, scratch usage */
#ifdef CONFIG_SYSTEM_VI_INCLUDE_UNDO
struct vi_undo_s undo[CONFIG_SYSTEM_VI_UNDO_LEVELS];
uint16_t undocount; /* Number of valid undo entries */
uint16_t undoindex; /* Current index in undo/redo stack */
#endif
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
char cmdbuf[CMD_BUFSIZE]; /* Last command buffer */
uint16_t cmdindex; /* Current index within cmdbuf */
uint16_t cmdcount; /* Count of entries in cmdbuf */
uint16_t repeatvalue; /* The command repeat value */
bool cmdrepeat; /* Command repeat is active */
#endif
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/* Low-level display and data entry functions */
static void vi_write(FAR struct vi_s *vi, FAR const char *buffer,
size_t buflen);
static void vi_putch(FAR struct vi_s *vi, char ch);
static int vi_getch(FAR struct vi_s *vi);
#if 0 /* Not used */
static void vi_blinkon(FAR struct vi_s *vi);
#endif
static void vi_boldon(FAR struct vi_s *vi);
static void vi_reverseon(FAR struct vi_s *vi);
static void vi_attriboff(FAR struct vi_s *vi);
static void vi_cursoron(FAR struct vi_s *vi);
static void vi_cursoroff(FAR struct vi_s *vi);
#if 0 /* Not used */
static void vi_cursorhome(FAR struct vi_s *vi);
#endif
static void vi_setcursor(FAR struct vi_s *vi, uint16_t row,
uint16_t column);
static void vi_clrtoeol(FAR struct vi_s *vi);
#if 0 /* Not used */
static void vi_clrscreen(FAR struct vi_s *vi);
#endif
/* Final Line display */
static void vi_printf(FAR struct vi_s *vi, FAR const char *prefix,
FAR const char *fmt, ...);
/* Line positioning */
static off_t vi_linebegin(FAR struct vi_s *vi, off_t pos);
static off_t vi_prevline(FAR struct vi_s *vi, off_t pos);
static off_t vi_lineend(FAR struct vi_s *vi, off_t pos);
static off_t vi_nextline(FAR struct vi_s *vi, off_t pos);
/* Text buffer management */
static bool vi_extendtext(FAR struct vi_s *vi, off_t pos,
size_t increment);
static void vi_shrinkpos(FAR struct vi_s *vi, off_t delpos,
size_t delsize, FAR off_t *pos);
static void vi_shrinktext(FAR struct vi_s *vi, off_t pos, size_t size);
/* File access */
static bool vi_insertfile(FAR struct vi_s *vi, off_t pos,
FAR const char *filename);
static bool vi_savetext(FAR struct vi_s *vi, FAR const char *filename,
off_t pos, size_t size);
static bool vi_checkfile(FAR struct vi_s *vi, FAR const char *filename);
/* Mode management */
static void vi_setmode(FAR struct vi_s *vi, uint8_t mode, long value);
static void vi_setsubmode(FAR struct vi_s *vi, uint8_t mode,
char prompt, long value);
static void vi_exitsubmode(FAR struct vi_s *vi, uint8_t mode);
/* Display management */
static void vi_windowpos(FAR struct vi_s *vi, off_t start, off_t end,
uint16_t *pcolumn, off_t *ppos);
static void vi_scrollcheck(FAR struct vi_s *vi);
static void vi_showtext(FAR struct vi_s *vi);
static void vi_showlinecol(FAR struct vi_s *vi);
/* Command mode */
static void vi_cusorup(FAR struct vi_s *vi, int nlines);
static void vi_cursordown(FAR struct vi_s *vi, int nlines);
static off_t vi_cursorleft(FAR struct vi_s *vi, off_t curpos,
int ncolumns);
static off_t vi_cursorright(FAR struct vi_s *vi, off_t curpos,
int ncolumns);
static void vi_delforward(FAR struct vi_s *vi);
static void vi_delbackward(FAR struct vi_s *vi);
static void vi_linerange(FAR struct vi_s *vi, off_t *start, off_t *end);
static void vi_delline(FAR struct vi_s *vi);
static void vi_deltoeol(FAR struct vi_s *vi);
static void vi_yanktext(FAR struct vi_s *vi, off_t start, off_t end,
bool yankcharmode, bool del_after_yank);
static void vi_yank(FAR struct vi_s *vi, bool del_after_yank);
static void vi_paste(FAR struct vi_s *vi, bool paste_before);
static void vi_gotoline(FAR struct vi_s *vi);
static void vi_join(FAR struct vi_s *vi);
static void vi_cmd_mode(FAR struct vi_s *vi);
static int vi_gotoscreenbottom(FAR struct vi_s *vi, int rows);
static void vi_gotofirstnonwhite(FAR struct vi_s *vi);
/* Command sub-modes */
static void vi_cmdch(FAR struct vi_s *vi, char ch);
static void vi_cmdbackspace(FAR struct vi_s *vi);
static void vi_parsecolon(FAR struct vi_s *vi);
static void vi_cmd_submode(FAR struct vi_s *vi);
static bool vi_findstring(FAR struct vi_s *vi);
static bool vi_revfindstring(FAR struct vi_s *vi);
static void vi_parsefind(FAR struct vi_s *vi, bool revfind);
static void vi_find_submode(FAR struct vi_s *vi, bool revfind);
static void vi_replacech(FAR struct vi_s *vi, char ch);
static void vi_replacech_submode(FAR struct vi_s *vi);
static void vi_findinline_mode(FAR struct vi_s *vi);
/* Insert and replace modes */
static void vi_insertch(FAR struct vi_s *vi, char ch);
static void vi_insert_mode(FAR struct vi_s *vi);
/* Command line processing */
static void vi_release(FAR struct vi_s *vi);
static void vi_showusage(FAR struct vi_s *vi, FAR const char *progname,
int exitcode);
/* Find next / prev word processing */
static int vi_chartype(char ch);
static off_t vi_findnextword(FAR struct vi_s *vi);
static void vi_gotonextword(FAR struct vi_s *vi);
static off_t vi_findprevword(FAR struct vi_s *vi);
static void vi_gotoprevword(FAR struct vi_s *vi);
/* Command repeat processing */
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
static void vi_saverepeat(FAR struct vi_s *vi, uint16_t ch);
static void vi_appendrepeat(FAR struct vi_s *vi, uint16_t ch);
#endif
/****************************************************************************
* Private Data
****************************************************************************/
/* VT100 escape sequences */
static const char g_cursoron[] = VT100_CURSORON;
static const char g_cursoroff[] = VT100_CURSOROFF;
#if 0 /* Not used */
static const char g_cursorhome[] = VT100_CURSORHOME;
#endif
static const char g_erasetoeol[] = VT100_CLEAREOL;
#if 0 /* Not used */
static const char g_clrscreen[] = VT100_CLEARSCREEN;
#endif
static const char g_index[] = VT100_INDEX;
static const char g_revindex[] = VT100_REVINDEX;
static const char g_attriboff[] = VT100_MODESOFF;
static const char g_boldon[] = VT100_BOLD;
static const char g_reverseon[] = VT100_REVERSE;
#if 0 /* Not used */
static const char g_blinkon[] = VT100_BLINK;
static const char g_boldoff[] = VT100_BOLDOFF;
static const char g_reverseoff[] = VT100_REVERSEOFF;
static const char g_blinkoff[] = VT100_BLINKOFF;
#endif
static const char g_fmtcursorpos[] = VT100_FMT_CURSORPOS;
/* Error format strings */
static const char g_fmtallocfail[] = "Failed to allocate memory";
static const char g_fmtcmdfail[] = "%s failed: %d";
static const char g_fmtnotfile[] = "%s is not a regular file";
static const char g_fmtfileexists[] = "File exists (add ! to override)";
static const char g_fmtmodified[] = "No write since last change (add ! to override)";
static const char g_fmtnotvalid[] = "Command not valid";
static const char g_fmtnotcmd[] = "Not an editor command: %s";
static const char g_fmtsrcbot[] = "search hit BOTTOM, continuing at TOP";
static const char g_fmtsrctop[] = "search hit TOP, continuing at BOTTOM";
static const char g_fmtinsert[] = "--INSERT--";
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: vi_vdebug and vi_debug
*
* Description:
* Print a debug message to the syslog
*
****************************************************************************/
#if !defined(CONFIG_CPP_HAVE_VARARGS) && CONFIG_SYSTEM_VI_DEBUGLEVEL > 0
static inline int vi_vdebug(FAR const char *fmt, va_list ap)
{
return vsyslog(LOG_DEBUG, fmt, ap);
}
static int vi_debug(FAR const char *fmt, ...)
{
va_list ap;
int ret;
/* Let vsyslog do the real work */
va_start(ap, fmt);
ret = vsyslog(LOG_DEBUG, fmt, ap);
va_end(ap);
return ret;
}
#endif
/****************************************************************************
* Low-level display and data entry functions
****************************************************************************/
/****************************************************************************
* Name: vi_write
*
* Description:
* Write a sequence of bytes to the console device (stdout, fd = 1).
*
****************************************************************************/
static void vi_write(FAR struct vi_s *vi, FAR const char *buffer,
size_t buflen)
{
ssize_t nwritten;
size_t nremaining = buflen;
/* Loop until all bytes have been successfully written (or until a
* unrecoverable error is encountered)
*/
do
{
/* Take the next gulp */
nwritten = write(1, buffer, buflen);
/* Handle write errors. write() should neve return 0. */
if (nwritten <= 0)
{
/* EINTR is not really an error; it simply means that a signal was
* received while waiting for write.
*/
int errcode = errno;
if (nwritten == 0 || errcode != EINTR)
{
fprintf(stderr, "ERROR: write to stdout failed: %d\n",
errcode);
exit(EXIT_FAILURE);
}
}
/* Decrement the count of bytes remaining to be sent (to handle the
* case of a partial write)
*/
else
{
nremaining -= nwritten;
}
}
while (nremaining > 0);
}
/****************************************************************************
* Name: vi_putch
*
* Description:
* Write a single character to the console device.
*
****************************************************************************/
static void vi_putch(FAR struct vi_s *vi, char ch)
{
vi_write(vi, &ch, 1);
}
/****************************************************************************
* Name: vi_getch
*
* Description:
* Get a single character from the console device (stdin, fd = 0).
*
****************************************************************************/
static int vi_getch(FAR struct vi_s *vi)
{
char buffer;
ssize_t nread;
/* Loop until we successfully read a character (or until an unexpected
* error occurs).
*/
if (vi->tcurs != NULL)
{
int specialkey;
int modifiers;
/* Get key from termcurses */
return termcurses_getkeycode(vi->tcurs, &specialkey, &modifiers);
}
else
{
do
{
/* Read one character from the incoming stream */
nread = read(0, &buffer, 1);
/* Check for error or end-of-file. */
if (nread <= 0)
{
/* EINTR is not really an error; it simply means that a signal
* we received while waiting for input.
*/
int errcode = errno;
if (nread == 0 || errcode != EINTR)
{
fprintf(stderr, "ERROR: read from stdin failed: %d\n",
errcode);
exit(EXIT_FAILURE);
}
}
}
while (nread < 1);
}
/* On success, return the character that was read */
viinfo("Returning: %c[%02x]\n", isprint(buffer) ? buffer : '.', buffer);
return buffer;
}
/****************************************************************************
* Name: vi_clearbottomline
*
* Description:
* Clear the bottom statusline.
*
****************************************************************************/
static void vi_clearbottomline(FAR struct vi_s *vi)
{
vi_setcursor(vi, vi->display.row-1, 0);
vi_clrtoeol(vi);
}
/****************************************************************************
* Name: vi_boldon
*
* Description:
* Enable the blinking attribute at the current cursor location
*
****************************************************************************/
static void vi_boldon(FAR struct vi_s *vi)
{
/* Send the VT100 BOLDON command */
vi_write(vi, g_boldon, sizeof(g_boldon));
}
/****************************************************************************
* Name: vi_reverseon
*
* Description:
* Enable the blinking attribute at the current cursor location
*
****************************************************************************/
static void vi_reverseon(FAR struct vi_s *vi)
{
/* Send the VT100 REVERSON command */
vi_write(vi, g_reverseon, sizeof(g_reverseon));
}
/****************************************************************************
* Name: vi_attriboff
*
* Description:
* Disable all previously selected attributes.
*
****************************************************************************/
static void vi_attriboff(FAR struct vi_s *vi)
{
/* Send the VT100 ATTRIBOFF command */
vi_write(vi, g_attriboff, sizeof(g_attriboff));
}
/****************************************************************************
* Name: vi_cursoron
*
* Description:
* Turn on the cursor
*
****************************************************************************/
static void vi_cursoron(FAR struct vi_s *vi)
{
/* Send the VT100 CURSORON command */
vi_write(vi, g_cursoron, sizeof(g_cursoron));
}
/****************************************************************************
* Name: vi_cursoroff
*
* Description:
* Turn off the cursor
*
****************************************************************************/
static void vi_cursoroff(FAR struct vi_s *vi)
{
/* Send the VT100 CURSOROFF command */
vi_write(vi, g_cursoroff, sizeof(g_cursoroff));
}
/****************************************************************************
* Name: vi_setcursor
*
* Description:
* Move the current cursor position to position (row,col)
*
****************************************************************************/
static void vi_setcursor(FAR struct vi_s *vi, uint16_t row, uint16_t column)
{
char buffer[16];
int len;
viinfo("row=%d column=%d\n", row, column);
/* Format the cursor position command. The origin is (1,1). */
len = snprintf(buffer, 16, g_fmtcursorpos, row + 1, column + 1);
/* Send the VT100 CURSORPOS command */
vi_write(vi, buffer, len);
}
/****************************************************************************
* Name: vi_clrtoeol
*
* Description:
* Clear the display from the current cursor position to the end of the
* current line.
*
****************************************************************************/
static void vi_clrtoeol(FAR struct vi_s *vi)
{
/* Send the VT100 ERASETOEOL command */
vi_write(vi, g_erasetoeol, sizeof(g_erasetoeol));
}
/****************************************************************************
* Name: vi_scrollup
*
* Description:
* Scroll the display up 'nlines' by sending the VT100 INDEX command.
*
****************************************************************************/
static void vi_scrollup(FAR struct vi_s *vi, uint16_t nlines)
{
viinfo("nlines=%d\n", nlines);
/* Scroll for the specified number of lines */
for (; nlines; nlines--)
{
/* Send the VT100 INDEX command */
vi_write(vi, g_index, sizeof(g_index));
}
/* Ensure bottom line is cleared */
vi_setcursor(vi, vi->display.row-1, 0);
vi_clrtoeol(vi);
}
/****************************************************************************
* Name: vi_scrolldown
*
* Description:
* Scroll the display down 'nlines' by sending the VT100 REVINDEX command.
*
****************************************************************************/
static void vi_scrolldown(FAR struct vi_s *vi, uint16_t nlines)
{
viinfo("nlines=%d\n", nlines);
/* Ensure the bottom line is cleared after the scroll */
vi_setcursor(vi, vi->display.row-2, 0);
vi_clrtoeol(vi);
/* Scroll for the specified number of lines */
for (; nlines; nlines--)
{
/* Send the VT100 REVINDEX command */
vi_write(vi, g_revindex, sizeof(g_revindex));
}
}
/****************************************************************************
* Name: vi_printf
*
* Description:
* Show a highlighted message at the final line of the display.
*
****************************************************************************/
static void vi_printf(FAR struct vi_s *vi, FAR const char *prefix,
FAR const char *fmt, ...)
{
struct vi_pos_s cursor;
va_list ap;
int len;
/* Save the current cursor position */
cursor.row = vi->cursor.row;
cursor.column = vi->cursor.column;
/* Set up for a reverse text message on the final line */
vi_setcursor(vi, vi->display.row - 1, 0);
vi_reverseon(vi);
/* Expand the prefix message in the scratch buffer */
len = prefix ? snprintf(vi->scratch, SCRATCH_BUFSIZE, prefix) : 0;
va_start(ap, fmt);
len += vsnprintf(vi->scratch + len, SCRATCH_BUFSIZE - len, fmt, ap);
vvidbg(fmt, ap);
va_end(ap);
/* Write the error message to the display in reverse text */
vi_write(vi, vi->scratch, len);
/* Restore normal attributes */
vi_attriboff(vi);
/* Reposition the cursor */
vi_setcursor(vi, cursor.row, cursor.column);
/* Remember that there is an error message on the last line of the display.
* When the display is refreshed, the last line will not be altered until
* the error is cleared.
*/
vi->error = true;
VI_BEL(vi);
}
/****************************************************************************
* Line positioning
****************************************************************************/
/****************************************************************************
* Name: vi_linebegin
*
* Description:
* Search backward for the beginning of the current line
*
****************************************************************************/
static off_t vi_linebegin(FAR struct vi_s *vi, off_t pos)
{
/* Search backward to find the previous newline character (or, possibly,
* the beginning of the text buffer).
*/
while (pos && vi->text[pos - 1] != '\n')
{
pos--;
}
viinfo("Return pos=%ld\n", (long)pos);
return pos;
}
/****************************************************************************
* Name: vi_prevline
*
* Description:
* Search backward for the beginning of the previous line
*
****************************************************************************/
static off_t vi_prevline(FAR struct vi_s *vi, off_t pos)
{
/* Find the beginning the of current line */
pos = vi_linebegin(vi, pos);
/* If this not the first line, then back up one more character to position
* at the last byte of the previous line.
*/
if (pos > 0)
{
pos = vi_linebegin(vi, pos - 1);
}
viinfo("Return pos=%ld\n", (long)pos);
return pos;
}
/****************************************************************************
* Name: vi_lineend
*
* Description:
* Search forward for the end of the current line
*
****************************************************************************/
static off_t vi_lineend(FAR struct vi_s *vi, off_t pos)
{
/* Search forward to find the next newline character. (or, possibly,
* the end of the text buffer).
*/
while (pos < vi->textsize && vi->text[pos] != '\n')
{
pos++;
}
if (vi->text[pos] == '\n')
{
pos--;
}
viinfo("Return pos=%ld\n", (long)pos);
return pos;
}
/****************************************************************************
* Name: vi_nextline
*
* Description:
* Search backward for the start of the next line
*
****************************************************************************/
static off_t vi_nextline(FAR struct vi_s *vi, off_t pos)
{
/* Position at the end of the current line */
pos = vi_lineend(vi, pos) + 1;
/* If this is not the last byte in the buffer, then increment by one
* for position of the first byte of the next line.
*/
if (pos < vi->textsize)
{
pos++;
}
viinfo("Return pos=%ld\n", (long)pos);
return pos;
}
/****************************************************************************
* Text buffer management
****************************************************************************/
/****************************************************************************
* Name: vi_extendtext
*
* Description:
* Reallocate the in-memory file memory by (at least) 'increment' and make
* space for new text of size 'increment' at the specified cursor position.
*
****************************************************************************/
static bool vi_extendtext(FAR struct vi_s *vi, off_t pos, size_t increment)
{
FAR char *alloc;
int i;
viinfo("pos=%ld increment=%ld\n", (long)pos, (long)increment);
/* Check if we need to reallocate */
if (!vi->text || vi->textsize + increment > vi->txtalloc)
{
/* Allocate in chunksize so that we do not have to reallocate so
* often.
*/
size_t allocsize = ALIGN_GULP(vi->textsize + increment);
alloc = realloc(vi->text, allocsize);
if (alloc == NULL)
{
/* Reallocation failed */
vi_error(vi, g_fmtallocfail);
return false;
}
/* Save the new buffer information */
vi->text = alloc;
vi->txtalloc = allocsize;
}
/* Move text to make space for new text of size 'increment' at the current
* cursor position
*/
for (i = vi->textsize - 1; i >= pos; i--)
{
vi->text[i + increment] = vi->text[i];
}
/* Adjust end of file position */
vi->textsize += increment;
vi->modified = true;
return true;
}
/****************************************************************************
* Name: vi_shrinkpos
*
* Description:
* This is really part of vi_shrinktext. When any text is deleted, any
* positions lying beyond the deleted region in the text buffer must be
* adjusted.
*
* Input Parameters:
* delpos The position where text was deleted
* delsize The number of bytes deleted.
* pos A pointer to a position that may need to be adjusted.
*
****************************************************************************/
static void vi_shrinkpos(FAR struct vi_s *vi, off_t delpos, size_t delsize,
FAR off_t *pos)
{
viinfo("delpos=%ld delsize=%ld pos=%ld\n",
(long)delpos, (long)delsize, (long)*pos);
/* Check if the position is beyond the deleted region */
if (*pos > delpos + delsize)
{
/* Yes... just subtract the size of the deleted region */
*pos -= delsize;
}
/* What if the position is within the deleted region? Set it to the
* beginning of the deleted region.
*/
else if (*pos > delpos)
{
*pos = delpos;
}
/* Ensure the position is within the text bounds in case the
* text at the end of the buffer is being deleted
*/
if (*pos >= vi->textsize && vi->mode != MODE_INSERT &&
vi->mode != MODE_REPLACE)
{
*pos = vi->textsize - 1;
}
/* Check pos for negative bounds */
if (*pos < 0)
{
*pos = 0;
}
}
/****************************************************************************
* Name: vi_shrinktext
*
* Description:
* Delete a region in the text buffer by copying the end of the text buffer
* over the deleted region and adjusting the size of the region. The text
* region may be reallocated in order to recover the unused memory.
*
****************************************************************************/
static void vi_shrinktext(FAR struct vi_s *vi, off_t pos, size_t size)
{
FAR char *alloc;
size_t allocsize;
int i;
viinfo("pos=%ld size=%ld\n", (long)pos, (long)size);
/* Close up the gap to remove 'size' characters at 'pos' */
for (i = pos + size; i < vi->textsize; i++)
{
vi->text[i - size] = vi->text[i];
}
/* Ensure we are not shrinking more than we have */
if (size > vi->textsize)
{
size = vi->textsize;
}
/* Adjust sizes and positions */
vi->textsize -= size;
vi->modified = true;
vi_shrinkpos(vi, pos, size, &vi->curpos);
vi_shrinkpos(vi, pos, size, &vi->winpos);
vi_shrinkpos(vi, pos, size, &vi->prevpos);
/* Reallocate the buffer to free up memory no longer in use */
allocsize = ALIGN_GULP(vi->textsize);
if (allocsize == 0)
{
allocsize = TEXT_GULP_SIZE;
}
if (allocsize < vi->txtalloc)
{
alloc = realloc(vi->text, allocsize);
if (!alloc)
{
vi_error(vi, g_fmtallocfail);
return;
}
/* Save the new buffer information */
vi->text = alloc;
vi->txtalloc = allocsize;
}
}
/****************************************************************************
* File access
****************************************************************************/
/****************************************************************************
* Name: vi_insertfile
*
* Description:
* Insert the contents of a file into the text buffer
*
****************************************************************************/
static bool vi_insertfile(FAR struct vi_s *vi, off_t pos,
FAR const char *filename)
{
struct stat buf;
FILE *stream;
off_t filesize;
size_t nread;
int result;
bool ret;
viinfo("pos=%ld filename=\"%s\"\n", (long)pos, filename);
/* Get the size of the file */
result = stat(filename, &buf);
if (result < 0)
{
vi_message(vi, "\"%s\" [New File]", filename);
return false;
}
/* Check for zero-length file */
filesize = buf.st_size;
if (filesize < 1)
{
return false;
}
/* Open the file for reading */
stream = fopen(filename, "r");
if (!stream)
{
vi_error(vi, g_fmtcmdfail, "open", errno);
return false;
}
/* [Re]allocate the text buffer to hold the file contents at the current
* cursor position.
*/
ret = false;
if (vi_extendtext(vi, pos, filesize))
{
/* Read the contents of the file into the text buffer at the
* current cursor position.
*/
nread = fread(vi->text + pos, 1, filesize, stream);
if (nread < filesize)
{
/* Report the error (or partial read), EINTR is not handled */
vi_error(vi, g_fmtcmdfail, "fread", errno);
vi_shrinktext(vi, pos, filesize);
}
else
{
ret = true;
}
}
vi->fullredraw = true;
fclose(stream);
return ret;
}
/****************************************************************************
* Name: vi_savetext
*
* Description:
* Save a region of the text buffer to 'filename'
*
****************************************************************************/
static bool vi_savetext(FAR struct vi_s *vi, FAR const char *filename,
off_t pos, size_t size)
{
FAR FILE *stream;
size_t nwritten;
int len;
viinfo("filename=\"%s\" pos=%ld size=%ld\n",
filename, (long)pos, (long)size);
/* Open the file for writing */
stream = fopen(filename, "w");
if (!stream)
{
vi_error(vi, g_fmtcmdfail, "fopen", errno);
return false;
}
/* Write the region of the text buffer beginning at pos and extending
* through pos + size -1.
*/
nwritten = fwrite(vi->text + pos, 1, size, stream);
if (nwritten < size)
{
/* Report the error (or partial write). EINTR is not handled. */
vi_error(vi, g_fmtcmdfail, "fwrite", errno);
fclose(stream);
return false;
}
fclose(stream);
len = sprintf(vi->scratch, "%dC written", nwritten);
vi_write(vi, vi->scratch, len);
return true;
}
/****************************************************************************
* Name: vi_checkfile
*
* Description:
* Check if a file by this name already exists.
*
****************************************************************************/
static bool vi_checkfile(FAR struct vi_s *vi, FAR const char *filename)
{
struct stat buf;
int ret;
viinfo("filename=\"%s\"\n", filename);
/* Get the size of the file */
ret = stat(filename, &buf);
if (ret < 0)
{
/* The file does not exist */
return false;
}
/* It exists, but is it a regular file */
if (!S_ISREG(buf.st_mode))
{
/* Report the error... there is really no good return value in
* this case.
*/
vi_error(vi, g_fmtnotfile, filename);
}
return true;
}
/****************************************************************************
* Mode Management Functions
****************************************************************************/
/****************************************************************************
* Name: vi_setmode
*
* Description:
* Set the new mode (or command sub-mode) and reset all other common state
* variables. NOTE that a numeric value may be passed to the new mode in
* the value field.
*
****************************************************************************/
static void vi_setmode(FAR struct vi_s *vi, uint8_t mode, long value)
{
viinfo("mode=%d value=%ld\n", mode, value);
/* Set the mode and clear mode-dependent states that are not preserved
* across mode changes.
*/
vi->mode = mode;
vi->delarm = false;
vi->yankarm = false;
vi->toparm = false;
vi->chgarm = false;
vi->wqarm = false;
vi->value = value;
vi->cmdlen = 0;
}
/****************************************************************************
* Name: vi_setsubmode
*
* Description:
* Set up one of the data entry sub-modes of the command mode. These are
* modes in which commands or search data will be entered on the final line
* of the display.
*
****************************************************************************/
static void vi_setsubmode(FAR struct vi_s *vi, uint8_t mode, char prompt,
long value)
{
viinfo("mode=%d prompt='%c' value=%ld\n", mode, prompt, value);
/* Set up the new mode */
vi_setmode(vi, mode, value);
/* Save the previous cursor position (not required by all modes) */
vi->cursave.row = vi->cursor.row;
vi->cursave.column = vi->cursor.column;
/* Set up for data entry on the final line */
vi->cursor.row = vi->display.row - 1;
vi->cursor.column = 0;
vi_setcursor(vi, vi->cursor.row, vi->cursor.column);
/* Output the prompt character in bold text */
vi_boldon(vi);
vi_putch(vi, prompt);
vi_attriboff(vi);
/* Clear to the end of the line */
vi_clrtoeol(vi);
/* Update the cursor position */
vi->cursor.column = 1;
}
/****************************************************************************
* Name: vi_exitsubmode
*
* Description:
* Exit the data entry sub-mode and return to normal command mode.
*
****************************************************************************/
static void vi_exitsubmode(FAR struct vi_s *vi, uint8_t mode)
{
viinfo("mode=%d\n", mode);
/* Set up the new mode */
vi_setmode(vi, mode, 0);
/* Restore the saved cursor position */
vi->cursor.row = vi->cursave.row;
vi->cursor.column = vi->cursave.column;
}
/****************************************************************************
* Display Management
****************************************************************************/
/****************************************************************************
* Name: vi_windowpos
*
* Description:
* Based on the position of the cursor in the text buffer, determine the
* horizontal display cursor position, performing TAB expansion as
* necessary.
*
****************************************************************************/
static void vi_windowpos(FAR struct vi_s *vi, off_t start, off_t end,
uint16_t *pcolumn, off_t *ppos)
{
uint16_t column;
off_t pos;
viinfo("start=%ld end=%ld\n", (long)start, (long)end);
/* Make sure that the end position is not beyond the end of the text. We
* assume that the start position is okay.
*/
if (end > vi->textsize)
{
end = vi->textsize;
}
/* Loop incrementing the text buffer position while text buffer position
* is within range.
*/
for (pos = start, column = 0; pos < end && (column < vi->reqcolumn ||
vi->updatereqcol); pos++)
{
/* Is there a newline terminator at this position? */
if (vi->text[pos] == '\n')
{
/* Yes... break out of the loop return the cursor column */
if (vi->mode != MODE_INSERT && vi->mode != MODE_REPLACE &&
pos != start)
{
pos--;
column--;
}
break;
}
/* No... Is there a TAB at this position? */
else if (vi->text[pos] == '\t')
{
/* Yes.. expand the TAB */
column = NEXT_TAB(column);
}
/* No, then just increment the cursor column by one character */
else
{
column++;
}
}
/* Keep cursor in bounds of text (i.e. not at the '\n') */
if (((pos == vi->textsize && column != 0) ||
(vi->text[pos] == '\n' && pos != start)) &&
vi->mode != MODE_INSERT && vi->mode != MODE_REPLACE)
{
pos--;
column--;
}
/* Now return the requested values */
if (ppos)
{
*ppos = pos;
}
if (pcolumn)
{
*pcolumn = column;
}
if (vi->updatereqcol)
{
vi->reqcolumn = column;
vi->updatereqcol = false;
}
}
/****************************************************************************
* Name: vi_scrollcheck
*
* Description:
* Check if any operations will require that we scroll the display.
*
****************************************************************************/
static void vi_scrollcheck(FAR struct vi_s *vi)
{
off_t curline;
off_t pos;
uint16_t tmp;
int column;
int nlines;
/* Sanity test */
if (vi->curpos > vi->textsize)
{
vi->curpos = vi->textsize;
}
/* Get the text buffer offset to the beginning of the current line */
curline = vi_linebegin(vi, vi->curpos);
/* Check if the current line is above the first line on the display */
while (curline < vi->winpos)
{
/* Yes.. move the window position up to the beginning of the previous
* line line and check again */
vi->winpos = vi_prevline(vi, vi->winpos);
vi->vscroll--;
vi->fullredraw = true;
}
/* Reset the cursor row position so that it is relative to the
* top of the display.
*/
vi->cursor.row = 0;
for (pos = vi->winpos; pos < curline; pos = vi_nextline(vi, pos))
{
vi->cursor.row++;
}
/* Check if the cursor row position is below the bottom of the display */
for (; vi->cursor.row >= vi->display.row-1; vi->cursor.row--)
{
/* Yes.. move the window position down by one line and check again */
vi->winpos = vi_nextline(vi, vi->winpos);
vi->vscroll++;
vi->fullredraw = true;
}
/* Check if the cursor column is on the display. vi_windowpos returns the
* unrestricted column number of cursor. hscroll is the horizontal offset
* in characters.
*/
vi_windowpos(vi, curline, vi->curpos, &tmp, NULL);
column = (int)tmp - (int)vi->hscroll;
/* Force the cursor column to lie on the display. First check if the
* column lies to the left of the horizontal scrolling position. If it
* does, move the scroll position to the left by tabs until the cursor
* lies on the display.
*/
while (column < 0)
{
column += VI_TABSIZE;
vi->hscroll -= VI_TABSIZE;
vi->fullredraw = true;
}
/* If the cursor column lies to the right of the display, then adjust
* the horizontal scrolling position so that the cursor position does
* lie on the display.
*/
while (column >= vi->display.column)
{
column -= VI_TABSIZE;
vi->hscroll += VI_TABSIZE;
vi->fullredraw = true;
}
/* That final adjusted position is the display cursor column */
vi->cursor.column = column;
/* Check if new window position is below the previous position.
* In this case, we will need to scroll up until the new window
* position is at the top of the display.
*/
if (vi->winpos > vi->prevpos)
{
/* We will need to scroll up. Count how many lines we
* need to scroll.
*/
for (nlines = 0, pos = vi->prevpos;
pos != vi->winpos && nlines < vi->display.row-1;
nlines++)
{
pos = vi_nextline(vi, pos);
}
/* Then scroll up that number of lines */
if (nlines < vi->display.row-1)
{
vi_scrollup(vi, nlines);
vi->fullredraw = true;
}
}
/* Check if new window position is above the previous position.
* In this case, we will need to scroll down until the new window
* position is at the top of the display.
*/
else if (vi->winpos < vi->prevpos)
{
for (nlines = 0, pos = vi->prevpos;
pos != vi->winpos && nlines < vi->display.row - 1;
nlines++)
{
pos = vi_prevline(vi, pos);
}
/* Then scroll down that number of lines */
if (nlines < vi->display.row-1)
{
vi_scrolldown(vi, nlines);
vi->fullredraw = true;
}
}
/* Save the previous top-of-display position for next time around.
* This can be modified asynchronously by text deletion operations.
*/
vi->prevpos = vi->winpos;
viinfo("winpos=%ld hscroll=%d\n",
(long)vi->winpos, (long)vi->hscroll);
}
/****************************************************************************
* Name: vi_showtext
*
* Description:
* Update the display based on the last operation. This function is
* called at the beginning of the processing loop in Command and Insert
* modes (and also in the continuous replace mode).
*
****************************************************************************/
static void vi_showtext(FAR struct vi_s *vi)
{
off_t pos;
off_t writefrom;
uint16_t row;
uint16_t endrow;
uint16_t column;
uint16_t endcol;
uint16_t tabcol;
bool redraw_line;
/* Check if any of the preceding operations will cause the display to
* scroll.
*/
vi_scrollcheck(vi);
/* If no display updates needed after scrollcheck, just return */
if (!vi->fullredraw && !vi->drawtoeos && !vi->redrawline)
{
return;
}
/* If there is an error message at the bottom of the display, then
* do not update the last line.
*/
endrow = vi->display.row-1;
/* Make sure that all character attributes are disabled; Turn off the
* cursor during the update.
*/
vi_attriboff(vi);
vi_cursoroff(vi);
/* Set loop control variables based on draw mode */
if (vi->fullredraw)
{
/* Start from beginning of display */
pos = vi->winpos;
row = 0;
/* Ensure drawtoeos and redraw line are also set */
vi->drawtoeos = true;
vi->redrawline = true;
}
else
{
/* Start drawing from current row */
pos = vi_linebegin(vi, vi->curpos);
row = vi->cursor.row;
if (vi->drawtoeos)
{
vi->redrawline = true;
}
else
{
endrow = row + 1;
}
}
/* Write each line to the display, handling horizontal scrolling and
* tab expansion.
*/
for (; pos < vi->textsize && row < endrow; row++)
{
/* Test if this line needs to be redrawn */
redraw_line = true;
if (!vi->redrawline)
{
redraw_line = false;
}
else if (row+1 < vi->cursor.row && !vi->fullredraw)
{
redraw_line = false;
}
else if (row > vi->cursor.row && !vi->drawtoeos)
{
redraw_line = false;
}
else if (row == vi->cursor.row && !vi->redrawline)
{
redraw_line = false;
}
/* Get the last column on this row. Avoid writing into the last byte
* on the screen which may trigger a scroll.
*/
endcol = vi->display.column;
if (row >= vi->display.row - 1)
{
endcol--;
}
/* Get the position into this line corresponding to display column 0,
* accounting for horizontal scrolling and tab expansion. Add that to
* the line start offset to get the first offset to consider for
* display.
*/
vi_windowpos(vi, pos, pos + vi->hscroll, NULL, &pos);
/* Set the cursor position to the beginning of this row and clear to
* the end of the line.
*/
if (redraw_line)
{
vi_setcursor(vi, row, 0);
/* Loop for each column */
writefrom = pos;
for (column = 0; pos < vi->textsize && column < endcol; pos++)
{
/* Break out of the loop if we encounter the newline before the
* last column is encountered.
*/
if (vi->text[pos] == '\n')
{
break;
}
/* Perform TAB expansion */
else if (vi->text[pos] == '\t')
{
/* Write collected characters */
if (writefrom != pos)
{
vi_write(vi, &vi->text[writefrom], pos-writefrom);
}
tabcol = NEXT_TAB(column);
if (tabcol < endcol)
{
for (; column < tabcol; column++)
{
vi_putch(vi, ' ');
}
writefrom = pos + 1;
}
else
{
/* Break out of the loop... there is nothing left on the
* line but whitespace.
*/
writefrom = pos;
break;
}
}
/* Add the normal character to the display */
else
{
column++;
}
}
/* Write collected characters */
if (writefrom != pos)
{
vi_write(vi, &vi->text[writefrom], pos-writefrom);
}
vi_clrtoeol(vi);
}
/* Skip to the beginning of the next line */
pos = vi_nextline(vi, pos);
}
if (pos == vi->textsize && vi->text[pos-1] == '\n')
{
vi_setcursor(vi, row, 0);
vi_clrtoeol(vi);
row++;
}
/* If we are drawing to EOS, then draw trailing '~' */
if (vi->drawtoeos)
{
/* If there was not enough text to fill the display, clear the
* remaining lines (except for any possible error line at the
* bottom of the display).
*/
for (; row < endrow; row++)
{
/* Set the cursor position to the beginning of the row and clear to
* the end of the line.
*/
vi_setcursor(vi, row, 0);
if (row != endrow && row != 0)
{
vi_putch(vi, '~');
}
vi_clrtoeol(vi);
}
}
/* Turn the cursor back on */
vi_cursoron(vi);
vi->fullredraw = false;
vi->drawtoeos = false;
vi->redrawline = false;
}
/****************************************************************************
* Name: vi_showlinecol
*
* Description:
* Update the current line/column on the display status line.
*
****************************************************************************/
static void vi_showlinecol(FAR struct vi_s *vi)
{
size_t len;
/* Move to bototm line for display */
vi_cursoroff(vi);
vi_setcursor(vi, vi->display.row-1, vi->display.column-15);
len = snprintf(vi->scratch, SCRATCH_BUFSIZE, "%d,%d",
vi->cursor.row + vi->vscroll + 1,
vi->cursor.column + vi->hscroll + 1);
vi_write(vi, vi->scratch, len);
vi_clrtoeol(vi);
vi_cursoron(vi);
}
/****************************************************************************
* Command Mode Functions
****************************************************************************/
/****************************************************************************
* Name: vi_cusorup
*
* Description:
* Move the cursor up one line in the text buffer.
*
****************************************************************************/
static void vi_cusorup(FAR struct vi_s *vi, int nlines)
{
int remaining;
off_t start;
off_t end;
viinfo("nlines=%d\n", nlines);
/* How many lines do we need to move? Zero means 1 (so does 1) */
remaining = (nlines < 1 ? 1 : nlines);
/* Get the offset to the start of the current line */
start = vi_linebegin(vi, vi->curpos);
/* Now move the cursor position back the correct number of lines */
for (; remaining > 0; remaining--)
{
/* Get the start position of the previous line */
start = vi_prevline(vi, start);
/* Find the cursor position on the next line corresponding to the
* cursor position on the current line.
*/
end = start + vi->reqcolumn;
vi_windowpos(vi, start, end, NULL, &vi->curpos);
}
}
/****************************************************************************
* Name: vi_cursordown
*
* Description:
* Move the cursor down one line in the text buffer
*
****************************************************************************/
static void vi_cursordown(FAR struct vi_s *vi, int nlines)
{
int remaining;
off_t start;
off_t end;
viinfo("nlines=%d\n", nlines);
/* How many lines do we need to move? Zero means 1 (so does 1) */
remaining = (nlines < 1 ? 1 : nlines);
/* Get the offset to the start of the current line */
start = vi_linebegin(vi, vi->curpos);
/* Now move the cursor position forward the correct number of lines */
for (; remaining > 0; remaining--)
{
/* Get the start of the next line. */
start = vi_nextline(vi, start);
/* Find the cursor position on the next line corresponding to the
* cursor position on the current line.
*/
end = start + vi->reqcolumn;
vi_windowpos(vi, start, end, NULL, &vi->curpos);
}
}
/****************************************************************************
* Name: vi_cursorleft
*
* Description:
* Move the cursor left 'ncolumns' columns in the text buffer (without
* moving to the preceding line). Note that a repetition count of 0 means
* to perform the movement once.
*
****************************************************************************/
static off_t vi_cursorleft(FAR struct vi_s *vi, off_t curpos, int ncolumns)
{
int remaining;
viinfo("curpos=%ld ncolumns=%d\n", curpos, ncolumns);
/* Loop decrementing the cursor position for each repetition count. Break
* out early if we hit either the beginning of the text buffer, or the end
* of the previous line.
*/
for (remaining = (ncolumns < 1 ? 1 : ncolumns);
curpos > 0 && remaining > 0 && vi->text[curpos - 1] != '\n';
curpos--, remaining--)
{
}
return curpos;
}
/****************************************************************************
* Name: vi_cursorright
*
* Description:
* Move the cursor right 'ncolumns' columns in the text buffer (without
* moving to the next line). Note that a repetition count of 0 means to
* perform the movement once.
*
****************************************************************************/
static off_t vi_cursorright(FAR struct vi_s *vi, off_t curpos, int ncolumns)
{
int remaining;
viinfo("curpos=%ld ncolumns=%d\n", curpos, ncolumns);
/* Loop incrementing the cursor position for each repetition count. Break
* out early if we hit either the end of the text buffer, or the end of
* the line.
*/
for (remaining = (ncolumns < 1 ? 1 : ncolumns);
curpos < vi->textsize && remaining > 0 && vi->text[curpos] != '\n';
curpos++, remaining--)
{
}
#if 0
if (vi->text[curpos] == '\n' || (curpos == vi->textsize &&
vi->mode != MODE_INSERT && vi->mode != MODE_REPLACE))
{
curpos--;
}
#endif
return curpos;
}
/****************************************************************************
* Name: vi_gotoscreenbottom
*
* Description:
* Move the cursor to the bottom of the screen or the bottom line of
* the file if it doesn't occupy the entire screen.
*
****************************************************************************/
static int vi_gotoscreenbottom(FAR struct vi_s *vi, int rows)
{
off_t pos;
int row;
int target = rows > 0 ? rows >> 1 : vi->display.row - 2;
vi->curpos = vi->winpos;
row = 0;
while (row < target)
{
/* Get position of next row down */
pos = vi_nextline(vi, vi->curpos);
/* Test for end of file before bottom of screen */
if (pos == vi->curpos)
{
break;
}
if (pos == vi->textsize)
{
/* Test for empty line at the bottom */
row++;
vi->curpos = pos;
break;
}
vi->curpos = pos;
row++;
}
/* Report the location of the bottom row */
return row;
}
/****************************************************************************
* Name: vi_gotofirstnonwhite
*
* Description:
* Move the cursor to the first non-whitespace character on the
* current line.
*
****************************************************************************/
static void vi_gotofirstnonwhite(FAR struct vi_s *vi)
{
vi->curpos = vi_linebegin(vi, vi->curpos);
while (vi->curpos <= vi->textsize && (vi->text[vi->curpos] == ' ' ||
vi->text[vi->curpos] == '\t'))
{
vi->curpos++;
}
}
/****************************************************************************
* Name: vi_delforward
*
* Description:
* Delete characters from the current cursor position forward
*
****************************************************************************/
static void vi_delforward(FAR struct vi_s *vi)
{
off_t start;
off_t end;
bool at_end = false;
viinfo("curpos=%ld value=%ld\n", (long)vi->curpos, vi->value);
/* Test for empty file */
if (vi->textsize == 0)
{
return;
}
/* Test for empty line deletion and simply return */
if (vi->cursor.column == 0)
{
/* If at end of file, just return */
if (vi->curpos == vi->textsize ||
vi->text[vi->curpos] == '\n')
{
return;
}
}
/* Get the cursor position as if we would have move the cursor right N
* times (which might be <N characters).
*/
end = vi_cursorright(vi, vi->curpos, vi->value);
/* Test for deletion at end of the line */
if (end == vi->curpos && vi->cursor.column > 0)
{
end++;
at_end = true;
}
/* The difference from the current position then is the number of
* characters to be deleted.
*/
start = vi->curpos;
vi_yanktext(vi, start, end-1, true, true);
vi->curpos = start;
if (at_end)
{
vi->curpos--;
}
vi->redrawline = true;
}
/****************************************************************************
* Name: vi_delbackward
*
* Description:
* Delete characters before the current cursor position
*
****************************************************************************/
static void vi_delbackward(FAR struct vi_s *vi)
{
off_t start;
off_t end;
off_t x;
viinfo("curpos=%ld value=%ld\n", (long)vi->curpos, vi->value);
/* Test if we are at beginning of line */
if (vi->curpos == 0 || vi->text[vi->curpos] == '\n' ||
vi->text[vi->curpos-1] == '\n')
{
return;
}
/* Back up one character. This is where the deletion will end */
end = vi_cursorleft(vi, vi->curpos, 1);
/* Get the cursor position as if we would have move the cursor left N
* times (which might be <N characters).
*/
if (vi->value > 1)
{
start = vi_cursorleft(vi, end, vi->value -1);
}
else
{
start = end;
}
for (x = end; x >= start; x--)
{
/* Test if \n' in the range. Don't delete through \n */
if (vi->text[x] == '\n')
{
start = x + 1;
break;
}
}
/* The difference from the current position then is the number of
* characters to be deleted.
*/
vi_yanktext(vi, start, end, true, true);
vi->redrawline = true;
}
/****************************************************************************
* Name: vi_linerange
*
* Description:
* Return the start and end positions for N lines in the text buffer,
* beginning at the current line. This is logic common to yanking and
* deleting lines.
*
****************************************************************************/
static void vi_linerange(FAR struct vi_s *vi, off_t *start, off_t *end)
{
off_t next;
int nlines;
/* Get the offset in the text buffer to the beginning of the current line */
*start = vi_linebegin(vi, vi->curpos);
/* Move one line unless a repetition count was provided */
nlines = (vi->value > 0 ? vi->value : 1);
/* Search ahead to find the end of the last line to yank */
for (next = *start; nlines > 1; nlines--)
{
next = vi_nextline(vi, next);
}
*end = vi_lineend(vi, next);
if (*end != vi->textsize)
{
(*end)++;
}
}
/****************************************************************************
* Name: vi_delline
*
* Description:
* Delete N lines from the text buffer, beginning at the current line.
*
****************************************************************************/
static void vi_delline(FAR struct vi_s *vi)
{
/* Yank and remove text from the buffer */
vi_yank(vi, true);
vi->drawtoeos = true;
}
/****************************************************************************
* Name: vi_deltoeol
*
* Description:
* Delete to end of line.
*
****************************************************************************/
static void vi_deltoeol(FAR struct vi_s *vi)
{
int start;
int end;
/* If we are at the end of the line, then return */
if (vi->curpos == vi->textsize || vi->text[vi->curpos] == '\n')
{
return;
}
/* Determine start and end location */
start = vi->curpos;
end = vi_lineend(vi, vi->curpos);
if (end == vi->textsize || vi->text[end] == '\n')
{
end--;
}
/* Yank and remove text from the buffer */
vi_yanktext(vi, start, end, true, true);
if (start > 0 && start != vi->textsize && vi->text[start - 1] != '\n')
{
vi->curpos = start-1;
}
else
{
vi->curpos = start;
}
vi->redrawline = true;
}
/****************************************************************************
* Name: vi_yanktext
*
* Description:
* Yank specified text from the text buffer and delete if requested.
*
****************************************************************************/
static void vi_yanktext(FAR struct vi_s *vi, off_t start, off_t end,
bool yankcharmode, bool del_after_yank)
{
int append_lf = 0;
size_t alloc;
size_t size;
/* At end of file, in line yank mode, if there is no LF, we append one */
if (vi->text[end] != '\n' && !yankcharmode)
{
append_lf = 1;
}
/* Allocate a yank buffer big enough to hold the lines */
size = end - start + 1;
alloc = size + append_lf;
if (alloc < CONFIG_SYSTEM_VI_YANK_THRESHOLD)
{
alloc = CONFIG_SYSTEM_VI_YANK_THRESHOLD;
}
/* Free any previously yanked lines */
if (vi->yank)
{
/* Free the buffer only if it is too small or if it is larger
* than the YANK_THRESHOLD and we need less than that.
*/
if (alloc > vi->yankalloc ||
(alloc == CONFIG_SYSTEM_VI_YANK_THRESHOLD &&
vi->yankalloc > CONFIG_SYSTEM_VI_YANK_THRESHOLD))
{
free(vi->yank);
vi->yank = NULL;
}
}
/* Allocate buffer if not already allocated */
if (!vi->yank)
{
vi->yankalloc = alloc;
vi->yank = (FAR char *)malloc(vi->yankalloc);
}
vi->yankcharmode = yankcharmode;
if (!vi->yank)
{
vi_error(vi, g_fmtallocfail);
vi->yankalloc = 0;
vi->yanksize = 0;
return;
}
/* Copy the block from the text buffer to the yank buffer */
vi->yanksize = size;
memcpy(vi->yank, &vi->text[start], size);
/* Append \n if needed */
if (append_lf > 0)
{
vi->yank[vi->yanksize] = '\n';
}
/* Remove the yanked text from the text buffer */
if (del_after_yank)
{
vi_shrinktext(vi, start, vi->yanksize);
}
/* Account for appended lf in yankalloc */
vi->yanksize += append_lf;
}
/****************************************************************************
* Name: vi_yank
*
* Description:
* Remove N lines from the text buffer, beginning at the current line and
* copy the lines to an allocated yank buffer.
*
****************************************************************************/
static void vi_yank(FAR struct vi_s *vi, bool del_after_yank)
{
off_t start;
off_t end;
off_t yank_end;
off_t textsize;
int pos_increment = 0;
bool empty_last_line = false;
/* Get the offset in the text buffer corresponding to the range of lines to
* be yanked
*/
vi_linerange(vi, &start, &end);
textsize = vi->textsize;
/* Do end of file bounds checking */
if (end >= textsize)
{
end = textsize - 1;
}
if (start >= textsize)
{
start = textsize -1;
}
/* When yanking last line with \n, don't delete the \n */
yank_end = end;
if (del_after_yank && end == textsize - 1 && start != end &&
vi->text[end] == '\n')
{
yank_end--;
pos_increment = 1;
}
viinfo("start=%ld end=%ld\n", (long)start, (long)end);
/* Test if deleting last line with empty line above it */
if ((end > 0 && start == end && end == vi->textsize -1 &&
vi->text[end-1] == '\n') || (start > 1 && end + 1 ==
vi->textsize && vi->text[start-2] == '\n'))
{
empty_last_line = true;
}
vi_yanktext(vi, start, yank_end, 0, del_after_yank);
/* If the last line was yanked, then remove the '\n' on the
* previous line.
*/
if (end + 1 == textsize && start != end && del_after_yank)
{
vi_shrinktext(vi, vi->textsize-1, 1);
}
/* Place cursor at beginning of the line */
if (del_after_yank)
{
if (empty_last_line)
{
vi->curpos = vi->textsize;
}
else
{
vi->curpos = vi_linebegin(vi, vi->curpos + pos_increment);
}
}
}
/****************************************************************************
* Name: vi_paste
*
* Description:
* Copy line(s) from the yank buffer, and past them after the current line.
* The contents of the yank buffer are released.
*
****************************************************************************/
static void vi_paste(FAR struct vi_s *vi, bool paste_before)
{
off_t start;
off_t new_curpos;
int count;
viinfo("curpos=%ld yankalloc=%d\n", (long)vi->curpos, (long)vi->yankalloc);
/* Make sure there is something to be pasted */
if (!vi->yank || vi->yanksize <= 0)
{
return;
}
/* Get the command count */
count = vi->value > 0 ? vi->value : 1;
if (count > 1)
{
vi->fullredraw = true;
}
/* Test for char mode paste buffer */
while (count > 0)
{
if (vi->yankcharmode)
{
off_t pos;
/* Paste at next col to the right of cursor */
if (vi->text[vi->curpos] == '\n' || vi->curpos == vi->textsize ||
paste_before)
{
pos = vi->curpos;
}
else
{
pos = vi->curpos + 1;
}
if (vi_extendtext(vi, pos, vi->yanksize))
{
/* Copy the contents of the yank buffer into the text buffer
* at the position where the start of the next line was.
*/
memcpy(&vi->text[pos], vi->yank, vi->yanksize);
/* Advance the cursor */
vi->curpos = vi->curpos + vi->yanksize;
if (vi->curpos > vi->textsize || vi->text[vi->curpos] == '\n')
{
vi->curpos--;
}
}
}
else
{
off_t size;
/* Paste at the beginning of the next line */
if (paste_before)
{
start = vi_linebegin(vi, vi->curpos);
}
else
{
start = vi_nextline(vi, vi->curpos);
}
size = vi->yanksize;
/* Test if pasting at end of file */
new_curpos = start;
if ((start >= vi->textsize && vi->text[vi->textsize-1] != '\n') ||
vi->curpos == vi->textsize)
{
off_t textsize = vi->textsize;
bool at_end = vi->curpos == vi->textsize;
vi->curpos = vi->textsize;
vi_insertch(vi, '\n');
start = vi->textsize;
new_curpos = start;
/* Don't append the \n' in the yank buffer */
if (vi->text[textsize-1] != '\n' || at_end)
{
size--;
}
}
/* Ensure start <= textsize */
else if (start >= vi->textsize)
{
start = vi->textsize;
new_curpos = start;
vi->fullredraw = true;
}
/* Reallocate the text buffer to hold the yank buffer contents at
* the beginning of the next line.
*/
if (vi_extendtext(vi, start, size))
{
/* Copy the contents of the yank buffer into the text buffer
* at the position where the start of the next line was.
*/
memcpy(&vi->text[start], vi->yank, size);
/* Advance to next line */
vi->curpos = new_curpos;
}
}
count--;
}
/* Redraw everything below this point */
vi->drawtoeos = true;
}
/****************************************************************************
* Name: vi_join
*
* Description:
* Join line below with current line.
*
****************************************************************************/
static void vi_join(FAR struct vi_s *vi)
{
off_t start;
off_t end;
/* Test if we are at end of file */
if (vi->curpos + 1 >= vi->textsize)
{
return;
}
start = vi_lineend(vi, vi->curpos);
/* Ensure the line ends with '\n' */
if (vi->text[start+1] != '\n')
{
return;
}
/* Convert the '\n' to a space */
vi->text[++start] = ' ';
end = start + 1;
/* Skip all spaces and tabs on next line */
while ((vi->text[end] == ' ' || vi->text[end] == '\t') &&
end < vi->textsize)
{
end++;
}
if (start+1 != end)
{
vi_shrinktext(vi, start+1, end - (start+1));
}
vi->curpos = start;
vi->drawtoeos = true;
}
/****************************************************************************
* Name: vi_gotoline
*
* Description:
* Position the cursor at the line specified by vi->value. If
* vi->value is zero, then the cursor is position at the end of the text
* buffer.
*
****************************************************************************/
static void vi_gotoline(FAR struct vi_s *vi)
{
viinfo("curpos=%ld value=%ld\n", (long)vi->curpos, vi->value);
/* Special case the first line */
if (vi->value == 1)
{
vi->curpos = 0;
}
/* Work harder to position to lines in the middle */
else if (vi->value > 0)
{
uint32_t line;
/* Got to the line == value */
for (line = vi->value, vi->curpos = 0;
--line > 0 && vi->curpos < vi->textsize;
)
{
vi->curpos = vi_nextline(vi, vi->curpos);
}
}
/* No value means to go to beginning of the last line */
else
{
/* Get the beginning of the last line */
vi->curpos = vi_linebegin(vi, vi->textsize);
}
vi->fullredraw = true;
}
/****************************************************************************
* Name: vi_chartype
*
* Description:
* Determine and return the type of character (i.e. alpha, space,
* punctuation).
*
****************************************************************************/
static int vi_chartype(char ch)
{
int type;
if (ch == ' ' || ch == '\t')
{
type = VI_CHAR_SPACE;
}
/* Test for alpha, numeric or '_' */
else if (isalnum(ch) || ch == '_')
{
type = VI_CHAR_ALPHA;
}
/* Test for CR or NL */
else if (ch == '\r' || ch == '\n')
{
type = VI_CHAR_CRLF;
}
/* Must be punctuation */
else
{
type = VI_CHAR_PUNCT;
}
return type;
}
/****************************************************************************
* Name: vi_findnextword
*
* Description:
* Find the position in the text buffer of the start of the next word.
*
****************************************************************************/
static off_t vi_findnextword(FAR struct vi_s *vi)
{
int srch_type;
int pos_type;
off_t pos;
/* Get the type of character under the cursor so we know what the
* next "word" looks like.
*/
srch_type = vi_chartype(vi->text[vi->curpos]);
pos = vi->curpos + 1;
for (; pos < vi->textsize; pos++)
{
/* Get type of the next character */
pos_type = vi_chartype(vi->text[pos]);
/* Skip CR and NL */
if (pos_type == VI_CHAR_CRLF)
{
/* Change to search type SPACE */
srch_type = VI_CHAR_SPACE;
continue;
}
/* We we were over a space, then any non-space is the next word */
if (srch_type == VI_CHAR_SPACE &&
pos_type != VI_CHAR_SPACE)
{
break;
}
/* Test for next punctuation if search type is alpha */
if (srch_type == VI_CHAR_ALPHA &&
pos_type == VI_CHAR_PUNCT)
{
break;
}
/* Test for next alpha if search type is punctuation */
if (srch_type == VI_CHAR_PUNCT &&
pos_type == VI_CHAR_ALPHA)
{
break;
}
/* Test for alpha search followed by space. Then switch the search type
* to space so we find whatever is next.
*/
if ((srch_type == VI_CHAR_ALPHA || srch_type == VI_CHAR_PUNCT) &&
pos_type == VI_CHAR_SPACE)
{
srch_type = VI_CHAR_SPACE;
}
}
/* Limit position to within the valid text range */
if (pos == vi->textsize)
{
pos--;
}
/* Return the position of the next word */
return pos;
}
/****************************************************************************
* Name: vi_gotonextword
*
* Description:
* Position the cursor at the start of the next word.
*
****************************************************************************/
static void vi_gotonextword(FAR struct vi_s *vi)
{
int count;
int x;
off_t start = vi->curpos;
off_t end;
off_t pos;
bool crfound;
/* Loop for the specified search count */
count = vi->value > 0 ? vi->value : 1;
for (x = 0; x < count; x++ )
{
/* Get position of next word */
vi->curpos = vi_findnextword(vi);
}
/* Test if yank, delete or change are armed */
if (vi->yankarm || vi->delarm || vi->chgarm)
{
/* Rewind so we don't yank skipped whitespace */
pos = vi->curpos;
crfound = false;
while ((vi->text[pos-1] == ' ' || vi->text[pos-1] == '\t' ||
vi->text[pos-1] == '\n') && pos > start)
{
/* We rewind only if '\n' found before non-space */
pos--;
if (vi->text[pos] == '\n')
{
crfound = true;
}
}
if (crfound)
{
vi->curpos = pos;
}
/* If the yank / delete count is 1, then limit the yank/delete so it
* doesn't contain any '\n' characters.
*/
if (count == 1)
{
/* Scan the text range and look for '\n' */
for (x = start; x < vi->curpos; x++)
{
/* Test for '\n' */
if (vi->text[x] == '\n')
{
/* Modify the yank / delete range */
vi->curpos = x;
break;
}
}
}
else
{
/* Multi-line delete? */
vi->fullredraw = vi->delarm || vi->chgarm;
}
/* Perform the yank */
end = vi->curpos + 1 == vi->textsize ? vi->curpos : vi->curpos - 1;
if (vi->chgarm)
{
end--;
}
/* Yank text if it isn't a single \n character */
if (!(start == end && vi->text[start] == '\n'))
{
vi_yanktext(vi, start, end, 1, vi->delarm | vi->chgarm);
}
if (vi->delarm | vi->chgarm)
{
/* Redraw line if text deleted */
vi->redrawline = true;
}
/* Restore the original curpos */
vi->curpos = start;
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
/* Setup command repeat */
if (vi->delarm | vi->chgarm)
{
vi_saverepeat(vi, vi->delarm ? 'd' : 'c');
vi_appendrepeat(vi, 'w');
}
#endif
/* If change text is armed, then enter insert mode */
if (vi->chgarm)
{
vi_setmode(vi, MODE_INSERT, 0);
}
vi->delarm = false;
vi->chgarm = false;
vi->yankarm = false;
}
}
/****************************************************************************
* Name: vi_findprevword
*
* Description:
* Find the position in the text buffer of the start of the previous word.
*
****************************************************************************/
static off_t vi_findprevword(FAR struct vi_s *vi)
{
int srch_type;
int pos_type;
off_t pos;
/* If we are basically at the beginning of the file, then the task
* is simple.
*/
if (vi->curpos < 2)
{
return 0;
}
/* Get the type of character under the cursor so we know what the
* next "word" looks like.
*/
srch_type = vi_chartype(vi->text[vi->curpos]);
pos = vi->curpos - 1;
pos_type = vi_chartype(vi->text[pos]);
/* Test if we are at the beginning of a word */
if (srch_type == pos_type)
{
/* Not at beginning of word. Find beginning of word. */
while (pos > 0)
{
pos_type = vi_chartype(vi->text[pos-1]);
if (pos_type != srch_type && pos_type != VI_CHAR_CRLF)
{
break;
}
pos--;
}
if ((srch_type != VI_CHAR_SPACE && srch_type != VI_CHAR_CRLF) ||
pos == 0)
{
return pos;
}
/* We found the start of a string of spaces. Decrement to first
* non-space character.
*/
pos_type = vi_chartype(vi->text[--pos]);
}
/* If the previous char is space, then skip them */
while ((pos_type == VI_CHAR_SPACE || pos_type == VI_CHAR_CRLF) && pos > 0)
{
pos_type = vi_chartype(vi->text[--pos]);
}
if (pos == 0)
{
return pos;
}
/* Now find beginning of this new type */
srch_type = vi_chartype(vi->text[pos]);
while (pos > 0 && vi_chartype(vi->text[pos-1]) == srch_type)
{
pos--;
}
/* Return the position of the next word */
return pos;
}
/****************************************************************************
* Name: vi_gotoprevword
*
* Description:
* Position the cursor at the start of the previous word.
*
****************************************************************************/
static void vi_gotoprevword(FAR struct vi_s *vi)
{
int count;
/* Loop for the specified search count */
count = vi->value > 0 ? vi->value : 1;
while (count > 0)
{
/* Get position of next word */
vi->curpos = vi_findprevword(vi);
count--;
}
}
/****************************************************************************
* Name: vi_bottom_line_debug
*
* Description:
* Print text and paste buffers on bottom line for debug purposes
*
****************************************************************************/
#ifdef ENABLE_BOTTOM_LINE_DEBUG
static void vi_bottom_line_debug(FAR struct vi_s *vi)
{
off_t pos;
int column;
vi_clearbottomline(vi);
vi_putch(vi, '"');
pos = 0;
column = 0;
while (pos < vi->textsize && column < vi->display.column)
{
if (vi->text[pos] == '\n')
{
vi_putch(vi, '\\');
vi_putch(vi, 'n');
}
else if (vi->text[pos] == '\t')
{
vi_putch(vi, '\\');
vi_putch(vi, 'n');
}
else
{
vi_putch(vi, vi->text[pos]);
}
pos++;
column++;
}
vi_putch(vi, '"');
if (!vi->yank)
{
return;
}
vi_putch(vi, ' ');
vi_putch(vi, '"');
pos = 0;
while (pos < vi->yanksize && column < vi->display.column)
{
if (vi->yank[pos] == '\n')
{
vi_putch(vi, '\\');
vi_putch(vi, 'n');
}
else if (vi->yank[pos] == '\t')
{
vi_putch(vi, '\\');
vi_putch(vi, 'n');
}
else
{
vi_putch(vi, vi->yank[pos]);
}
pos++;
}
vi_putch(vi, '"');
}
#endif /* ENABLE_BOTTOM_LINE_DEBUG */
/****************************************************************************
* Name: vi_findnext
*
* Description:
* Perform find operation again in forward direction
*
****************************************************************************/
void vi_findnext(FAR struct vi_s *vi)
{
if (vi->curpos < vi->textsize)
{
vi->curpos++;
}
/* Search for string */
if (!vi_findstring(vi))
{
/* Restore original pos if not found */
vi->curpos--;
VI_BEL(vi);
}
}
/****************************************************************************
* Name: vi_findprev
*
* Description:
* Perform find operation again in reverse direction
*
****************************************************************************/
void vi_findprev(FAR struct vi_s *vi)
{
off_t pos = vi->curpos;
/* Move the cursor to the left */
if (vi->curpos > 0)
{
vi->curpos--;
}
else
{
vi->curpos = vi->textsize - strlen(vi->findstr);
}
/* Perform the search */
if (!vi_revfindstring(vi))
{
/* Restore the position if not found */
vi->curpos = pos;
}
}
/****************************************************************************
* Name: vi_saverepeat
*
* Description:
* Save ch as the first command repeat entry.
*
****************************************************************************/
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
static void vi_saverepeat(FAR struct vi_s *vi, uint16_t ch)
{
/* If we are in command repeat mode, then don't initialize */
if (vi->cmdrepeat)
{
return;
}
vi->cmdcount = 0;
vi->cmdindex = 0;
if (ch < 256)
{
vi->cmdbuf[vi->cmdcount++] = ch;
vi->repeatvalue = vi->value;
}
}
#endif /* CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT */
/****************************************************************************
* Name: vi_appendrepeat
*
* Description:
* Save ch as the next command repeat entry.
*
****************************************************************************/
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
static void vi_appendrepeat(FAR struct vi_s *vi, uint16_t ch)
{
/* If we are in command repeat mode, then don't append */
if (vi->cmdrepeat || vi->cmdcount == 0 || ch > 255)
{
return;
}
/* Don't overflow the command repeat buffer */
if (vi->cmdcount < CMD_BUFSIZE)
{
vi->cmdbuf[vi->cmdcount++] = ch;
}
}
#endif /* CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT */
/****************************************************************************
* Name: vi_cmd_mode
*
* Description:
* Command mode loop
*
****************************************************************************/
static void vi_cmd_mode(FAR struct vi_s *vi)
{
viinfo("Enter command mode\n");
/* Loop while we are in command mode */
while (vi->mode == MODE_COMMAND)
{
bool preserve;
int ch;
/* Make sure that the display reflects the current state */
vi_showtext(vi);
vi_showlinecol(vi);
vi_setcursor(vi, vi->cursor.row, vi->cursor.column);
/* Get the next character from the input */
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
/* Test for end of command repeat */
if (vi->cmdrepeat && vi->cmdindex == vi->cmdcount)
{
/* Terminate the command repeat */
vi->cmdrepeat = false;
}
/* Test for active cmdrepeat */
if (vi->cmdrepeat)
{
/* Read next command from command buffer */
ch = vi->cmdbuf[vi->cmdindex++];
}
else
#endif
{
ch = vi_getch(vi);
}
/* Handle numeric input. Zero (0) with no preceding value is a
* special case: It means to go to the beginning o the line.
*/
if (isdigit(ch) && (vi->value > 0 || ch != '0'))
{
uint32_t tmp = 10 * vi->value + (ch - '0');
if (tmp > UINT16_MAX)
{
tmp = UINT16_MAX;
}
/* Update the command repetition count */
vi->value = tmp;
viinfo("Value=%ld\n", vi->value);
continue;
}
/* Allow the following during yank / delete modes */
if (ch != 'f' && ch != 't' && ch != 'w')
{
/* Anything other than 'd' disarms line deletion */
if (ch != 'd')
{
vi->delarm = false;
}
/* Anything other than 'y' disarms line yanking */
if (ch != 'y')
{
vi->yankarm = false;
}
/* Anything other than 'c' disarms line yanking */
if (ch != 'c')
{
vi->chgarm = false;
}
}
/* Anything other than'g' disarms goto top */
if (ch != 'g')
{
vi->toparm = false;
}
/* Anything other than'Z' disarms :wq */
if (ch != 'Z')
{
vi->wqarm = false;
}
/* Test for empty file */
if (vi->textsize == 0)
{
/* We need some text before we can do anything. Only accept
* text insertion commands.
*/
if (ch != KEY_CMDMODE_APPEND && ch != KEY_CMDMODE_INSERT &&
ch != KEY_CMDMODE_OPENBELOW && ch != KEY_CMDMODE_APPENDEND &&
ch != KEY_CMDMODE_INSBEGIN && ch != KEY_CMDMODE_OPENABOVE &&
ch != KEY_CMDMODE_COLONMODE)
{
continue;
}
}
/* Any key press clears the error message */
vi->error = false;
/* Then handle the non-numeric character. Normally the accumulated
* value will be reset after processing the command. There are a few
* exceptions; 'preserve' will be set to 'true' in those exceptional
* cases.
*/
preserve = false;
vi->updatereqcol = true;
switch (ch)
{
case KEY_CMDMODE_UP: /* Move the cursor up one line */
case KEY_UP: /* Move the cursor up one line */
{
vi->updatereqcol = false;
vi_cusorup(vi, vi->value);
}
break;
case KEY_CMDMODE_DOWN: /* Move the cursor down one line */
case KEY_DOWN: /* Move the cursor down one line */
{
vi->updatereqcol = false;
vi_cursordown(vi, vi->value);
}
break;
case KEY_CMDMODE_LEFT: /* Move the cursor left N characters */
case KEY_LEFT: /* Move the cursor left N characters */
{
vi->curpos = vi_cursorleft(vi, vi->curpos, vi->value);
}
break;
case KEY_CMDMODE_RIGHT: /* Move the cursor right one character */
case KEY_RIGHT: /* Move the cursor right one character */
{
if (vi->text[vi->curpos] != '\n' &&
vi->text[vi->curpos+1] != '\n')
{
vi->curpos = vi_cursorright(vi, vi->curpos, vi->value);
if (vi->curpos >= vi->textsize)
{
vi->curpos = vi->textsize - 1;
}
}
}
break;
case KEY_CMDMODE_BEGINLINE: /* Move cursor to start of current line */
case KEY_HOME:
{
vi->curpos = vi_linebegin(vi, vi->curpos);
}
break;
case KEY_CMDMODE_ENDLINE: /* Move cursor to end of current line */
case KEY_END:
{
vi->curpos = vi_lineend(vi, vi->curpos);
vi->reqcolumn = 65535;
vi->updatereqcol = false;
}
break;
case KEY_CMDMODE_PAGEUP: /* Move up (backward) one screen */
case KEY_PPAGE:
{
vi->updatereqcol = false;
vi_cusorup(vi, vi->display.row);
}
break;
case KEY_CMDMODE_PAGEDOWN: /* Move down (forward) one screen */
case KEY_NPAGE:
{
vi->updatereqcol = false;
vi_cursordown(vi, vi->display.row);
}
break;
case KEY_CMDMODE_HALFUP: /* Move up (backward) one screen */
{
vi->updatereqcol = false;
vi_cusorup(vi, vi->display.row >> 1);
}
break;
case KEY_CMDMODE_HALFDOWN: /* Move down (forward) one half screen */
{
vi->updatereqcol = false;
vi_cursordown(vi, vi->display.row >> 1);
}
break;
case KEY_CMDMODE_TOP: /* Move to top of screen */
{
vi->curpos = vi->winpos;
}
break;
case KEY_CMDMODE_BOTTOM: /* Move to bottom of screen */
{
vi_gotoscreenbottom(vi, 0);
}
break;
case KEY_CMDMODE_MIDDLE: /* Move to middle of screen */
{
/* Find bottom row number, then move to half that */
off_t pos = vi_gotoscreenbottom(vi, 0);
vi_gotoscreenbottom(vi, pos);
}
break;
case KEY_CMDMODE_FIRSTCHAR:
{
vi_gotofirstnonwhite(vi);
}
break;
case KEY_CMDMODE_GOTOTOP: /* Go to top of document */
{
if (vi->toparm)
{
vi->curpos = 0;
vi->redrawline = true;
vi->toparm = false;
}
else
{
vi->toparm = true;
}
}
break;
case KEY_CMDMODE_FINDNEXT:
{
if (vi->revfind)
{
vi_findprev(vi);
}
else
{
vi_findnext(vi);
}
break;
}
case KEY_CMDMODE_FINDPREV:
{
if (vi->revfind)
{
vi_findnext(vi);
}
else
{
vi_findprev(vi);
}
break;
}
break;
case ASCII_BS: /* Delete N characters before the cursor */
{
/* Move the cursor to the left */
if (vi->curpos > 0)
{
vi->curpos--;
/* If we moved to \n on the previous line, skip it */
if (vi->curpos > 0 && vi->text[vi->curpos] == '\n')
{
vi->curpos--;
}
}
}
break;
case KEY_CMDMODE_DEL_LINE: /* Delete the current line */
{
if (vi->delarm)
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
vi_appendrepeat(vi, ch);
#endif
vi_delline(vi);
vi->delarm = false;
}
else
{
vi->delarm = true;
preserve = true;
}
}
break;
case KEY_CMDMODE_CHANGE:
{
if (vi->chgarm)
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
vi_appendrepeat(vi, ch);
#endif
vi_gotofirstnonwhite(vi);
vi_deltoeol(vi);
vi_setmode(vi, MODE_INSERT, 0);
if (vi->curpos == vi->textsize)
{
vi->curpos = vi_cursorright(vi, vi->curpos, 1) + 1;
}
else
{
vi->curpos = vi_cursorright(vi, vi->curpos, 1);
}
vi->chgarm = false;
}
else
{
vi->chgarm = true;
preserve = true;
}
}
break;
case KEY_CMDMODE_DELTOEOL: /* Delete to end of current line */
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
vi_deltoeol(vi);
}
break;
case KEY_CMDMODE_DELBACKWARD: /* Delete from cursor forward */
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
vi_delbackward(vi);
}
break;
case KEY_CMDMODE_YANK: /* Yank the current line(s) into the buffer */
{
if (vi->yankarm)
{
vi_yank(vi, false);
vi->yankarm = false;
}
else
{
vi->yankarm = true;
preserve = true;
}
}
break;
case KEY_CMDMODE_PASTE: /* Paste line(s) from into text after current line */
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
vi_paste(vi, false);
}
break;
case KEY_CMDMODE_PASTEBEFORE: /* Paste text before cursor position */
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
vi_paste(vi, true);
}
break;
case KEY_CMDMODE_REPLACECH: /* Replace character(s) under cursor */
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
vi_setmode(vi, SUBMODE_REPLACECH, vi->value);
preserve = true;
}
break;
case KEY_CMDMODE_REPLACE: /* Replace character(s) under cursor until ESC */
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
vi_setmode(vi, MODE_REPLACE, 0);
}
break; /* Not implemented */
case KEY_CMDMODE_FINDINLINE: /* Find character(s) in current line */
case KEY_CMDMODE_TFINDINLINE: /* Find character(s) in current line */
{
vi->tfind = ch == KEY_CMDMODE_TFINDINLINE;
vi->mode = MODE_FINDINLINE;
preserve = true;
}
break;
case KEY_CMDMODE_OPENBELOW: /* Enter insertion mode in new line below current */
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
vi_setmode(vi, MODE_INSERT, 0);
/* Go forward to the end of the current line */
vi->curpos = vi_lineend(vi, vi->curpos);
if (vi->curpos != vi->textsize)
{
/* Include the '\n' */
vi->curpos++;
}
/* Insert a newline to break the line. The cursor now points
* beginning of the new line.
*/
vi_insertch(vi, '\n');
/* Then enter insert mode */
vi->drawtoeos = true;
}
break;
case KEY_CMDMODE_OPENABOVE: /* Enter insertion mode in new line above current */
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
/* Back up to the beginning of the end of the previous line */
off_t pos = vi_linebegin(vi, vi->curpos);
if (pos == 0)
{
/* Insert newline at beginning of file, then move to previous
* line.
*/
vi->curpos = 0;
vi_insertch(vi, '\n');
vi->curpos = vi_prevline(vi, vi->curpos);
}
else
{
/* Insert a newline to open the line. The cursor will now
* point to thebeginning of newly openly line before the
* current line.
*/
pos = vi_prevline(vi, pos);
vi->curpos = vi_lineend(vi, pos)+1;
vi_insertch(vi, '\n');
}
/* Then enter insert mode */
vi_setmode(vi, MODE_INSERT, 0);
vi->drawtoeos = true;
}
break;
case KEY_CMDMODE_CHANGETOEOL: /* Delete to end of current line */
{
/* First delete to end of line */
vi_deltoeol(vi);
}
/* Now enter insert mode by falling through the case */
case KEY_CMDMODE_APPEND: /* Enter insertion mode after the current
* cursor position */
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
vi_setmode(vi, MODE_INSERT, 0);
if (vi->curpos == vi->textsize)
{
vi->curpos = vi_cursorright(vi, vi->curpos, 1) + 1;
}
else
{
vi->curpos = vi_cursorright(vi, vi->curpos, 1);
}
}
break;
case KEY_CMDMODE_APPENDEND: /* Enter insertion mode at the end of the current line */
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
vi_setmode(vi, MODE_INSERT, 0);
vi->curpos = vi_lineend(vi, vi->curpos) + 1;
}
break;
case KEY_CMDMODE_SUBSTITUTE:
case KEY_CMDMODE_DEL: /* Delete N characters at the cursor */
case KEY_DC:
case ASCII_DEL:
{
off_t pos = vi->curpos;
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
/* If we are at the end of the line, then delete backward */
if (vi->text[pos] == '\n')
{
/* Nothing to do */
break;
}
else if (pos+1 != vi->textsize && vi->text[pos+1] == '\n')
{
if (pos > 0)
{
vi_delforward(vi);
vi->curpos = vi_cursorleft(vi, vi->curpos, 1);
}
}
else
{
vi_delforward(vi);
vi->redrawline = true;
}
}
/* For 's'ubstitute key, we go into insert mode */
if (ch == KEY_CMDMODE_SUBSTITUTE)
{
vi_setmode(vi, MODE_INSERT, 0);
}
break;
case KEY_CMDMODE_INSBEGIN: /* Enter insertion mode at the beginning of the current line */
{
vi->curpos = vi_linebegin(vi, vi->curpos);
}
/* Fall through */
case KEY_CMDMODE_INSERT: /* Enter insertion mode before the current cursor position */
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
vi_setmode(vi, MODE_INSERT, 0);
}
break;
case KEY_CMDMODE_JOIN: /* Join line below with current line */
{
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
vi_saverepeat(vi, ch);
#endif
vi_join(vi);
}
break;
case KEY_CMDMODE_COLONMODE: /* Enter : command sub-mode */
{
vi->updatereqcol = false;
vi_setsubmode(vi, SUBMODE_COLON, ':', 0);
}
break;
case KEY_CMDMODE_SAVEQUIT: /* Two of these is the same as :wq */
{
if (vi->wqarm)
{
/* Emulate :wq */
strcpy(vi->scratch, "wq");
vi->cmdlen = 2;
vi_parsecolon(vi);
/* If save quit succeeds, we won't return */
}
else
{
vi->wqarm = true;
}
}
break;
case KEY_CMDMODE_FINDMODE: /* Enter / find sub-mode */
{
vi->updatereqcol = false;
vi_setsubmode(vi, SUBMODE_FIND, '/', 0);
}
break;
case KEY_CMDMODE_REVFINDMODE: /* Enter / find sub-mode */
{
vi->updatereqcol = false;
vi_setsubmode(vi, SUBMODE_REVFIND, '?', 0);
}
break;
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
case KEY_CMDMODE_REPEAT: /* Repeat the last command */
{
if (vi->cmdcount < CMD_BUFSIZE)
{
vi->cmdindex = 0;
vi->cmdrepeat = true;
vi->value = vi->value > 0 ? vi->value : vi->repeatvalue > 0 ?
vi->repeatvalue : 1;
preserve = true;
}
else
{
VI_BEL(vi);
}
}
break;
#endif
case KEY_CMDMODE_GOTO: /* Go to line specified by the accumulated value */
{
vi_gotoline(vi);
}
break;
case KEY_CMDMODE_WORDFWD: /* Go to line specified by the accumulated value */
{
vi_gotonextword(vi);
}
break;
case KEY_CMDMODE_WORDBACK: /* Go to line specified by the accumulated value */
{
vi_gotoprevword(vi);
}
break;
#if defined(CONFIG_EOL_IS_CR)
case KEY_CMDMODE_NEXTLINE:
case '\r': /* CR terminates line */
{
vi->curpos = vi_nextline(vi, vi->curpos);
vi_gotofirstnonwhite(vi);
}
break;
#elif defined(CONFIG_EOL_IS_BOTH_CRLF)
case '\r': /* Wait for the LF */
break;
#endif
#if defined(CONFIG_EOL_IS_LF) || defined(CONFIG_EOL_IS_BOTH_CRLF)
case KEY_CMDMODE_NEXTLINE:
case '\n': /* LF terminates line */
{
vi->curpos = vi_nextline(vi, vi->curpos);
vi_gotofirstnonwhite(vi);
}
break;
#endif
#ifdef CONFIG_EOL_IS_EITHER_CRLF
case KEY_CMDMODE_NEXTLINE:
case '\r': /* Either CR or LF terminates line */
case '\n':
{
vi->curpos = vi_nextline(vi, vi->curpos);
vi_gotofirstnonwhite(vi);
}
break;
#endif
case KEY_CMDMODE_PREVLINE:
{
vi->curpos = vi_prevline(vi, vi->curpos);
vi_gotofirstnonwhite(vi);
}
break;
/* Unimplemented and invalid commands */
case KEY_CMDMODE_REDRAW: /* Redraws the screen */
case KEY_CMDMODE_REDRAW2: /* Redraws the screen, removing deleted lines */
case KEY_CMDMODE_MARK: /* Place a mark beginning at the current cursor position */
default:
{
if (ch == -1)
{
continue;
}
else
{
VI_BEL(vi);
}
}
break;
}
/* Any non-numeric input will reset the accumulated value (after it has
* been used). There are a few exceptions:
*
* - For the double character sequences, we need to retain the value
* until the next character is entered.
* - If we are changing modes, then we may need to preserve the 'value'
* as well; in some cases settings are passed to the new mode in
* 'value' (vi_setmode() will have set or cleared 'value'
* appropriately).
*/
if (!preserve)
{
vi->value = 0;
}
}
}
/****************************************************************************
* Common Sub-Mode Functions
****************************************************************************/
/****************************************************************************
* Name: vi_cmdch
*
* Description:
* Insert one character into the data entry line
*
****************************************************************************/
static void vi_cmdch(FAR struct vi_s *vi, char ch)
{
int index = vi->cmdlen;
int next = index + 1;
viinfo("cmdlen=%d ch=%c[%02x]\n", vi->cmdlen, isprint(ch) ? ch : '.', ch);
/* Abort gracelessly if the scratch buffer becomes full */
if (next >= SCRATCH_BUFSIZE)
{
vi_exitsubmode(vi, MODE_COMMAND);
return;
}
/* Add the new character to the scratch buffer */
vi->scratch[index] = ch;
vi->cmdlen = next;
/* Update the cursor position */
vi->cursor.column = next + 1;
/* And add the new character to the display */
vi_putch(vi, ch);
if (ch == '\n')
{
vi->drawtoeos = true;
}
}
/****************************************************************************
* Name: vi_cmdbackspace
*
* Description:
* Process a backspace character in the data entry line
*
****************************************************************************/
static void vi_cmdbackspace(FAR struct vi_s *vi)
{
viinfo("cmdlen=%d\n", vi->cmdlen);
if (vi->cmdlen > 0)
{
vi_setcursor(vi, vi->display.row - 1, vi->cmdlen);
vi_clrtoeol(vi);
/* Update the command index and cursor position */
vi->cursor.column = vi->cmdlen;
/* Decrement the number of characters on in the command */
vi->cmdlen--;
}
}
/****************************************************************************
* Colon Data Entry Sub-Mode Functions
****************************************************************************/
/****************************************************************************
* Name: vi_parsecolon
*
* Description:
* Parse the colon command collected in the scratch buffer
*
****************************************************************************/
static void vi_parsecolon(FAR struct vi_s *vi)
{
FAR const char *filename = NULL;
uint8_t cmd = CMD_NONE;
bool done = false;
bool forced;
int col;
int ch;
viinfo("Parse: \"%s\"\n", vi->scratch);
/* NUL terminate the command */
vi->scratch[vi->cmdlen] = '\0';
/* Convert "wq" into "qw" */
if (vi->cmdlen > 1 && vi->scratch[0] == KEY_COLMODE_WRITE &&
vi->scratch[1] == KEY_COLMODE_QUIT)
{
vi->scratch[0] = KEY_COLMODE_QUIT;
vi->scratch[1] = KEY_COLMODE_WRITE;
}
/* Then parse the contents of the scratch buffer */
for (col = 0; col < vi->cmdlen && !done; col++)
{
/* Get the next command character from the scratch buffer */
ch = vi->scratch[col];
/* Check if the next after that is KEY_COLMODE_FORCE */
forced = false;
if (col < vi->cmdlen && vi->scratch[col + 1] == KEY_COLMODE_FORCE)
{
/* Yes.. the operation is forced */
forced = true;
col++;
}
/* Then process the command character */
switch (ch)
{
case KEY_COLMODE_READ:
{
/* Reading a file should not be forced */
if (cmd == CMD_NONE && !forced)
{
cmd = CMD_READ;
}
else
{
/* The read operation is not compatible with writing or
* quitting
*/
goto errout_bad_command;
}
}
break;
case KEY_COLMODE_WRITE:
{
/* Are we just writing? Or writing then quitting? */
if (cmd == CMD_NONE)
{
/* Just writing.. do we force overwriting? */
cmd = (forced ? CMD_OWRITE : CMD_WRITE);
}
else if (cmd == CMD_QUIT)
{
/* Both ... do we force overwriting the file? */
cmd = (forced ? CMD_OWRITE_QUIT : CMD_WRITE_QUIT);
}
else
{
/* Anything else, including a forced quit is a syntax error */
goto errout_bad_command;
}
}
break;
case KEY_COLMODE_QUIT:
{
/* Are we just quitting? Or writing then quitting? */
if (cmd == CMD_NONE)
{
/* Just quitting... should we discard any changes? */
cmd = (forced ? CMD_DISCARD : CMD_QUIT);
}
/* If we are also writing, then it makes no sense to force the
* quit operation.
*/
else if (cmd == CMD_WRITE && !forced)
{
cmd = CMD_WRITE_QUIT;
}
else if (cmd == CMD_OWRITE && !forced)
{
cmd = CMD_OWRITE_QUIT;
}
else
{
/* Quit is not compatible with reading */
goto errout_bad_command;
}
}
break;
default:
{
/* Ignore whitespace */
if (ch != ' ')
{
/* Anything else terminates the loop */
done = true;
/* If there is anything else on the line, then it must be
* a file name. If we are writing (or reading with an
* empty text buffer), then we will need to copy the file
* into the filename storage area.
*/
if (ch != '\0')
{
/* For now, just remember where the file is in the
* scratch buffer.
*/
filename = &vi->scratch[col];
}
}
}
break;
}
}
/* Did we find any valid command? A read command requires a filename.
* A filename where one is not needed is also an error.
*/
viinfo("cmd=%d filename=\"%s\"\n", cmd, vi->filename);
if (cmd == CMD_NONE || (IS_READ(cmd) && !filename) ||
(!USES_FILE(cmd) && filename))
{
goto errout_bad_command;
}
/* Are we writing to a new filename? If we are not forcing the write,
* then we have to check if the file exists.
*/
if (filename && IS_NOWRITE(cmd))
{
/* Check if the file exists */
if (vi_checkfile(vi, filename))
{
/* It does... show an error and exit */
vi_error(vi, g_fmtfileexists);
goto errout;
}
}
/* Check if we are trying to quit with un-saved changes. The user must
* force quitting in this case.
*/
if (vi->modified && IS_NDISCARD(cmd))
{
/* Show an error and exit */
vi_error(vi, g_fmtmodified);
goto errout;
}
/* Are we now committed to reading the file? */
if (IS_READ(cmd))
{
/* Was the text buffer empty? */
bool empty = (vi->textsize == 0);
/* Yes.. get the cursor position of the beginning of the next line */
off_t pos = vi_nextline(vi, vi->curpos);
/* Then read the file into the text buffer at that position. */
if (vi_insertfile(vi, pos, filename))
{
/* Was the text buffer empty before we inserted the file? */
if (empty)
{
/* Yes.. then we want to save the filename and mark the text
* as unmodified.
*/
strncpy(vi->filename, filename, MAX_FILENAME - 1);
/* Make sure that the (possibly truncated) file name is NUL
* terminated
*/
vi->filename[MAX_FILENAME - 1] = '\0';
vi->modified = false;
}
else
{
/* No.. then we want to retain the filename and mark the text
* as modified.
*/
vi->modified = true;
}
}
}
/* Are we now committed to writing the file? */
if (IS_WRITE(cmd))
{
/* If we are writing to a new file, then we need to copy the filename
* from the scratch buffer to the filename buffer.
*/
if (filename)
{
strncpy(vi->filename, filename, MAX_FILENAME - 1);
/* Make sure that the (possibly truncated) file name is NUL
* terminated
*/
vi->filename[MAX_FILENAME - 1] = '\0';
}
/* If it is not a new file and if there are no changes to the text
* buffer, then ignore the write.
*/
if (filename || vi->modified)
{
vi_clearbottomline(vi);
vi_putch(vi, '"');
vi_write(vi, vi->filename, strlen(vi->filename));
vi_putch(vi, '"');
vi_putch(vi, ' ');
/* Now, finally, we can save the file */
if (!vi_savetext(vi, vi->filename, 0, vi->textsize))
{
/* An error occurred while saving the file and we are
* not forcing the quit operation. So error out without
* quitting until the user decides what to do about
* the save failure.
*/
goto errout;
}
/* The text buffer contents are no longer modified */
if (!IS_QUIT(cmd))
{
vi_setcursor(vi, vi->cursor.row, vi->cursor.column);
}
vi->modified = false;
}
}
/* Are we committed to exit-ing? */
if (IS_QUIT(cmd))
{
/* Yes... free resources and exit */
vi_putch(vi, '\n');
vi_release(vi);
exit(EXIT_SUCCESS);
}
/* Otherwise, revert to command mode */
vi_exitsubmode(vi, MODE_COMMAND);
return;
errout_bad_command:
vi_error(vi, g_fmtnotcmd, vi->scratch);
errout:
vi_exitsubmode(vi, MODE_COMMAND);
}
/****************************************************************************
* Name: vi_cmd_submode
*
* Description:
* Colon command sub-mode of the command mode processing
*
****************************************************************************/
static void vi_cmd_submode(FAR struct vi_s *vi)
{
int ch;
viinfo("Enter colon command sub-mode\n");
/* Loop while we are in colon command mode */
while (vi->mode == SUBMODE_COLON)
{
/* Get the next character from the input */
ch = vi_getch(vi);
/* Handle the newly received character */
switch (ch)
{
case KEY_COLMODE_QUOTE: /* Quoted character follows */
{
/* Insert the next character unconditionally */
vi_cmdch(vi, vi_getch(vi));
}
break;
case ASCII_BS: /* Delete the character(s) before the cursor */
{
if (vi->cmdlen == 0)
{
vi_exitsubmode(vi, MODE_COMMAND);
/* Ensure bottom line is cleared */
vi_clearbottomline(vi);
}
else
{
vi_cmdbackspace(vi);
}
}
break;
case ASCII_ESC: /* Escape exits colon mode */
{
vi_exitsubmode(vi, MODE_COMMAND);
}
break;
/* What do we do with carriage returns? line feeds? */
#if defined(CONFIG_EOL_IS_CR)
case '\r': /* CR terminates line */
{
vi_parsecolon(vi);
}
break;
#elif defined(CONFIG_EOL_IS_BOTH_CRLF)
case '\r': /* Wait for the LF */
break;
#endif
#if defined(CONFIG_EOL_IS_LF) || defined(CONFIG_EOL_IS_BOTH_CRLF)
case '\n': /* LF terminates line */
{
vi_parsecolon(vi);
}
break;
#endif
#ifdef CONFIG_EOL_IS_EITHER_CRLF
case '\r': /* Either CR or LF terminates line */
case '\n':
{
vi_parsecolon(vi);
}
break;
#endif
default:
{
/* Ignore all but printable characters */
if (isprint(ch))
{
/* Insert the filtered character into the scratch buffer */
vi_cmdch(vi, ch);
}
else
{
VI_BEL(vi);
}
}
break;
}
}
}
/****************************************************************************
* Find Data Entry Sub-Mode Functions
****************************************************************************/
/****************************************************************************
* Name: vi_findstring
*
* Description:
* Find the string in the findstr buffer by searching for a matching
* sub-string in the text buffer, starting at the current cursor position.
*
****************************************************************************/
static bool vi_findstring(FAR struct vi_s *vi)
{
off_t pos;
int len;
viinfo("findstr: \"%s\"\n", vi->findstr);
/* The search string is in the find buffer */
len = strlen(vi->findstr);
if (!len)
{
return false;
}
/* Search from the current cursor position forward for a
* matching sub-string. Stop loo
*/
vi_clearbottomline(vi);
for (pos = vi->curpos;
pos + len <= vi->textsize;
pos++)
{
/* Check for the matching sub-string */
if (strncmp(vi->text + pos, vi->scratch, len) == 0)
{
/* Found it... save the cursor position and
* return success.
*/
vi->curpos = pos;
return true;
}
}
/* If we get here, then the search string was not found anywhere after the
* current cursor position. Start from beginning and search to curpos.
*/
for (pos = 0; pos <= vi->curpos; pos++)
{
/* Check for the matching sub-string */
if (strncmp(vi->text + pos, vi->scratch, len) == 0)
{
vi_write(vi, g_fmtsrcbot, sizeof(g_fmtsrcbot));
/* Found it... save the cursor position and
* return success.
*/
vi->curpos = pos;
return true;
}
}
return false;
}
/****************************************************************************
* Name: vi_revfindstring
*
* Description:
* Find the string in the findstr buffer by searching for a matching
* sub-string in the text buffer, starting at the current cursor position.
* The search is performed backward through the file.
*
****************************************************************************/
static bool vi_revfindstring(FAR struct vi_s *vi)
{
off_t pos;
int len;
viinfo("findstr: \"%s\"\n", vi->findstr);
/* The search string is in the find buffer */
len = strlen(vi->findstr);
if (!len)
{
return false;
}
/* Search from the current cursor position forward for a
* matching sub-string. Stop loo
*/
vi_clearbottomline(vi);
for (pos = vi->curpos;
pos > 0; pos--)
{
/* Check for the matching sub-string */
if (strncmp(vi->text + pos, vi->scratch, len) == 0)
{
/* Found it... save the cursor position and
* return success.
*/
vi->curpos = pos;
return true;
}
}
/* If we get here, then the search string was not found anywhere before the
* current cursor position. Start from end and search to curpos.
*/
for (pos = vi->textsize - len; pos > vi->curpos; pos--)
{
/* Check for the matching sub-string */
if (strncmp(vi->text + pos, vi->scratch, len) == 0)
{
vi_write(vi, g_fmtsrctop, sizeof(g_fmtsrctop));
/* Found it... save the cursor position and
* return success.
*/
vi->curpos = pos;
return true;
}
}
return false;
}
/****************************************************************************
* Name: vi_parsefind
*
* Description:
* Find the string collected in the scratch buffer.
*
****************************************************************************/
static void vi_parsefind(FAR struct vi_s *vi, bool revfind)
{
/* Make certain that the scratch buffer contents are NUL terminated */
vi->scratch[vi->cmdlen] = '\0';
/* Is there anything in the scratch buffer? If not, then we will use the
* string from the previous find operation.
*/
viinfo("scratch: \"%s\"\n", vi->scratch);
if (vi->cmdlen > 0)
{
/* Copy the new search string from the scratch to the find buffer */
strncpy(vi->findstr, vi->scratch, MAX_STRING - 1);
/* Make sure that the (possibly truncated) search string is NUL
* terminated
*/
vi->findstr[MAX_STRING - 1] = '\0';
}
/* Then attempt to find the string */
vi->revfind = revfind;
if (revfind)
{
vi_revfindstring(vi);
}
else
{
vi_findstring(vi);
}
/* Exit the sub-mode and revert to command mode */
vi_exitsubmode(vi, MODE_COMMAND);
}
/****************************************************************************
* Name: vi_find_submode
*
* Description:
* Find command sub-mode of the command mode processing
*
****************************************************************************/
static void vi_find_submode(FAR struct vi_s *vi, bool revfind)
{
int ch;
viinfo("Enter find sub-mode\n");
/* Loop while we are in find mode */
while (vi->mode == SUBMODE_FIND || vi->mode == SUBMODE_REVFIND)
{
/* Get the next character from the input */
ch = vi_getch(vi);
/* Handle the newly received character */
switch (ch)
{
case KEY_FINDMODE_QUOTE: /* Quoted character follows */
{
/* Insert the next character unconditionally */
vi_cmdch(vi, vi_getch(vi));
}
break;
case ASCII_BS: /* Delete the character before the cursor */
{
if (vi->cmdlen == 0)
{
vi_exitsubmode(vi, MODE_COMMAND);
/* Ensure bottom line is cleared */
vi_clearbottomline(vi);
}
else
{
vi_cmdbackspace(vi);
}
}
break;
case ASCII_ESC: /* Escape exits find mode */
{
vi_exitsubmode(vi, MODE_COMMAND);
}
break;
/* What do we do with carriage returns? line feeds? */
#if defined(CONFIG_EOL_IS_CR)
case '\r': /* CR terminates line */
{
vi_parsefind(vi, revfind);
}
break;
#elif defined(CONFIG_EOL_IS_BOTH_CRLF)
case '\r': /* Wait for the LF */
break;
#endif
#if defined(CONFIG_EOL_IS_LF) || defined(CONFIG_EOL_IS_BOTH_CRLF)
case '\n': /* LF terminates line */
{
vi_parsefind(vi, revfind);
}
break;
#endif
#ifdef CONFIG_EOL_IS_EITHER_CRLF
case '\r': /* Either CR or LF terminates line */
case '\n':
{
vi_parsefind(vi, revfind);
}
break;
#endif
default:
{
/* Ignore all but printable characters */
if (isprint(ch))
{
/* Insert the filtered character into the scratch buffer */
vi_cmdch(vi, ch);
}
else
{
VI_BEL(vi);
}
}
break;
}
}
}
/****************************************************************************
* Replace Text Sub-Mode Functions
****************************************************************************/
/****************************************************************************
* Name: vi_replacech
*
* Description:
* Replace the character at the current position. If the current position
* is the end of line, then insert the character.
*
****************************************************************************/
static void vi_replacech(FAR struct vi_s *vi, char ch)
{
viinfo("curpos=%ld ch=%c[%02x]\n", vi->curpos, isprint(ch) ? ch : '.', ch);
/* Is there a newline at the current cursor position? */
if (vi->text[vi->curpos] == '\n')
{
/* Yes, then insert the new character before the newline */
vi_insertch(vi, ch);
vi->drawtoeos = true;
}
else
{
/* No, just replace the character and increment the cursor position */
vi->text[vi->curpos++] = ch;
vi->redrawline = true;
}
}
/****************************************************************************
* Name: vi_replacech_submode
*
* Description:
* Replace character command sub-mode of the command mode processing
*
****************************************************************************/
static void vi_replacech_submode(FAR struct vi_s *vi)
{
off_t end;
long nchars;
bool found = false;
int ch = 0;
/* Get the number of characters to replace */
nchars = (vi->value > 0 ? vi->value : 1);
viinfo("Enter replaces character(s) sub-mode: nchars=%d\n", nchars);
/* Are there that many characters left on the line to be replaced? */
end = vi_lineend(vi, vi->curpos) + 1;
if (vi->curpos + nchars > end)
{
vi_error(vi, g_fmtnotvalid);
vi_setmode(vi, MODE_COMMAND, 0);
}
/* Loop until we get the replacement character */
while (vi->mode == SUBMODE_REPLACECH && !found)
{
/* Get the next character from the input */
ch = vi_getch(vi);
/* Handle the newly received character */
vi->updatereqcol = true;
switch (ch)
{
case KEY_FINDMODE_QUOTE: /* Quoted character follows */
{
/* Insert the next character unconditionally */
ch = vi_getch(vi);
found = true;
}
break;
case ASCII_ESC: /* Escape exits replace mode */
{
vi_setmode(vi, MODE_COMMAND, 0);
if (vi->curpos > 0)
{
--vi->curpos;
}
}
break;
/* What do we do with carriage returns? line feeds? */
#if defined(CONFIG_EOL_IS_CR)
case '\r': /* CR terminates line */
{
ch = '\n';
found = true;
}
break;
#elif defined(CONFIG_EOL_IS_BOTH_CRLF)
case '\r': /* Wait for the LF */
break;
#endif
#if defined(CONFIG_EOL_IS_LF) || defined(CONFIG_EOL_IS_BOTH_CRLF)
case '\n': /* LF terminates line */
{
found = true;
}
break;
#endif
#ifdef CONFIG_EOL_IS_EITHER_CRLF
case '\r': /* Either CR or LF terminates line */
case '\n':
{
ch = '\n';
found = true;
}
break;
#endif
default:
{
/* Ignore all but printable characters and tab */
if (isprint(ch) || ch == '\t')
{
found = true;
}
else
{
VI_BEL(vi);
}
}
break;
}
}
/* Now replace with the character nchar times */
for (; nchars > 0; nchars--)
{
vi_replacech(vi, ch);
vi->redrawline = true;
}
/* Revert to command mode */
vi_setmode(vi, MODE_COMMAND, 0);
}
/****************************************************************************
* Name: vi_findinline_mode
*
* Description:
* Find character in current line.
*
****************************************************************************/
static void vi_findinline_mode(FAR struct vi_s *vi)
{
int count;
off_t pos;
int ch = -1;
/* Get the next character from the input */
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
/* Test for active cmdrepeat */
if (vi->cmdrepeat)
{
/* Read next command from command buffer */
ch = vi->cmdbuf[vi->cmdindex++];
}
else
#endif
{
while (ch == -1)
{
ch = vi_getch(vi);
}
}
/* Ignore all but printable characters and tab */
if (!isprint(ch))
{
VI_BEL(vi);
vi_setmode(vi, MODE_COMMAND, 0);
return;
}
vi->updatereqcol = true;
/* Now find the character */
pos = vi->curpos + 1;
count = vi->value > 0 ? vi->value : 1;
while (count > 0 && pos < vi->textsize-1 && vi->text[pos] != '\n')
{
/* Increment to next character */
pos++;
/* Test if this character matches */
if (vi->text[pos] == ch)
{
count--;
}
}
/* Test if found */
if (count == 0)
{
if (vi->tfind)
{
pos--;
}
/* Test if yank or del armed */
if (vi->yankarm || vi->delarm || vi->chgarm)
{
/* Yank the text and possibly delete */
vi_yanktext(vi, vi->curpos, pos, 1, vi->delarm || vi->chgarm);
if (vi->delarm || vi->chgarm)
{
/* Redraw line if text deleted */
vi->redrawline = true;
}
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
/* Setup command repeat */
if (vi->delarm || vi->chgarm)
{
vi_saverepeat(vi, vi->delarm ? 'd' : 'c');
vi_appendrepeat(vi, vi->tfind ? 't' : 'f');
vi_appendrepeat(vi, ch);
}
#endif
/* If change text is armed, then enter insert mode */
if (vi->chgarm)
{
vi->chgarm = false;
vi_setmode(vi, MODE_INSERT, 0);
return;
}
vi->delarm = false;
vi->yankarm = false;
}
else
{
/* Simply move to the specified location */
vi->curpos = pos;
}
}
/* Revert to command mode */
vi_setmode(vi, MODE_COMMAND, 0);
}
/****************************************************************************
* Insert and Replace Mode Functions
****************************************************************************/
/****************************************************************************
* Name: vi_insertch
*
* Description:
* Insert one character into the text buffer
*
****************************************************************************/
static void vi_insertch(FAR struct vi_s *vi, char ch)
{
viinfo("curpos=%ld ch=%c[%02x]\n", vi->curpos, isprint(ch) ? ch : '.', ch);
/* Make space in the buffer for the new character */
if (vi_extendtext(vi, vi->curpos, 1))
{
/* Add the new character to the buffer */
vi->text[vi->curpos++] = ch;
}
}
/****************************************************************************
* Name: vi_insert_mode
*
* Description:
* Insert mode loop
*
****************************************************************************/
static void vi_insert_mode(FAR struct vi_s *vi)
{
off_t start = vi->curpos;
int ch;
viinfo("Enter insert mode\n");
/* Print insert message */
vi_clearbottomline(vi);
vi_write(vi, g_fmtinsert, sizeof(g_fmtinsert));
vi_setcursor(vi, vi->cursor.row, vi->cursor.column);
vi->redrawline = true;
/* Loop while we are in insert mode */
while (vi->mode == MODE_INSERT || vi->mode == MODE_REPLACE)
{
/* Make sure that the display reflects the current state */
if (vi->redrawline || vi->drawtoeos || vi->fullredraw)
{
vi_showtext(vi);
}
/* Display the line and col number */
vi_showlinecol(vi);
vi_setcursor(vi, vi->cursor.row, vi->cursor.column);
/* Get the next character from the input */
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
/* Test for active cmdrepeat */
if (vi->cmdrepeat)
{
/* Read next command from command buffer */
ch = vi->cmdbuf[vi->cmdindex++];
}
else
#endif
{
ch = vi_getch(vi);
#ifdef CONFIG_SYSTEM_VI_INCLUDE_COMMAND_REPEAT
/* Any arrow, pgup, pgdn, etc. key resets command repeat */
if (ch == KEY_UP || ch == KEY_DOWN || ch == KEY_LEFT ||
ch == KEY_RIGHT || ch == KEY_HOME || ch == KEY_END ||
ch == KEY_PPAGE || ch == KEY_NPAGE)
{
vi->cmdcount = 1;
vi->redrawline = true;
}
else
{
vi_appendrepeat(vi, ch);
}
#endif
}
/* Test for printable character first since we will get mostly those,
* and this will give better performance.
*/
vi->updatereqcol = true;
if (!iscntrl(ch) || ch == '\t')
{
/* Insert the filtered character into the buffer */
if (vi->mode == MODE_INSERT)
{
vi_insertch(vi, ch);
}
else
{
vi_replacech(vi, ch);
}
/* If we don't have to scroll the screen to display the
* character, then do a simple putch, otherwise request
* a line redraw.
*/
if (vi->cursor.column + 1 < vi->display.column && ch != '\t' &&
(vi->curpos+1 == vi->textsize ||
vi->text[vi->curpos+1] == '\n'))
{
vi_putch(vi, ch);
}
else
{
vi->redrawline = true;
}
vi->cursor.column++;
continue;
}
/* Any key press clears the error message */
vi->error = false;
vi->redrawline = true;
/* Handle the newly received character */
switch (ch)
{
case KEY_INSMODE_QUOTE: /* Quoted character follows */
{
/* Insert the next character unconditionally */
vi_insertch(vi, vi_getch(vi));
}
break;
case ASCII_DEL:
{
if (vi->curpos < vi->textsize)
{
if (vi->text[vi->curpos] == '\n')
{
vi->drawtoeos = true;
}
vi_shrinktext(vi, vi->curpos, 1);
}
}
break;
case ASCII_BS:
{
/* Backspace changes based on mode */
if (vi->mode == MODE_INSERT)
{
/* In insert mode, we remove characters */
if (vi->curpos > 0)
{
if (vi->text[vi->curpos-1] == '\n')
{
vi->drawtoeos = true;
}
vi_shrinktext(vi, vi->curpos-1, 1);
}
}
else
{
/* In replace mode, we simply move the cursor left */
if (vi->curpos > start)
{
vi->curpos = vi_cursorleft(vi, vi->curpos, 1);
}
}
}
break;
case ASCII_ESC: /* Escape exits insert mode */
{
vi_setmode(vi, MODE_COMMAND, 0);
vi->updatereqcol = true;
/* Move cursor 1 space to the left when exiting insert mode */
if (vi->curpos > 0 && vi->text[vi->curpos-1] != '\n')
{
--vi->curpos;
}
}
break;
/* What do we do with carriage returns? */
#if defined(CONFIG_EOL_IS_CR)
case '\r': /* CR terminates line */
{
if (vi->mode == MODE_INSERT)
{
vi_insertch(vi, '\n');
}
else
{
vi_replacech(vi, '\n');
}
vi->drawtoeos = true;
}
break;
#elif defined(CONFIG_EOL_IS_BOTH_CRLF)
case '\r': /* Wait for the LF */
break;
#endif
#if defined(CONFIG_EOL_IS_LF) || defined(CONFIG_EOL_IS_BOTH_CRLF)
case '\n': /* LF terminates line */
{
if (vi->mode == MODE_INSERT)
{
vi_insertch(vi, '\n');
}
else
{
vi_replacech(vi, '\n');
}
vi->drawtoeos = true;
}
break;
#endif
#ifdef CONFIG_EOL_IS_EITHER_CRLF
case '\r': /* Either CR or LF terminates line */
case '\n':
{
if (vi->mode == MODE_INSERT)
{
vi_insertch(vi, '\n');
}
else
{
vi_replacech(vi, '\n');
}
vi_putch(vi, ' ');
vi_clrtoeol(vi);
vi->drawtoeos = true;
}
break;
#endif
case KEY_UP: /* Move the cursor up one line */
{
vi->updatereqcol = false;
vi_cusorup(vi, 1);
}
break;
case KEY_DOWN: /* Move the cursor down one line */
{
vi->updatereqcol = false;
vi_cursordown(vi, 1);
}
break;
case KEY_LEFT: /* Move the cursor left N characters */
{
vi->curpos = vi_cursorleft(vi, vi->curpos, 1);
}
break;
case KEY_RIGHT: /* Move the cursor right one character */
{
vi->curpos = vi_cursorright(vi, vi->curpos, 1);
if (vi->curpos >= vi->textsize)
{
vi->curpos = vi->textsize - 1;
}
}
break;
case KEY_HOME:
{
vi->curpos = vi_linebegin(vi, vi->curpos);
}
break;
case KEY_END:
{
vi->curpos = vi_lineend(vi, vi->curpos);
}
break;
case KEY_PPAGE:
{
vi->updatereqcol = false;
vi_cusorup(vi, vi->display.row);
}
break;
case KEY_NPAGE:
{
vi->updatereqcol = false;
vi_cursordown(vi, vi->display.row);
}
break;
default:
{
/* Don't print BEL if char is -1 from termcurses */
if (ch == -1)
{
continue;
}
else
{
VI_BEL(vi);
}
}
break;
}
}
vi_clearbottomline(vi);
}
/****************************************************************************
* Command line processing
****************************************************************************/
/****************************************************************************
* Name: vi_showusage
*
* Description:
* Show command line arguments and exit.
*
****************************************************************************/
static void vi_release(FAR struct vi_s *vi)
{
if (vi)
{
if (vi->text)
{
free(vi->text);
}
if (vi->yank)
{
free(vi->yank);
}
if (vi->tcurs)
{
termcurses_deinitterm(vi->tcurs);
}
free(vi);
}
}
/****************************************************************************
* Name: vi_showusage
*
* Description:
* Show command line arguments and exit.
*
****************************************************************************/
static void vi_showusage(FAR struct vi_s *vi, FAR const char *progname,
int exitcode)
{
fprintf(stderr, "\nUSAGE:\t%s [-c <columns] [-r <rows>] [<filename>]\n",
progname);
fprintf(stderr, "\nUSAGE:\t%s -h\n\n",
progname);
fprintf(stderr, "Where:\n");
fprintf(stderr, "\t<filename>:\n");
fprintf(stderr, "\t\tOptional name of the file to open\n");
fprintf(stderr, "\t-c <columns>:\n");
fprintf(stderr, "\t\tOptional width of the display in columns. Default: %d\n",
CONFIG_SYSTEM_VI_COLS);
fprintf(stderr, "\t-r <rows>:\n");
fprintf(stderr, "\t\tOptional height of the display in rows. Default: %d\n",
CONFIG_SYSTEM_VI_ROWS);
fprintf(stderr, "\t-h:\n");
fprintf(stderr, "\t\tShows this message and exits.\n");
/* Release all allocated resources and exit */
vi_release(vi);
exit(exitcode);
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: vi_main
*
* Description:
* The main entry point into vi.
*
****************************************************************************/
int main(int argc, FAR char *argv[])
{
FAR struct vi_s *vi;
int option;
int ret;
/* Allocate a vi state structure */
vi = (FAR struct vi_s *)zalloc(sizeof(struct vi_s));
if (vi == NULL)
{
vi_error(vi, g_fmtallocfail);
return EXIT_FAILURE;
}
/* Initialize non-zero elements of the vi state structure */
vi->display.row = CONFIG_SYSTEM_VI_ROWS;
vi->display.column = CONFIG_SYSTEM_VI_COLS;
/* Parse command line arguments */
while ((option = getopt(argc, argv, ":c:r:h")) != ERROR)
{
switch (option)
{
case 'c': /* Display width in columns */
{
unsigned long value = strtoul(optarg, NULL, 10);
if (value <= UINT16_MAX)
{
vi->display.column = (uint16_t)value;
}
else
{
fprintf(stderr, "ERROR: Column value out of range: %lu\n",
value);
vi_showusage(vi, argv[0], EXIT_FAILURE);
}
}
break;
case 'r': /* Display width in columns */
{
unsigned long value = strtoul(optarg, NULL, 10);
if (value <= UINT16_MAX)
{
vi->display.row = (uint16_t)value;
}
else
{
fprintf(stderr, "ERROR: Row value out of range: %lu\n",
value);
vi_showusage(vi, argv[0], EXIT_FAILURE);
}
}
break;
case 'h':
{
vi_showusage(vi, argv[0], EXIT_SUCCESS);
}
break;
case ':':
{
fprintf(stderr, "ERROR: Missing parameter argument\n");
vi_showusage(vi, argv[0], EXIT_FAILURE);
}
break;
case '?':
default:
{
fprintf(stderr, "ERROR: Unrecognized parameter\n");
vi_showusage(vi, argv[0], EXIT_FAILURE);
}
break;
}
}
/* Initialize termcurses */
ret = termcurses_initterm(NULL, 0, 1, &vi->tcurs);
if (ret == OK)
{
struct winsize winsz;
ret = termcurses_getwinsize(vi->tcurs, &winsz);
if (ret == OK)
{
vi->display.row = winsz.ws_row;
vi->display.column = winsz.ws_col;
}
}
/* There may be one additional argument on the command line: The filename */
if (optind < argc)
{
/* Copy the file name into the file name buffer */
if (argv[optind][0] == '/')
{
strncpy(vi->filename, argv[optind], MAX_STRING - 1);
}
else
{
/* Make file relative to current working directory */
getcwd(vi->filename, MAX_STRING-1);
strncat(vi->filename, "/", MAX_STRING - 1);
strncat(vi->filename, argv[optind], MAX_STRING - 1);
}
/* Make sure that the (possibly truncated) file name is NUL terminated */
vi->filename[MAX_STRING - 1] = '\0';
/* Load the file into memory */
vi_insertfile(vi, 0, vi->filename);
vi->modified = false;
/* Skip over the filename argument. There should nothing after this */
optind++;
}
/* If no file loaded, create an empty buffer for editing */
if (vi->text == NULL)
{
vi_extendtext(vi, 0, TEXT_GULP_SIZE);
vi->textsize = 0;
vi->modified = 0;
}
if (optind != argc)
{
fprintf(stderr, "ERROR: Too many arguments\n");
vi_showusage(vi, argv[0], EXIT_FAILURE);
}
/* The editor loop */
vi->fullredraw = true;
for (; ; )
{
/* We loop, processing each mode change */
viinfo("mode=%d\n", vi->mode);
switch (vi->mode)
{
default:
case MODE_COMMAND: /* Command mode */
vi_cmd_mode(vi);
break;
case SUBMODE_COLON: /* Colon data entry in command mode */
vi_cmd_submode(vi);
break;
case SUBMODE_REVFIND:
case SUBMODE_FIND: /* Find data entry in command mode */
vi_find_submode(vi, vi->mode == SUBMODE_REVFIND);
break;
case SUBMODE_REPLACECH: /* Replace characters in command mode */
vi_replacech_submode(vi);
break;
case MODE_INSERT: /* Insert mode */
case MODE_REPLACE: /* Replace character(s) under cursor until ESC */
vi_insert_mode(vi);
break;
case MODE_FINDINLINE: /* Insert mode */
vi_findinline_mode(vi);
break;
}
}
/* We won't get here */
}
Reference in New Issue View Git Blame Copy Permalink