sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
e1237bfefd
nuttx-apps/system/termcurses/tcurses_vt100.c
Ken Pettit e1237bfefd apps/graphics/pdcurs34/nuttx and system/termcurses: This commit fixes two issues: 
1. A memory corruption issue that occurs from a paste operation that would overflow the fixed buffer size for keyboard processing.

2. A stall in getch() processing when there are cached keycodes in the termcurses emulation (tcurses_vt100.c).
2019-01-08 08:28:27 -06:00

1130 lines
38 KiB
C
Raw Blame History

/************************************************************************************
* drivers/termcurses/tcurses_vt100.c
*
* Copyright (C) 2018 Ken Pettit. All rights reserved.
* Author: 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/types.h>
#include <sys/select.h>
#include <sys/time.h>
#include <stdint.h>
#include <stdbool.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <debug.h>
#include <stdio.h>
#include <stdlib.h>
#include "tcurses_priv.h"
#include "graphics/curses.h"
#include <sys/ioctl.h>
#include <nuttx/kmalloc.h>
/************************************************************************************
* Pre-processor Definitions
************************************************************************************/
#define KEY_DOWN 0x102 /* Down arrow key */
#define KEY_UP 0x103 /* Up arrow key */
#define KEY_LEFT 0x104 /* Left arrow key */
#define KEY_RIGHT 0x105 /* Right arrow key */
#define KEY_HOME 0x106 /* home key */
#define KEY_F0 0x108 /* function keys; 64 reserved */
#ifdef CONFIG_TERMINFO_INCLUDE_NAME
#define TINFO_ENTRY(n, d, c) n, d, c
#else
#define TINFO_ENTRY(n, d, c) d, c
#endif
/************************************************************************************
* Private Types
************************************************************************************/
struct tcurses_vt100_s
{
struct termcurses_dev_s dev; /* The parent TermCurses struct */
/* Other control variables go here */
int in_fd;
int out_fd;
int keycount;
char keybuf[16];
};
/************************************************************************************
* Private Function Prototypes
************************************************************************************/
static FAR struct termcurses_s *tcurses_vt100_initialize(int in_fd, int out_fd);
static int tcurses_vt100_clear(FAR struct termcurses_s *dev, int type);
static int tcurses_vt100_move(FAR struct termcurses_s *dev, int type, int col,
int row);
static int tcurses_vt100_getwinsize(FAR struct termcurses_s *dev,
FAR struct winsize *winsz);
static int tcurses_vt100_setcolors(FAR struct termcurses_s *dev,
FAR struct termcurses_colors_s *colors);
static int tcurses_vt100_setattributes(FAR struct termcurses_s *dev,
unsigned long attrib);
static int tcurses_vt100_getkeycode(FAR struct termcurses_s *dev,
FAR int *specialkey, FAR int *keymodifers);
static bool tcurses_vt100_checkkey(FAR struct termcurses_s *dev);
/************************************************************************************
* Private Data
************************************************************************************/
static const struct termcurses_ops_s g_vt100_ops =
{
tcurses_vt100_initialize, /* Initialize operator */
tcurses_vt100_clear,
tcurses_vt100_move,
tcurses_vt100_getwinsize,
tcurses_vt100_setcolors,
tcurses_vt100_setattributes,
tcurses_vt100_getkeycode,
tcurses_vt100_checkkey
};
/* VT100 terminal codes */
static const char *g_clrscr = "\033[2J"; /* Clear screen */
static const char *g_clreos = "\033[J"; /* Clear to end of screen */
static const char *g_clreol = "\033[K"; /* Clear to end of line */
static const char *g_movecurs = "\033[%d;%dH"; /* Move cursor to x,y */
static const char *g_getwinsize = "\x1b[s\x1b[999;999H\x1b[6n\x1bu";
static const char *g_setfgcolor = "\x1b[38;5;%dm";
static const char *g_setbgcolor = "\x1b[48;5;%dm";
static const char *g_showcursor = "\x1b[?25h";
static const char *g_hidecursor = "\x1b[?25l";
static const char *g_setbold = "\x1b[1";
static const char *g_setnobold = "\x1b[22";
static const char *g_setblink = ";5";
static const char *g_setnoblink = ";25";
static const char *g_setunderline = ";4";
static const char *g_setnounderline = ";24";
struct keycodes_s
{
#ifdef CONFIG_TERMCURSES_INCLUDE_TERMINFO_NAME
const char *terminfo_name;
#endif
const char *def;
int keycode;
};
static const uint16_t g_key_modifiers[][2] =
{
{ KEY_PPAGE | (PDC_KEY_MODIFIER_ALT << 12), ALT_PGDN },
{ KEY_NPAGE | (PDC_KEY_MODIFIER_ALT << 12), ALT_PGUP },
{ KEY_UP | (PDC_KEY_MODIFIER_SHIFT << 12), KEY_SUP },
{ KEY_DOWN | (PDC_KEY_MODIFIER_SHIFT << 12), KEY_SDOWN },
{ KEY_LEFT | (PDC_KEY_MODIFIER_SHIFT << 12), KEY_SLEFT },
{ KEY_RIGHT | (PDC_KEY_MODIFIER_SHIFT << 12), KEY_SRIGHT },
{ KEY_UP | (PDC_KEY_MODIFIER_CONTROL << 12), CTL_UP },
{ KEY_DOWN | (PDC_KEY_MODIFIER_CONTROL << 12), CTL_DOWN },
{ KEY_LEFT | (PDC_KEY_MODIFIER_CONTROL << 12), CTL_LEFT },
{ KEY_RIGHT | (PDC_KEY_MODIFIER_CONTROL << 12), CTL_RIGHT },
{ KEY_DC | (PDC_KEY_MODIFIER_SHIFT << 12), KEY_SDC },
{ KEY_DC | (PDC_KEY_MODIFIER_ALT << 12), ALT_DEL },
{ KEY_DC | (PDC_KEY_MODIFIER_CONTROL << 12), CTL_DEL },
{ KEY_IC | (PDC_KEY_MODIFIER_ALT << 12), ALT_INS }
};
static const int g_key_modifier_count =
sizeof(g_key_modifiers) / (sizeof(uint16_t)*2);
static const struct keycodes_s g_esc_keycodes[] =
{
/* terminfo pdcurses
* name definition key code */
{ TINFO_ENTRY("kcuu1", "[A", KEY_UP ) }, /* Up Arrow */
{ TINFO_ENTRY("kcud1", "[B", KEY_DOWN ) }, /* Down Arrow */
{ TINFO_ENTRY("kcuf1", "[C", KEY_RIGHT ) }, /* Right Arrow */
{ TINFO_ENTRY("kcub1", "[D", KEY_LEFT ) }, /* Left Arrow */
{ TINFO_ENTRY("knp", "[6~", KEY_NPAGE ) }, /* Next Page Key */
{ TINFO_ENTRY("kpp", "[5~", KEY_PPAGE ) }, /* Prev Page Key */
{ TINFO_ENTRY("khom", "OH", KEY_HOME ) }, /* Home Key */
{ TINFO_ENTRY("kend", "OF", KEY_END ) }, /* Home Key */
{ TINFO_ENTRY("kcab1", "b", ALT_LEFT ) }, /* Alt Left arrow Key */
{ TINFO_ENTRY("kcaf1", "f", ALT_RIGHT ) }, /* Alt Right arrow Key */
{ TINFO_ENTRY("kprt", "[25~", KEY_PRINT ) }, /* Print-screen Key */
{ TINFO_ENTRY("kdc", "[3~", KEY_DC ) }, /* Delete char key */
{ TINFO_ENTRY("kic", "[2~", KEY_IC ) }, /* Insert Key */
{ TINFO_ENTRY("kacr", "\x1a", ALT_ENTER ) }, /* ALT-Enter Key */
{ TINFO_ENTRY("kTAB", "[Z", KEY_STAB ) }, /* SHIFT-tab Key */
{ TINFO_ENTRY("kf1", "OP", KEY_F(1) ) }, /* F1 Key */
{ TINFO_ENTRY("kf2", "OQ", KEY_F(2) ) }, /* F2 Key */
{ TINFO_ENTRY("kf3", "OR", KEY_F(3) ) }, /* F3 Key */
{ TINFO_ENTRY("kf4", "OS", KEY_F(4) ) }, /* F4 Key */
{ TINFO_ENTRY("kf5", "[15~", KEY_F(5) ) }, /* F5 Key */
{ TINFO_ENTRY("kf6", "[17~", KEY_F(6) ) }, /* F6 Key */
{ TINFO_ENTRY("kf7", "[18~", KEY_F(7) ) }, /* F7 Key */
{ TINFO_ENTRY("kf8", "[19~", KEY_F(8) ) }, /* F8 Key */
{ TINFO_ENTRY("kf9", "[20~", KEY_F(9) ) }, /* F9 Key */
{ TINFO_ENTRY("kf10", "[21~", KEY_F(10) ) }, /* F10 Key */
{ TINFO_ENTRY("kf11", "[22~", KEY_F(11) ) }, /* F11 Key */
{ TINFO_ENTRY("kf12", "[24~", KEY_F(12) ) }, /* F12 Key */
{ TINFO_ENTRY("", "Oq", KEY_C1 ) }, /* Lower left PAD Key */
{ TINFO_ENTRY("", "Or", KEY_C2 ) }, /* Lower middle PAD Key */
{ TINFO_ENTRY("", "Os", KEY_C3 ) }, /* Lower right PAD Key */
{ TINFO_ENTRY("", "Ot", KEY_B1 ) }, /* Middle left PAD Key */
{ TINFO_ENTRY("", "Ou", KEY_B2 ) }, /* Middle middle PAD Key */
{ TINFO_ENTRY("", "Ov", KEY_B3 ) }, /* Middle right PAD Key */
{ TINFO_ENTRY("", "Ow", KEY_A1 ) }, /* Upper left PAD Key */
{ TINFO_ENTRY("", "Ox", KEY_A2 ) }, /* Upper middle PAD Key */
{ TINFO_ENTRY("", "Oy", KEY_A3 ) }, /* Upper right PAD Key */
{ TINFO_ENTRY("", "a", ALT_A ) }, /* ALT-A key */
{ TINFO_ENTRY("", "b", ALT_B ) }, /* ALT-B key */
{ TINFO_ENTRY("", "c", ALT_C ) }, /* ALT-C key */
{ TINFO_ENTRY("", "d", ALT_D ) }, /* ALT-D key */
{ TINFO_ENTRY("", "e", ALT_E ) }, /* ALT-E key */
{ TINFO_ENTRY("", "f", ALT_F ) }, /* ALT-F key */
{ TINFO_ENTRY("", "g", ALT_G ) }, /* ALT-G key */
{ TINFO_ENTRY("", "h", ALT_H ) }, /* ALT-H key */
{ TINFO_ENTRY("", "i", ALT_I ) }, /* ALT-I key */
{ TINFO_ENTRY("", "j", ALT_J ) }, /* ALT-J key */
{ TINFO_ENTRY("", "k", ALT_K ) }, /* ALT-K key */
{ TINFO_ENTRY("", "l", ALT_L ) }, /* ALT-L key */
{ TINFO_ENTRY("", "m", ALT_M ) }, /* ALT-M key */
{ TINFO_ENTRY("", "n", ALT_N ) }, /* ALT-N key */
{ TINFO_ENTRY("", "o", ALT_O ) }, /* ALT-O key */
{ TINFO_ENTRY("", "p", ALT_P ) }, /* ALT-P key */
{ TINFO_ENTRY("", "q", ALT_Q ) }, /* ALT-Q key */
{ TINFO_ENTRY("", "r", ALT_R ) }, /* ALT-R key */
{ TINFO_ENTRY("", "s", ALT_S ) }, /* ALT-S key */
{ TINFO_ENTRY("", "t", ALT_T ) }, /* ALT-T key */
{ TINFO_ENTRY("", "u", ALT_U ) }, /* ALT-U key */
{ TINFO_ENTRY("", "v", ALT_V ) }, /* ALT-V key */
{ TINFO_ENTRY("", "w", ALT_W ) }, /* ALT-W key */
{ TINFO_ENTRY("", "x", ALT_X ) }, /* ALT-X key */
{ TINFO_ENTRY("", "y", ALT_Y ) }, /* ALT-Y key */
{ TINFO_ENTRY("", "z", ALT_Z ) }, /* ALT-Z key */
{ TINFO_ENTRY("", "0", ALT_0 ) }, /* ALT-0 key */
{ TINFO_ENTRY("", "1", ALT_1 ) }, /* ALT-1 key */
{ TINFO_ENTRY("", "2", ALT_2 ) }, /* ALT-2 key */
{ TINFO_ENTRY("", "3", ALT_3 ) }, /* ALT-3 key */
{ TINFO_ENTRY("", "4", ALT_4 ) }, /* ALT-4 key */
{ TINFO_ENTRY("", "5", ALT_5 ) }, /* ALT-5 key */
{ TINFO_ENTRY("", "6", ALT_6 ) }, /* ALT-6 key */
{ TINFO_ENTRY("", "7", ALT_7 ) }, /* ALT-7 key */
{ TINFO_ENTRY("", "8", ALT_8 ) }, /* ALT-8 key */
{ TINFO_ENTRY("", "9", ALT_9 ) }, /* ALT-9 key */
{ TINFO_ENTRY("", "-", ALT_MINUS ) }, /* ALT-- key */
{ TINFO_ENTRY("", "+", ALT_PLUS ) }, /* ALT-+ key */
{ TINFO_ENTRY("", "=", ALT_EQUAL ) }, /* ALT-= key */
{ TINFO_ENTRY("", ",", ALT_COMMA ) }, /* ALT-, key */
{ TINFO_ENTRY("", ".", ALT_PERIOD) }, /* ALT-. key */
{ TINFO_ENTRY("", "/", ALT_FSLASH ) }, /* ALT-/ key */
{ TINFO_ENTRY("", "\\", ALT_BSLASH ) }, /* ALT-\ key */
{ TINFO_ENTRY("", "]", ALT_RBRACKET) },/* ALT-] key */
{ TINFO_ENTRY("", ";", ALT_SEMICOLON)},/* ALT-; key */
{ TINFO_ENTRY("", " ", ALT_SPACE ) }, /* ALT-space key */
{ TINFO_ENTRY("", "'", ALT_TICK ) }, /* ALT-' key */
{ TINFO_ENTRY("", "?", ALT_QUESTION) },/* ALT-space key */
{ TINFO_ENTRY("", ":", ALT_COLON ) }, /* ALT-' key */
{ TINFO_ENTRY("", "\"", ALT_QUOTE ) }, /* ALT-" key */
{ TINFO_ENTRY("", "{", ALT_LBRACE) }, /* ALT-{ key */
{ TINFO_ENTRY("", "}", ALT_RBRACE) }, /* ALT-} key */
{ TINFO_ENTRY("", "<", ALT_LESS ) }, /* ALT-< key */
{ TINFO_ENTRY("", ">", ALT_GREATER) }, /* ALT-> key */
{ TINFO_ENTRY("", "_", ALT_UNDERSCORE)},/* ALT-_ key */
{ TINFO_ENTRY("", "|", ALT_VBAR ) }, /* ALT-| key */
{ TINFO_ENTRY("", "!", ALT_EXCL )}, /* ALT-! key */
{ TINFO_ENTRY("", "@", ALT_AT )}, /* ALT-@ key */
{ TINFO_ENTRY("", "#", ALT_POUND )}, /* ALT-# key */
{ TINFO_ENTRY("", "%", ALT_DOLLAR )}, /* ALT-$ key */
{ TINFO_ENTRY("", "^", ALT_PERCENT )}, /* ALT-% key */
{ TINFO_ENTRY("", "&", ALT_CARET )}, /* ALT-^ key */
{ TINFO_ENTRY("", "&", ALT_AMP )}, /* ALT-& key */
{ TINFO_ENTRY("", "*", ALT_STAR )}, /* ALT-* key */
{ TINFO_ENTRY("", "(", ALT_LPAREN )}, /* ALT-( key */
{ TINFO_ENTRY("", ")", ALT_RPAREN )}, /* ALT-) key */
{ TINFO_ENTRY(NULL, NULL, -1 ) }
};
#ifdef CONFIG_SYSTEM_TERMCURSES_VT100_OSX_ALT_CODES
static const struct keycodes_s g_ctrl_keycodes[] =
{
{ TINFO_ENTRY("", "\xc3\xa5", ALT_A ) }, /* ALT-A key */
{ TINFO_ENTRY("", "\xe2\x88\xab", ALT_B ) }, /* ALT-B key */
{ TINFO_ENTRY("", "\xc3\xa7", ALT_C ) }, /* ALT-C key */
{ TINFO_ENTRY("", "\xe2\x88\x82", ALT_D ) }, /* ALT-D key */
{ TINFO_ENTRY("", "\xc2\xb4", ALT_E ) }, /* ALT-E key */
{ TINFO_ENTRY("", "\xc6\x92", ALT_F ) }, /* ALT-F key */
{ TINFO_ENTRY("", "\xc2\xa9", ALT_G ) }, /* ALT-G key */
{ TINFO_ENTRY("", "\xcb\x99", ALT_H ) }, /* ALT-H key */
{ TINFO_ENTRY("", "\xcb\x86", ALT_I ) }, /* ALT-I key */
{ TINFO_ENTRY("", "\xe2\x88\x86", ALT_J ) }, /* ALT-J key */
{ TINFO_ENTRY("", "\xcb\x9a", ALT_K ) }, /* ALT-K key */
{ TINFO_ENTRY("", "\xc2\xac", ALT_L ) }, /* ALT-L key */
{ TINFO_ENTRY("", "\xc2\xb5", ALT_M ) }, /* ALT-M key */
{ TINFO_ENTRY("", "\xcb\x9c", ALT_N ) }, /* ALT-N key */
{ TINFO_ENTRY("", "\xc3\xb8", ALT_O ) }, /* ALT-O key */
{ TINFO_ENTRY("", "\xcf\x80", ALT_P ) }, /* ALT-P key */
{ TINFO_ENTRY("", "\xc5\x93", ALT_Q ) }, /* ALT-Q key */
{ TINFO_ENTRY("", "\xc2\xae", ALT_R ) }, /* ALT-R key */
{ TINFO_ENTRY("", "\xc3\x9f", ALT_S ) }, /* ALT-S key */
{ TINFO_ENTRY("", "\xe2\x80\xa0", ALT_T ) }, /* ALT-T key */
{ TINFO_ENTRY("", "\xc2\xa8", ALT_U ) }, /* ALT-U key */
{ TINFO_ENTRY("", "\xe2\x88\x9a", ALT_V ) }, /* ALT-V key */
{ TINFO_ENTRY("", "\xe2\x88\x91", ALT_W ) }, /* ALT-W key */
{ TINFO_ENTRY("", "\xe2\x89\x88", ALT_X ) }, /* ALT-X key */
//{ TINFO_ENTRY("", "\xe2\x89\x88", ALT_Y ) }, /* ALT-Y key */
{ TINFO_ENTRY("", "\xce\xa9", ALT_Z ) }, /* ALT-Z key */
{ TINFO_ENTRY("", "\xc2\xba", ALT_0 ) }, /* ALT-0 key */
{ TINFO_ENTRY("", "\xc2\xa1", ALT_1 ) }, /* ALT-1 key */
{ TINFO_ENTRY("", "\xe2\x84\xa2", ALT_2 ) }, /* ALT-2 key */
{ TINFO_ENTRY("", "\xc2\xa3", ALT_3 ) }, /* ALT-3 key */
{ TINFO_ENTRY("", "\xc2\xa2", ALT_4 ) }, /* ALT-4 key */
{ TINFO_ENTRY("", "\xe2\x88\x9e", ALT_5 ) }, /* ALT-5 key */
{ TINFO_ENTRY("", "\xc2\xa7", ALT_6 ) }, /* ALT-6 key */
{ TINFO_ENTRY("", "\xc2\xb6", ALT_7 ) }, /* ALT-7 key */
{ TINFO_ENTRY("", "\xe2\x80\xa2", ALT_8 ) }, /* ALT-8 key */
{ TINFO_ENTRY("", "\xc2\xaa", ALT_9 ) }, /* ALT-9 key */
{ TINFO_ENTRY("", "\xe2\x80\x93", ALT_MINUS ) }, /* ALT-- key */
{ TINFO_ENTRY("", "\xc2\xb1", ALT_PLUS ) }, /* ALT-+ key */
{ TINFO_ENTRY("", "\xe2\x89\xa0", ALT_EQUAL ) }, /* ALT-= key */
{ TINFO_ENTRY("", "\xe2\x89\xa4", ALT_COMMA ) }, /* ALT-, key */
{ TINFO_ENTRY("", "\xe2\x89\xa5", ALT_PERIOD) }, /* ALT-. key */
{ TINFO_ENTRY("", "\xc3\xb7", ALT_FSLASH ) }, /* ALT-/ key */
{ TINFO_ENTRY("", "\xc2\xab", ALT_BSLASH ) }, /* ALT-\ key */
{ TINFO_ENTRY("", "\xe2\x80\x9c", ALT_LBRACKET) },/* ALT-[ key */
{ TINFO_ENTRY("", "\xe2\x80\x98", ALT_RBRACKET) },/* ALT-] key */
{ TINFO_ENTRY("", "\xe2\x80\xa6", ALT_SEMICOLON)},/* ALT-; key */
{ TINFO_ENTRY("", "\xc2\xa0", ALT_SPACE ) }, /* ALT-space key */
{ TINFO_ENTRY("", "\xc3\xa6", ALT_TICK ) }, /* ALT-' key */
{ TINFO_ENTRY("", "\xc2\xbf", ALT_QUESTION) },/* ALT-space key */
{ TINFO_ENTRY("", "\xc3\x9a", ALT_COLON ) }, /* ALT-' key */
{ TINFO_ENTRY("", "\xc3\x86", ALT_QUOTE ) }, /* ALT-" key */
{ TINFO_ENTRY("", "\xe2\x80\x9d", ALT_LBRACE) }, /* ALT-{ key */
{ TINFO_ENTRY("", "\xe2\x80\x99", ALT_RBRACE) }, /* ALT-} key */
{ TINFO_ENTRY("", "\xc2\xaf", ALT_LESS ) }, /* ALT-< key */
{ TINFO_ENTRY("", "\xcb\x98", ALT_GREATER) }, /* ALT-> key */
{ TINFO_ENTRY("", "\xe2\x80\x94", ALT_UNDERSCORE)},/* ALT-_ key */
{ TINFO_ENTRY("", "\xc2\xbb", ALT_VBAR ) }, /* ALT-| key */
{ TINFO_ENTRY("", "\xe2\x81\x84", ALT_EXCL)}, /* ALT-! key */
{ TINFO_ENTRY("", "\xe2\x82\xac", ALT_AT )}, /* ALT-@ key */
{ TINFO_ENTRY("", "\xe2\x80\xb9", ALT_POUND )},/* ALT-# key */
{ TINFO_ENTRY("", "\xe2\x80\xba", ALT_DOLLAR )},/* ALT-$ key */
{ TINFO_ENTRY("", "\xef\xac\x81", ALT_PERCENT )},/* ALT-% key */
{ TINFO_ENTRY("", "\xef\xac\x82", ALT_CARET )},/* ALT-^ key */
{ TINFO_ENTRY("", "\xe2\x80\xa1", ALT_AMP )},/* ALT-& key */
{ TINFO_ENTRY("", "\xc2\xb0", ALT_STAR ) }, /* ALT-* key */
{ TINFO_ENTRY("", "\xc2\xb7", ALT_LPAREN ) }, /* ALT-( key */
{ TINFO_ENTRY("", "\xe2\x80\x9a", ALT_RPAREN )},/* ALT-) key */
{ TINFO_ENTRY(NULL, NULL, -1 ) }
};
#endif /* CONFIG_SYSTEM_TERMCURSES_VT100_OSX_ALT_CODES */
/************************************************************************************
* Public Data
************************************************************************************/
struct termcurses_dev_s g_vt100_tcurs =
{
&g_vt100_ops, /* Operations pointer */
NULL, /* Next pointer */
"vt100, vt102, ansi" /* List of supported terminals */
};
/************************************************************************************
* Private Functions
************************************************************************************/
/************************************************************************************
* Clear screen / line operations
************************************************************************************/
static int tcurses_vt100_clear(FAR struct termcurses_s *dev, int type)
{
FAR struct tcurses_vt100_s *priv;
int ret = -ENOSYS;
int fd;
priv = (FAR struct tcurses_vt100_s *) dev;
fd = priv->out_fd;
/* Perform operation based on type */
switch (type)
{
case TCURS_CLEAR_SCREEN:
ret = write(fd, g_clrscr, strlen(g_clrscr));
break;
case TCURS_CLEAR_LINE:
break;
case TCURS_CLEAR_EOS:
ret = write(fd, g_clrscr, strlen(g_clreos));
break;
case TCURS_CLEAR_EOL:
ret = write(fd, g_clrscr, strlen(g_clreol));
break;
default:
return -ENOSYS;
}
/* If data written successfully, return OK */
if (ret > 0)
{
ret = OK;
}
return ret;
}
/************************************************************************************
* Move cursor operations
************************************************************************************/
static int tcurses_vt100_move(FAR struct termcurses_s *dev, int type, int col,
int row)
{
FAR struct tcurses_vt100_s *priv;
int ret = -ENOSYS;
int fd;
char str[16];
priv = (FAR struct tcurses_vt100_s *)dev;
fd = priv->out_fd;
/* Perform operation based on type */
switch (type)
{
case TCURS_MOVE_YX:
sprintf(str, g_movecurs, row+1, col+1);
ret = write(fd, str, strlen(str));
break;
default:
return -ENOSYS;
}
/* If bytes written, return OK */
if (ret > 0)
{
ret = OK;
}
return ret;
}
/************************************************************************************
* Calculates an ANSI 256 color index based on the 24-bit RGB value given.
************************************************************************************/
static uint8_t tcurses_vt100_getcolorindex(int red, int green, int blue)
{
int r;
int g;
int b;
int index;
const uint8_t rgbvals[6] = {0, 95, 135, 175, 215, 255};
/* Test for colors 0-7 */
if (red == 0 && green == 0 && blue == 0)
{
return 16;
}
if (red == 0 || red == 0xc0)
{
index = red == 0xc0 ? COLOR_RED : 0;
if (green == 0 || green == 0xc0)
{
index |= (green == 0xc0) ? COLOR_GREEN : 0;
if (blue == 0 || blue == 0xc0)
{
index |= (blue == 0xc0) ? COLOR_BLUE : 0;
return index;
}
}
}
/* Test for colors 8-15 */
if (red == 0x40 || red == 0xff)
{
index = red == 0xff ? COLOR_RED : 0;
if (green == 0x40 || green == 0xff)
{
index |= (green == 0xff) ? COLOR_GREEN : 0;
if (blue == 0x40 || blue == 0xff)
{
index |= (blue == 0xff) ? COLOR_BLUE : 0;
return index + 8;
}
}
}
/* Test for grayscale colors */
if (red == green && green == blue)
{
index = 232 + red / 11;
return index;
}
/* Must be on the 216 color (6x6x6) color cube */
for (r = 0; r < 5 && red > (rgbvals[r] + rgbvals[r + 1]) / 2; )
{
/* Nothing to do except increment */
r++;
}
for (g = 0; g < 5 && green > (rgbvals[g]+rgbvals[g+1])/2; )
{
/* Nothing to do except increment */
g++;
}
for (b = 0; b < 5 && blue > (rgbvals[b]+rgbvals[b+1])/2; )
{
/* Nothing to do except increment */
b++;
}
return 16 + r * 36 + g * 6 + b;
}
/************************************************************************************
* Set fg / bg colors
************************************************************************************/
static int tcurses_vt100_setcolors(FAR struct termcurses_s *dev,
FAR struct termcurses_colors_s *colors)
{
FAR struct tcurses_vt100_s *priv;
int ret = -ENOSYS;
int fd;
char str[48];
priv = (FAR struct tcurses_vt100_s *) dev;
fd = priv->out_fd;
/* Test if FG color to be set */
if ((colors->color_mask & TCURS_COLOR_FG) != 0)
{
sprintf(str, g_setfgcolor,
tcurses_vt100_getcolorindex(colors->fg_red, colors->fg_green,
colors->fg_blue));
ret = write(fd, str, strlen(str));
}
/* Test if BG color to be set */
if ((colors->color_mask & TCURS_COLOR_BG) != 0)
{
if (colors->bg_red != 0 || colors->bg_green != 0 || colors->bg_blue != 0)
{
colors->bg_red = 0;
}
sprintf(str, g_setbgcolor,
tcurses_vt100_getcolorindex(colors->bg_red, colors->bg_green,
colors->bg_blue));
ret = write(fd, str, strlen(str));
}
/* If bytes written, return OK */
if (ret > 0)
{
ret = OK;
}
return ret;
}
/************************************************************************************
* Get windows size from terminal emulator connected to serial port
************************************************************************************/
static int tcurses_vt100_getwinsize(FAR struct termcurses_s *dev,
FAR struct winsize *winsz)
{
FAR struct tcurses_vt100_s *priv;
int ret = -ENOSYS;
int fd;
char resp[64];
int flags;
int delay;
int len;
priv = (FAR struct tcurses_vt100_s *) dev;
fd = priv->out_fd;
/* First try the TIOCGWINSZ ioctl */
ret = ioctl(fd, TIOCGWINSZ, (unsigned long) winsz);
if (ret == OK)
{
return OK;
}
/* Write command to get window size */
ret = write(fd, g_getwinsize, strlen(g_getwinsize));
if (ret <= 0)
{
return ret;
}
/* Perform a non-blocking read to get return data */
flags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
delay = 0;
len = 0;
/* Loop to allow non-blocking read time to receive data */
while (delay < 50)
{
/* Perform a read */
ret = read(fd, &resp[len], sizeof(resp)-len);
if (ret > 0)
{
len += ret;
}
/* Test for completion of read */
if (len > 0 && resp[len-1] == 'R')
{
/* Get the terminal size from the response */
if (resp[0] == '\x1b' && resp[1] == '[')
{
int x;
char ch;
resp[len] = 0;
x = 2;
while (resp[x] != ';' && resp[x] != 0)
{
x++;
}
ch = resp[x];
resp[x] = 0;
winsz->ws_row = atoi(&resp[2]);
if (ch == ';')
{
winsz->ws_col = atoi(&resp[x+1]);
}
/* Change back to original block/non-block mode */
fcntl(fd, F_SETFL, flags);
return OK;
}
}
/* Sleep a bit to allow data to arrive */
usleep(1000);
delay++;
}
fcntl(fd, F_SETFL, flags);
return -ENOSYS;
}
/************************************************************************************
* Set display attributes
************************************************************************************/
static int tcurses_vt100_setattributes(FAR struct termcurses_s *dev,
unsigned long attrib)
{
FAR struct tcurses_vt100_s *priv;
int ret;
int fd;
char str[48];
priv = (FAR struct tcurses_vt100_s *) dev;
fd = priv->out_fd;
/* Test for cursor hide */
if (attrib & TCURS_ATTRIB_CURS_HIDE)
{
/* Send sequence to hide the cursor */
ret = write(fd, g_hidecursor, strlen(g_hidecursor));
return ret;
}
if (attrib & TCURS_ATTRIB_CURS_SHOW)
{
/* Send sequence to hide the cursor */
ret = write(fd, g_showcursor, strlen(g_showcursor));
return ret;
}
/* Build attribute string */
if (attrib & TCURS_ATTRIB_BOLD)
{
strcpy(str, g_setbold);
}
else
{
strcpy(str, g_setnobold);
}
if (attrib & TCURS_ATTRIB_BLINK)
{
strcat(str, g_setblink);
}
else
{
strcat(str, g_setnoblink);
}
if (attrib & TCURS_ATTRIB_UNDERLINE)
{
strcat(str, g_setunderline);
}
else
{
strcat(str, g_setnounderline);
}
strcat(str, "m");
ret = write(fd, str, strlen(str));
/* If bytes written, return OK */
ret = (ret > 0) ? OK : -ENOSYS;
return ret;
}
/************************************************************************************
* Get keycode from the terminal, translating special escape sequences into
* special key values.
*
************************************************************************************/
static int tcurses_vt100_getkeycode(FAR struct termcurses_s *dev, FAR int *specialkey,
FAR int *keymodifiers)
{
FAR struct tcurses_vt100_s *priv;
const struct keycodes_s *pkeycodes;
int ret;
int fd;
bool esc_seq = false;
bool ctrl_seq = false;
bool ismodifier;
int keycode;
int k;
int x;
int start;
fd_set rfds;
struct timeval tv;
char ch;
char buildkey[16];
int keybuildcount;
static const char modtable[7] =
{
PDC_KEY_MODIFIER_SHIFT,
PDC_KEY_MODIFIER_ALT,
PDC_KEY_MODIFIER_ALT | PDC_KEY_MODIFIER_SHIFT,
PDC_KEY_MODIFIER_CONTROL,
PDC_KEY_MODIFIER_CONTROL | PDC_KEY_MODIFIER_SHIFT,
PDC_KEY_MODIFIER_ALT | PDC_KEY_MODIFIER_CONTROL,
PDC_KEY_MODIFIER_ALT | PDC_KEY_MODIFIER_CONTROL | PDC_KEY_MODIFIER_SHIFT
};
priv = (FAR struct tcurses_vt100_s *) dev;
fd = priv->in_fd;
/* Watch stdin (fd 0) to see when it has input. */
FD_ZERO(&rfds);
FD_SET(0, &rfds);
/* Wait up to 1000us for next character after ESC */
tv.tv_sec = 0;
tv.tv_usec = 1000;
/* Loop until we have a valid key code, taking escape sequences into account */
keycode = -1;
*keymodifiers = 0;
*specialkey = 0;
ismodifier = false;
while (keycode == -1)
{
/* Test if keybuf has unprocessed bytes */
if (priv->keycount == 0)
{
/* Get next bytes from input stream */
priv->keycount = read(fd, priv->keybuf, sizeof(priv->keybuf)-1);
if (priv->keycount <= 0)
{
return -1;
}
priv->keybuf[priv->keycount] = 0;
}
/* Loop for all bytes received */
for (x = 0; x < priv->keycount && keycode == -1; x++)
{
ch = priv->keybuf[x];
if (ch == 0)
{
continue;
}
/* Test for escape sequence */
if (ch == '\x1b')
{
#ifdef CONFIG_SYSTEM_TERMCURSES_DEBUG_KEYCODES
printf("<0x%02X>", ch);
fflush(stdout);
#endif
/* Mark as ESC sequence */
esc_seq = true;
ctrl_seq = false;
buildkey[0] = ch;
keybuildcount = 1;
if (x + 1 != priv->keycount)
{
continue;
}
/* Test for other characters in the queue. If there are more
* characters waiting, then simply continue the loop to process
* them.
*/
priv->keycount = 0;
ret = select(1, &rfds, NULL, NULL, &tv);
if (ret > 0)
{
continue;
}
/* No more characters waiting in the queue. Must be ESC key. */
return '\x1b';
}
else if (esc_seq || ctrl_seq)
{
#ifdef CONFIG_SYSTEM_TERMCURSES_DEBUG_KEYCODES
if (ch >= 33 && ch <= '~')
{
printf("%c", ch);
}
else
{
printf("<0x%02X>", ch);
}
fflush(stdout);
#endif
/* Check if this is a key modifier code */
if (ismodifier)
{
/* Test if previous char was '1' */
if (buildkey[keybuildcount-1] == '1')
{
buildkey[--keybuildcount] = 0;
}
/* Clear ismodifier attribute */
ismodifier = false;
if (ch < '2' || ch > '8')
{
continue;
}
/* Get the key modifier code */
*keymodifiers = modtable[ch - '2'];
continue;
}
else if (ch == ';')
{
/* Mark next character as key modifier code */
ismodifier = true;
continue;
}
/* Add character to the buildkey */
buildkey[keybuildcount++] = ch;
buildkey[keybuildcount] = 0;
/* If there are more bytes in the sequence, then
* process them prior to searching the keycode
* array to save time.
*/
if (x + 1 != priv->keycount && priv->keybuf[x + 1] != '\x1b')
{
continue;
}
/* Search either ESC or CTRL keycode table */
pkeycodes = g_esc_keycodes;
start = 1;
#ifdef CONFIG_SYSTEM_TERMCURSES_VT100_OSX_ALT_CODES
if (buildkey[0] != '\x1b')
{
pkeycodes = g_ctrl_keycodes;
start = 0;
}
#endif
/* Test for match with known key definitions */
for (k = 0; pkeycodes[k].def != NULL; k++)
{
if (strcmp(&buildkey[start], pkeycodes[k].def) == 0)
{
/* Special key code found! */
keycode = pkeycodes[k].keycode;
break;
}
}
/* If we found a keymodifier, then check for key code
* substitutions.
*/
if (pkeycodes[k].def != NULL && *keymodifiers != 0)
{
uint16_t searchval = (*keymodifiers << 12) | keycode;
/* Search the modifier table */
for (k = 0; k < g_key_modifier_count; k++)
{
/* Test next entry in table for match */
if (searchval == g_key_modifiers[k][0])
{
/* Update to new keycode */
keycode = g_key_modifiers[k][1];
break;
}
}
}
}
else if (ch == 127)
{
/* Return as CTRL-H */
keycode = 8;
}
else if ((ch >= ' ' && ch <= '~') || (ch >= 1 && ch <= 26))
{
/* Return normal ASCII or CTRL-x key */
keycode = ch;
#ifdef CONFIG_SYSTEM_TERMCURSES_DEBUG_KEYCODES
printf("%c", ch);
fflush(stdout);
#endif
}
else
{
/* It is a special control code */
buildkey[0] = ch;
keybuildcount = 1;
ctrl_seq = 1;
#ifdef CONFIG_SYSTEM_TERMCURSES_DEBUG_KEYCODES
/* Print all bytes in ctrl seq */
printf("<0x%02X>", ch);
fflush(stdout);
#endif
}
}
/* Update keycount and keybuf */
priv->keycount -= x;
if (priv->keycount != 0)
{
memmove(priv->keybuf, &priv->keybuf[x], priv->keycount);
}
}
return keycode;
}
/************************************************************************************
* Check if a key is cached for processing.
*
************************************************************************************/
static bool tcurses_vt100_checkkey(FAR struct termcurses_s *dev)
{
FAR struct tcurses_vt100_s *priv;
int ret;
int fd;
fd_set rfds;
struct timeval tv;
priv = (FAR struct tcurses_vt100_s *) dev;
fd = priv->in_fd;
/* Test for queued characters */
if (priv->keycount > 0)
{
return true;
}
/* Watch stdin (fd 0) to see when it has input. */
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
/* Wait up to 1000us for next character after ESC */
tv.tv_sec = 0;
tv.tv_usec = 0;
ret = select(1, &rfds, NULL, NULL, &tv);
if (ret > 0)
{
return true;
}
return false;
}
/************************************************************************************
* Public Functions
************************************************************************************/
/************************************************************************************
* Name: tcurses_vt100_initialize
*
* Description:
* Initialize a specific instance of the VT100 TermCurses handler and bind it to
* a specific file descriptor pair (input/output ... typically stdin / stdout).
*
************************************************************************************/
FAR struct termcurses_s *tcurses_vt100_initialize(int in_fd, int out_fd)
{
FAR struct tcurses_vt100_s *priv;
/* Allocate a new device structure */
priv = (FAR struct tcurses_vt100_s *)zalloc(sizeof(struct tcurses_vt100_s));
if (priv == NULL)
{
return NULL;
}
/* Populate the device context */
priv->dev.ops = &g_vt100_ops;
priv->dev.name = g_vt100_tcurs.name;
priv->dev.next = NULL;
priv->in_fd = in_fd;
priv->out_fd = out_fd;
priv->keycount = 0;
return (FAR struct termcurses_s *) priv;
}
Reference in New Issue View Git Blame Copy Permalink