/* vi:set sts=4 sw=4: * * VIM - Vi IMproved by Bram Moolenaar * * Do ":help uganda" in Vim to read copying and usage conditions. * Do ":help credits" in Vim to see a list of people who contributed. */ /* * * term.c: functions for controlling the terminal * * primitive termcap support for Amiga, MSDOS, and Win32 included * * NOTE: padding and variable substitution is not performed, * when compiling without HAVE_TGETENT, we use tputs() and tgoto() dummies. */ /* * Some systems have a prototype for tgetstr() with (char *) instead of * (char **). This define removes that prototype. We include our own prototype * below. */ #define tgetstr tgetstr_defined_wrong #include "vim.h" #include "globals.h" #include "option.h" #include "proto.h" #ifdef HAVE_TGETENT # ifdef HAVE_TERMIOS_H # include /* seems to be required for some Linux */ # endif # ifdef HAVE_TERMCAP_H # include # endif /* * A few linux systems define outfuntype in termcap.h to be used as the third * argument for tputs(). */ # ifdef VMS # define TPUTSFUNCAST # else # ifdef HAVE_OUTFUNTYPE # define TPUTSFUNCAST (outfuntype) # else # define TPUTSFUNCAST (int (*)()) # endif # endif #endif #undef tgetstr /* * Here are the builtin termcap entries. They are not stored as complete * Tcarr structures, as such a structure is too big. * * The entries are compact, therefore they normally are included even when * HAVE_TGETENT is defined. When HAVE_TGETENT is defined, the builtin entries * can be accessed with "builtin_amiga", "builtin_ansi", "builtin_debug", etc. * * Each termcap is a list of builtin_term structures. It always starts with * KS_NAME, which separates the entries. See parse_builtin_tcap() for all * details. * bt_entry is either a KS_xxx code (< 0x100), or a K_xxx code. */ struct builtin_term { enum SpecialKey bt_entry; char *bt_string; }; /* start of keys that are not directly used by Vim but can be mapped */ #define BT_EXTRA_KEYS 0x101 static struct builtin_term *find_builtin_term __ARGS((char_u *name)); static void parse_builtin_tcap __ARGS((char_u *s)); static void gather_termleader __ARGS((void)); static int get_bytes_from_buf __ARGS((char_u *, char_u *, int)); static int is_builtin_term __ARGS((char_u *)); #ifdef HAVE_TGETENT static char_u *tgetent_error __ARGS((char_u *, char_u *)); /* * Here is our own prototype for tgetstr(), any prototypes from the include * files have been disabled by the define at the start of this file. */ char *tgetstr __PARMS((char *, char **)); /* * Don't declare these variables if termcap.h contains them. * Autoconf checks if these variables should be declared extern (not all * systems have them). * Some versions define ospeed to be speed_t, but that is incompatible with * BSD, where ospeed is short and speed_t is long. */ # ifndef HAVE_OSPEED # ifdef OSPEED_EXTERN extern short ospeed; # else short ospeed; # endif # endif # ifndef HAVE_UP_BC_PC # ifdef UP_BC_PC_EXTERN extern char *UP, *BC, PC; # else char *UP, *BC, PC; # endif # endif # define TGETSTR(s, p) (char_u *)tgetstr((s), (char **)(p)) # define TGETENT(b, t) tgetent((char *)(b), (char *)(t)) #endif /* HAVE_TGETENT */ struct builtin_term builtin_termcaps[] = { #if defined(USE_GUI) /* * Motif/Athena pseudo term-cap. */ {KS_NAME, "gui"}, {KS_CE, "\033|$"}, {KS_AL, "\033|i"}, # ifdef TERMINFO {KS_CAL, "\033|%p1%dI"}, # else {KS_CAL, "\033|%dI"}, # endif {KS_DL, "\033|d"}, # ifdef TERMINFO {KS_CDL, "\033|%p1%dD"}, {KS_CS, "\033|%p1%d;%p2%dR"}, # else {KS_CDL, "\033|%dD"}, {KS_CS, "\033|%d;%dR"}, # endif {KS_CL, "\033|C"}, {KS_ME, "\033|31H"}, /* 31 = HL_ALL, H = off */ {KS_MR, "\033|1h"}, /* 1 = HL_INVERSE, h = on */ {KS_MD, "\033|2h"}, /* 2 = HL_BOLD, h = on */ {KS_SE, "\033|16H"}, /* 16 = HL_STANDOUT, H = off */ {KS_SO, "\033|16h"}, /* 16 = HL_STANDOUT, h = on */ {KS_UE, "\033|8H"}, /* 8 = HL_UNDERLINE, H = off */ {KS_US, "\033|8h"}, /* 8 = HL_UNDERLINE, h = on */ {KS_CZR, "\033|4H"}, /* 4 = HL_ITALIC, H = off */ {KS_CZH, "\033|4h"}, /* 4 = HL_ITALIC, h = on */ {KS_VB, "\033|f"}, {KS_MS, "y"}, # ifdef TERMINFO {KS_CM, "\033|%p1%d;%p2%dM"}, # else {KS_CM, "\033|%d;%dM"}, # endif /* there are no key sequences here, the GUI sequences are recognized * in check_termcodes() */ #endif #ifndef NO_BUILTIN_TCAPS # if defined(AMIGA) || defined(ALL_BUILTIN_TCAPS) /* * Amiga console window, default for Amiga */ {KS_NAME, "amiga"}, {KS_CE, "\033[K"}, {KS_CD, "\033[J"}, {KS_AL, "\033[L"}, # ifdef TERMINFO {KS_CAL, "\033[%p1%dL"}, # else {KS_CAL, "\033[%dL"}, # endif {KS_DL, "\033[M"}, # ifdef TERMINFO {KS_CDL, "\033[%p1%dM"}, # else {KS_CDL, "\033[%dM"}, # endif {KS_CL, "\014"}, {KS_VI, "\033[0 p"}, {KS_VE, "\033[1 p"}, {KS_ME, "\033[0m"}, {KS_MR, "\033[7m"}, {KS_MD, "\033[1m"}, {KS_SE, "\033[0m"}, {KS_SO, "\033[33m"}, {KS_US, "\033[4m"}, {KS_UE, "\033[0m"}, {KS_CZH, "\033[3m"}, {KS_CZR, "\033[0m"}, {KS_MS, "y"}, # ifdef TERMINFO {KS_CM, "\033[%i%p1%d;%p2%dH"}, # else {KS_CM, "\033[%i%d;%dH"}, # endif # ifdef TERMINFO {KS_CRI, "\033[%p1%dC"}, # else {KS_CRI, "\033[%dC"}, # endif {(SKEY)K_UP, "\233A"}, {(SKEY)K_DOWN, "\233B"}, {(SKEY)K_LEFT, "\233D"}, {(SKEY)K_RIGHT, "\233C"}, {(SKEY)K_S_UP, "\233T"}, {(SKEY)K_S_DOWN, "\233S"}, {(SKEY)K_S_LEFT, "\233 A"}, {(SKEY)K_S_RIGHT, "\233 @"}, {(SKEY)K_S_TAB, "\233Z"}, {(SKEY)K_F1, "\233\060~"},/* some compilers don't dig "\2330" */ {(SKEY)K_F2, "\233\061~"}, {(SKEY)K_F3, "\233\062~"}, {(SKEY)K_F4, "\233\063~"}, {(SKEY)K_F5, "\233\064~"}, {(SKEY)K_F6, "\233\065~"}, {(SKEY)K_F7, "\233\066~"}, {(SKEY)K_F8, "\233\067~"}, {(SKEY)K_F9, "\233\070~"}, {(SKEY)K_F10, "\233\071~"}, {(SKEY)K_S_F1, "\233\061\060~"}, {(SKEY)K_S_F2, "\233\061\061~"}, {(SKEY)K_S_F3, "\233\061\062~"}, {(SKEY)K_S_F4, "\233\061\063~"}, {(SKEY)K_S_F5, "\233\061\064~"}, {(SKEY)K_S_F6, "\233\061\065~"}, {(SKEY)K_S_F7, "\233\061\066~"}, {(SKEY)K_S_F8, "\233\061\067~"}, {(SKEY)K_S_F9, "\233\061\070~"}, {(SKEY)K_S_F10, "\233\061\071~"}, {(SKEY)K_HELP, "\233?~"}, {(SKEY)K_INS, "\233\064\060~"}, /* 101 key keyboard */ {(SKEY)K_PAGEUP, "\233\064\061~"}, /* 101 key keyboard */ {(SKEY)K_PAGEDOWN, "\233\064\062~"}, /* 101 key keyboard */ {(SKEY)K_HOME, "\233\064\064~"}, /* 101 key keyboard */ {(SKEY)K_END, "\233\064\065~"}, /* 101 key keyboard */ {(SKEY)BT_EXTRA_KEYS, ""}, {(SKEY)TERMCAP2KEY('#', '2'), "\233\065\064~"}, /* shifted home key */ {(SKEY)TERMCAP2KEY('#', '3'), "\233\065\060~"}, /* shifted insert key */ {(SKEY)TERMCAP2KEY('*', '7'), "\233\065\065~"}, /* shifted end key */ # endif # if defined(BEBOX) || defined(ALL_BUILTIN_TCAPS) /* * almost standard ANSI terminal, default for bebox */ {KS_NAME, "bebox-ansi"}, {KS_CE, "\033[K"}, {KS_CD, "\033[J"}, {KS_AL, "\033[L"}, # ifdef TERMINFO {KS_CAL, "\033[%p1%dL"}, # else {KS_CAL, "\033[%dL"}, # endif {KS_DL, "\033[M"}, # ifdef TERMINFO {KS_CDL, "\033[%p1%dM"}, # else {KS_CDL, "\033[%dM"}, # endif #ifdef notyet # ifdef TERMINFO {KS_CS, "\033[%i%p1%d;%p2%dr"}, # else {KS_CS, "\033[%i%d;%dr"}, /* scroll region */ # endif #endif {KS_CL, "\033[H\033[2J"}, #ifdef notyet {KS_VI, "[VI]"}, {KS_VE, "[VE]"}, #endif {KS_ME, "\033[m"}, /* normal mode */ {KS_MR, "\033[7m"}, /* reverse */ {KS_MD, "\033[1m"}, /* bold */ {KS_SO, "\033[31m"}, /* standout mode: red */ {KS_SE, "\033[m"}, /* standout end */ {KS_CZH, "\033[35m"}, /* italic: purple */ {KS_CZR, "\033[m"}, /* italic end */ {KS_US, "\033[4m"}, /* underscore mode */ {KS_UE, "\033[m"}, /* underscore end */ {KS_CCO, "8"}, /* allow 8 colors */ # ifdef TERMINFO {KS_CAB, "\033[4%p1%dm"},/* set background color */ {KS_CAF, "\033[3%p1%dm"},/* set foreground color */ # else {KS_CAB, "\033[4%dm"}, /* set background color */ {KS_CAF, "\033[3%dm"}, /* set foreground color */ # endif {KS_MS, "y"}, /* safe to move cur in reverse mode */ # ifdef TERMINFO {KS_CM, "\033[%i%p1%d;%p2%dH"}, # else {KS_CM, "\033[%i%d;%dH"}, # endif {KS_SR, "\033M"}, # ifdef TERMINFO {KS_CRI, "\033[%p1%dC"}, # else {KS_CRI, "\033[%dC"}, # endif {KS_DB, ""}, /* hack! see screen.c */ {(SKEY)K_UP, "\033[A"}, {(SKEY)K_DOWN, "\033[B"}, {(SKEY)K_LEFT, "\033[D"}, {(SKEY)K_RIGHT, "\033[C"}, # endif # if defined(UNIX) || defined(ALL_BUILTIN_TCAPS) || defined(SOME_BUILTIN_TCAPS) || defined(__EMX__) /* * standard ANSI terminal, default for unix */ {KS_NAME, "ansi"}, {KS_CE, "\033[K"}, {KS_AL, "\033[L"}, # ifdef TERMINFO {KS_CAL, "\033[%p1%dL"}, # else {KS_CAL, "\033[%dL"}, # endif {KS_DL, "\033[M"}, # ifdef TERMINFO {KS_CDL, "\033[%p1%dM"}, # else {KS_CDL, "\033[%dM"}, # endif {KS_CL, "\033[H\033[2J"}, {KS_ME, "\033[0m"}, {KS_MR, "\033[7m"}, {KS_MS, "y"}, # ifdef TERMINFO {KS_CM, "\033[%i%p1%d;%p2%dH"}, # else {KS_CM, "\033[%i%d;%dH"}, # endif # ifdef TERMINFO {KS_CRI, "\033[%p1%dC"}, # else {KS_CRI, "\033[%dC"}, # endif # endif # if defined(MSDOS) || defined(ALL_BUILTIN_TCAPS) || defined(__EMX__) /* * These codes are valid when nansi.sys or equivalent has been installed. * Function keys on a PC are preceded with a NUL. These are converted into * K_NUL '\316' in mch_inchar(), because we cannot handle NULs in key codes. * CTRL-arrow is used instead of SHIFT-arrow. */ #ifdef __EMX__ {KS_NAME, "os2ansi"}, #else {KS_NAME, "pcansi"}, {KS_DL, "\033[M"}, {KS_AL, "\033[L"}, #endif {KS_CE, "\033[K"}, {KS_CL, "\033[2J"}, {KS_ME, "\033[0m"}, {KS_MR, "\033[7m"}, {KS_MS, "y"}, # ifdef TERMINFO {KS_CM, "\033[%i%p1%d;%p2%dH"}, # else {KS_CM, "\033[%i%d;%dH"}, # endif # ifdef TERMINFO {KS_CRI, "\033[%p1%dC"}, # else {KS_CRI, "\033[%dC"}, # endif {(SKEY)K_UP, "\316H"}, {(SKEY)K_DOWN, "\316P"}, {(SKEY)K_LEFT, "\316K"}, {(SKEY)K_RIGHT, "\316M"}, {(SKEY)K_S_LEFT, "\316s"}, {(SKEY)K_S_RIGHT, "\316t"}, {(SKEY)K_F1, "\316;"}, {(SKEY)K_F2, "\316<"}, {(SKEY)K_F3, "\316="}, {(SKEY)K_F4, "\316>"}, {(SKEY)K_F5, "\316?"}, {(SKEY)K_F6, "\316@"}, {(SKEY)K_F7, "\316A"}, {(SKEY)K_F8, "\316B"}, {(SKEY)K_F9, "\316C"}, {(SKEY)K_F10, "\316D"}, {(SKEY)K_F11, "\316\205"}, /* guessed */ {(SKEY)K_F12, "\316\206"}, /* guessed */ {(SKEY)K_S_F1, "\316T"}, {(SKEY)K_S_F2, "\316U"}, {(SKEY)K_S_F3, "\316V"}, {(SKEY)K_S_F4, "\316W"}, {(SKEY)K_S_F5, "\316X"}, {(SKEY)K_S_F6, "\316Y"}, {(SKEY)K_S_F7, "\316Z"}, {(SKEY)K_S_F8, "\316["}, {(SKEY)K_S_F9, "\316\\"}, {(SKEY)K_S_F10, "\316]"}, {(SKEY)K_S_F11, "\316\207"}, /* guessed */ {(SKEY)K_S_F12, "\316\210"}, /* guessed */ {(SKEY)K_INS, "\316R"}, {(SKEY)K_DEL, "\316S"}, {(SKEY)K_HOME, "\316G"}, {(SKEY)K_END, "\316O"}, {(SKEY)K_PAGEDOWN, "\316Q"}, {(SKEY)K_PAGEUP, "\316I"}, # endif # if defined(MSDOS) /* * These codes are valid for the pc video. The entries that start with ESC | * are translated into conio calls in os_msdos.c. Default for MSDOS. */ {KS_NAME, "pcterm"}, {KS_CE, "\033|K"}, {KS_AL, "\033|L"}, {KS_DL, "\033|M"}, # ifdef TERMINFO {KS_CS, "\033|%i%p1%d;%p2%dr"}, # else {KS_CS, "\033|%i%d;%dr"}, # endif {KS_CL, "\033|J"}, {KS_ME, "\033|0m"}, /* normal */ {KS_MR, "\033|112m"}, /* reverse: black on lightgrey */ {KS_MD, "\033|15m"}, /* bold: white text */ {KS_SE, "\033|0m"}, /* standout end */ {KS_SO, "\033|31m"}, /* standout: white on blue */ {KS_CZH, "\033|225m"}, /* italic mode: blue text on yellow */ {KS_CZR, "\033|0m"}, /* italic mode end */ {KS_US, "\033|67m"}, /* underscore mode: cyan text on red */ {KS_UE, "\033|0m"}, /* underscore mode end */ {KS_CCO, "16"}, /* allow 16 colors */ # ifdef TERMINFO {KS_CAB, "\033|%p1%db"}, /* set background color */ {KS_CAF, "\033|%p1%df"}, /* set foreground color */ # else {KS_CAB, "\033|%db"}, /* set background color */ {KS_CAF, "\033|%df"}, /* set foreground color */ # endif {KS_MS, "y"}, # ifdef TERMINFO {KS_CM, "\033|%i%p1%d;%p2%dH"}, # else {KS_CM, "\033|%i%d;%dH"}, # endif #ifdef DJGPP {KS_VB, "\033|B"}, /* visual bell */ #endif {(SKEY)K_UP, "\316H"}, {(SKEY)K_DOWN, "\316P"}, {(SKEY)K_LEFT, "\316K"}, {(SKEY)K_RIGHT, "\316M"}, {(SKEY)K_S_LEFT, "\316s"}, {(SKEY)K_S_RIGHT, "\316t"}, {(SKEY)K_S_TAB, "\316\017"}, {(SKEY)K_F1, "\316;"}, {(SKEY)K_F2, "\316<"}, {(SKEY)K_F3, "\316="}, {(SKEY)K_F4, "\316>"}, {(SKEY)K_F5, "\316?"}, {(SKEY)K_F6, "\316@"}, {(SKEY)K_F7, "\316A"}, {(SKEY)K_F8, "\316B"}, {(SKEY)K_F9, "\316C"}, {(SKEY)K_F10, "\316D"}, {(SKEY)K_F11, "\316\205"}, /* only when nobioskey */ {(SKEY)K_F12, "\316\206"}, /* only when nobioskey */ {(SKEY)K_S_F1, "\316T"}, {(SKEY)K_S_F2, "\316U"}, {(SKEY)K_S_F3, "\316V"}, {(SKEY)K_S_F4, "\316W"}, {(SKEY)K_S_F5, "\316X"}, {(SKEY)K_S_F6, "\316Y"}, {(SKEY)K_S_F7, "\316Z"}, {(SKEY)K_S_F8, "\316["}, {(SKEY)K_S_F9, "\316\\"}, {(SKEY)K_S_F10, "\316]"}, {(SKEY)K_S_F11, "\316\207"}, /* only when nobioskey */ {(SKEY)K_S_F12, "\316\210"}, /* only when nobioskey */ {(SKEY)K_INS, "\316R"}, {(SKEY)K_DEL, "\316S"}, {(SKEY)K_HOME, "\316G"}, {(SKEY)K_END, "\316O"}, {(SKEY)K_PAGEDOWN, "\316Q"}, {(SKEY)K_PAGEUP, "\316I"}, # endif # if defined(WIN32) || defined(ALL_BUILTIN_TCAPS) || defined(__EMX__) /* * These codes are valid for the Win32 Console . The entries that start with * ESC | are translated into console calls in os_win32.c. The function keys * are also translated in os_win32.c. */ {KS_NAME, "win32"}, {KS_CE, "\033|K"}, /* clear to end of line */ {KS_AL, "\033|L"}, /* add new blank line */ # ifdef TERMINFO {KS_CAL, "\033|%p1%dL"}, /* add number of new blank lines */ # else {KS_CAL, "\033|%dL"}, /* add number of new blank lines */ # endif {KS_DL, "\033|M"}, /* delete line */ # ifdef TERMINFO {KS_CDL, "\033|%p1%dM"}, /* delete number of lines */ # else {KS_CDL, "\033|%dM"}, /* delete number of lines */ # endif {KS_CL, "\033|J"}, /* clear screen */ {KS_CD, "\033|j"}, /* clear to end of display */ {KS_VI, "\033|v"}, /* cursor invisible */ {KS_VE, "\033|V"}, /* cursor visible */ {KS_ME, "\033|0m"}, /* normal */ {KS_MR, "\033|112m"}, /* reverse: black on lightgray */ {KS_MD, "\033|15m"}, /* bold: white on black */ #if 1 {KS_SO, "\033|31m"}, /* standout: white on blue */ {KS_SE, "\033|0m"}, /* standout end */ #else {KS_SO, "\033|F"}, /* standout: high intensity */ {KS_SE, "\033|f"}, /* standout end */ #endif {KS_CZH, "\033|225m"}, /* italic: blue text on yellow */ {KS_CZR, "\033|0m"}, /* italic end */ {KS_US, "\033|67m"}, /* underscore: cyan text on red */ {KS_UE, "\033|0m"}, /* underscore end */ {KS_CCO, "16"}, /* allow 16 colors */ # ifdef TERMINFO {KS_CAB, "\033|%p1%db"}, /* set background color */ {KS_CAF, "\033|%p1%df"}, /* set foreground color */ # else {KS_CAB, "\033|%db"}, /* set background color */ {KS_CAF, "\033|%df"}, /* set foreground color */ # endif {KS_MS, "y"}, /* save to move cur in reverse mode */ # ifdef TERMINFO {KS_CM, "\033|%i%p1%d;%p2%dH"}, /* cursor motion */ # else {KS_CM, "\033|%i%d;%dH"}, /* cursor motion */ # endif {KS_VB, "\033|B"}, /* visual bell */ {KS_TI, "\033|S"}, /* put terminal in termcap mode */ {KS_TE, "\033|E"}, /* out of termcap mode */ {KS_CS, "\033|%i%d;%dr"}, /* scroll region */ {(SKEY)K_UP, "\316H"}, {(SKEY)K_DOWN, "\316P"}, {(SKEY)K_LEFT, "\316K"}, {(SKEY)K_RIGHT, "\316M"}, {(SKEY)K_S_UP, "\316\304"}, {(SKEY)K_S_DOWN, "\316\317"}, {(SKEY)K_S_LEFT, "\316\311"}, {(SKEY)K_S_RIGHT, "\316\313"}, {(SKEY)K_S_TAB, "\316\017"}, {(SKEY)K_F1, "\316;"}, {(SKEY)K_F2, "\316<"}, {(SKEY)K_F3, "\316="}, {(SKEY)K_F4, "\316>"}, {(SKEY)K_F5, "\316?"}, {(SKEY)K_F6, "\316@"}, {(SKEY)K_F7, "\316A"}, {(SKEY)K_F8, "\316B"}, {(SKEY)K_F9, "\316C"}, {(SKEY)K_F10, "\316D"}, {(SKEY)K_F11, "\316\205"}, {(SKEY)K_F12, "\316\206"}, {(SKEY)K_S_F1, "\316T"}, {(SKEY)K_S_F2, "\316U"}, {(SKEY)K_S_F3, "\316V"}, {(SKEY)K_S_F4, "\316W"}, {(SKEY)K_S_F5, "\316X"}, {(SKEY)K_S_F6, "\316Y"}, {(SKEY)K_S_F7, "\316Z"}, {(SKEY)K_S_F8, "\316["}, {(SKEY)K_S_F9, "\316\\"}, {(SKEY)K_S_F10, "\316]"}, {(SKEY)K_S_F11, "\316\207"}, {(SKEY)K_S_F12, "\316\210"}, {(SKEY)K_INS, "\316R"}, {(SKEY)K_DEL, "\316S"}, {(SKEY)K_HOME, "\316G"}, {(SKEY)K_END, "\316O"}, {(SKEY)K_PAGEDOWN, "\316Q"}, {(SKEY)K_PAGEUP, "\316I"}, # endif # if defined(ALL_BUILTIN_TCAPS) || defined(__MINT__) /* * Ordinary vt52 */ {KS_NAME, "vt52"}, {KS_CE, "\033K"}, {KS_CD, "\033J"}, {KS_CM, "\033Y%+ %+ "}, # ifdef __MINT__ {KS_AL, "\033L"}, {KS_DL, "\033M"}, {KS_CL, "\033E"}, {KS_SR, "\033I"}, {KS_VE, "\033e"}, {KS_VI, "\033f"}, {KS_SO, "\033p"}, {KS_SE, "\033q"}, {(SKEY)K_UP, "\033A"}, {(SKEY)K_DOWN, "\033B"}, {(SKEY)K_LEFT, "\033D"}, {(SKEY)K_RIGHT, "\033C"}, {(SKEY)K_S_UP, "\033a"}, {(SKEY)K_S_DOWN, "\033b"}, {(SKEY)K_S_LEFT, "\033d"}, {(SKEY)K_S_RIGHT, "\033c"}, {(SKEY)K_F1, "\033P"}, {(SKEY)K_F2, "\033Q"}, {(SKEY)K_F3, "\033R"}, {(SKEY)K_F4, "\033S"}, {(SKEY)K_F5, "\033T"}, {(SKEY)K_F6, "\033U"}, {(SKEY)K_F7, "\033V"}, {(SKEY)K_F8, "\033W"}, {(SKEY)K_F9, "\033X"}, {(SKEY)K_F10, "\033Y"}, {(SKEY)K_S_F1, "\033p"}, {(SKEY)K_S_F2, "\033q"}, {(SKEY)K_S_F3, "\033r"}, {(SKEY)K_S_F4, "\033s"}, {(SKEY)K_S_F5, "\033t"}, {(SKEY)K_S_F6, "\033u"}, {(SKEY)K_S_F7, "\033v"}, {(SKEY)K_S_F8, "\033w"}, {(SKEY)K_S_F9, "\033x"}, {(SKEY)K_S_F10, "\033y"}, {(SKEY)K_INS, "\033I"}, {(SKEY)K_HOME, "\033E"}, {(SKEY)K_PAGEDOWN, "\033b"}, {(SKEY)K_PAGEUP, "\033a"}, # else {KS_AL, "\033T"}, {KS_DL, "\033U"}, {KS_CL, "\033H\033J"}, {KS_ME, "\033SO"}, {KS_MR, "\033S2"}, {KS_MS, "y"}, # endif # endif # if defined(UNIX) || defined(ALL_BUILTIN_TCAPS) || defined(SOME_BUILTIN_TCAPS) || defined(__EMX__) /* * The xterm termcap is missing F14 and F15, because they send the same * codes as the undo and help key, although they don't work on all keyboards. */ {KS_NAME, "xterm"}, {KS_CE, "\033[K"}, {KS_AL, "\033[L"}, # ifdef TERMINFO {KS_CAL, "\033[%p1%dL"}, # else {KS_CAL, "\033[%dL"}, # endif {KS_DL, "\033[M"}, # ifdef TERMINFO {KS_CDL, "\033[%p1%dM"}, # else {KS_CDL, "\033[%dM"}, # endif # ifdef TERMINFO {KS_CS, "\033[%i%p1%d;%p2%dr"}, # else {KS_CS, "\033[%i%d;%dr"}, # endif {KS_CL, "\033[H\033[2J"}, {KS_CD, "\033[J"}, {KS_ME, "\033[m"}, {KS_MR, "\033[7m"}, {KS_MD, "\033[1m"}, {KS_UE, "\033[m"}, {KS_US, "\033[4m"}, {KS_CCO, "8"}, {KS_CAF, "\033[3%p1%dm"}, {KS_CAB, "\033[4%p1%dm"}, {KS_CSF, "\033[3%p1%dm"}, {KS_CSB, "\033[4%p1%dm"}, {KS_US, "\033[4m"}, {KS_MS, "y"}, # ifdef TERMINFO {KS_CM, "\033[%i%p1%d;%p2%dH"}, # else {KS_CM, "\033[%i%d;%dH"}, # endif {KS_SR, "\033M"}, # ifdef TERMINFO {KS_CRI, "\033[%p1%dC"}, # else {KS_CRI, "\033[%dC"}, # endif {KS_KS, "\033[?1h\033="}, {KS_KE, "\033[?1l\033>"}, # ifdef SAVE_XTERM_SCREEN {KS_TI, "\0337\033[?47h"}, {KS_TE, "\033[2J\033[?47l\0338"}, # endif {(SKEY)K_UP, "\033OA"}, {(SKEY)K_DOWN, "\033OB"}, {(SKEY)K_LEFT, "\033OD"}, {(SKEY)K_RIGHT, "\033OC"}, {(SKEY)K_S_UP, "\033Ox"}, {(SKEY)K_S_DOWN, "\033Or"}, {(SKEY)K_S_LEFT, "\033Ot"}, {(SKEY)K_S_RIGHT, "\033Ov"}, {(SKEY)K_F1, "\033[11~"}, {(SKEY)K_F2, "\033[12~"}, {(SKEY)K_F3, "\033[13~"}, {(SKEY)K_F4, "\033[14~"}, {(SKEY)K_F5, "\033[15~"}, {(SKEY)K_F6, "\033[17~"}, {(SKEY)K_F7, "\033[18~"}, {(SKEY)K_F8, "\033[19~"}, {(SKEY)K_F9, "\033[20~"}, {(SKEY)K_F10, "\033[21~"}, {(SKEY)K_F11, "\033[23~"}, {(SKEY)K_F12, "\033[24~"}, {(SKEY)K_HELP, "\033[28~"}, {(SKEY)K_UNDO, "\033[26~"}, {(SKEY)K_INS, "\033[2~"}, {(SKEY)K_HOME, "\033[7~"}, {(SKEY)K_KHOME, "\033[1~"}, {(SKEY)K_END, "\033[8~"}, {(SKEY)K_KEND, "\033[4~"}, {(SKEY)K_PAGEUP, "\033[5~"}, {(SKEY)K_PAGEDOWN, "\033[6~"}, /* {(SKEY)K_DEL, "\033[3~"}, not used */ {(SKEY)BT_EXTRA_KEYS, ""}, {(SKEY)TERMCAP2KEY('k', '0'), "\033[10~"}, /* F0 */ {(SKEY)TERMCAP2KEY('F', '3'), "\033[25~"}, /* F13 */ {(SKEY)TERMCAP2KEY('F', '6'), "\033[29~"}, /* F16 */ {(SKEY)TERMCAP2KEY('F', '7'), "\033[31~"}, /* F17 */ {(SKEY)TERMCAP2KEY('F', '8'), "\033[32~"}, /* F18 */ {(SKEY)TERMCAP2KEY('F', '9'), "\033[33~"}, /* F19 */ {(SKEY)TERMCAP2KEY('F', 'A'), "\033[34~"}, /* F20 */ # endif # if defined(UNIX) || defined(ALL_BUILTIN_TCAPS) /* * iris-ansi for Silicon Graphics machines. */ {KS_NAME, "iris-ansi"}, {KS_CE, "\033[K"}, {KS_CD, "\033[J"}, {KS_AL, "\033[L"}, # ifdef TERMINFO {KS_CAL, "\033[%p1%dL"}, # else {KS_CAL, "\033[%dL"}, # endif {KS_DL, "\033[M"}, # ifdef TERMINFO {KS_CDL, "\033[%p1%dM"}, # else {KS_CDL, "\033[%dM"}, # endif /* * This "cs" is not working correctly. What is the right one? */ #if 0 # ifdef TERMINFO {KS_CS, "\033[%i%p1%d;%p2%dr"}, # else {KS_CS, "\033[%i%d;%dr"}, # endif #endif {KS_CL, "\033[H\033[2J"}, {KS_VE, "\033[9/y\033[12/y\033[=6l"}, {KS_VS, "\033[10/y\033[=1h\033[=2l\033[=6h"}, {KS_SE, "\033[m"}, {KS_SO, "\033[1;7m"}, {KS_ME, "\033[m"}, {KS_MR, "\033[7m"}, {KS_MD, "\033[1m"}, {KS_UE, "\033[m"}, {KS_US, "\033[4m"}, {KS_MS, "y"}, /* does this really work? */ # ifdef TERMINFO {KS_CM, "\033[%i%p1%d;%p2%dH"}, # else {KS_CM, "\033[%i%d;%dH"}, # endif {KS_SR, "\033M"}, # ifdef TERMINFO {KS_CRI, "\033[%p1%dC"}, # else {KS_CRI, "\033[%dC"}, # endif {(SKEY)K_UP, "\033[A"}, {(SKEY)K_DOWN, "\033[B"}, {(SKEY)K_LEFT, "\033[D"}, {(SKEY)K_RIGHT, "\033[C"}, {(SKEY)K_S_UP, "\033[161q"}, {(SKEY)K_S_DOWN, "\033[164q"}, {(SKEY)K_S_LEFT, "\033[158q"}, {(SKEY)K_S_RIGHT, "\033[167q"}, {(SKEY)K_F1, "\033[001q"}, {(SKEY)K_F2, "\033[002q"}, {(SKEY)K_F3, "\033[003q"}, {(SKEY)K_F4, "\033[004q"}, {(SKEY)K_F5, "\033[005q"}, {(SKEY)K_F6, "\033[006q"}, {(SKEY)K_F7, "\033[007q"}, {(SKEY)K_F8, "\033[008q"}, {(SKEY)K_F9, "\033[009q"}, {(SKEY)K_F10, "\033[010q"}, {(SKEY)K_F11, "\033[011q"}, {(SKEY)K_F12, "\033[012q"}, {(SKEY)K_S_F1, "\033[013q"}, {(SKEY)K_S_F2, "\033[014q"}, {(SKEY)K_S_F3, "\033[015q"}, {(SKEY)K_S_F4, "\033[016q"}, {(SKEY)K_S_F5, "\033[017q"}, {(SKEY)K_S_F6, "\033[018q"}, {(SKEY)K_S_F7, "\033[019q"}, {(SKEY)K_S_F8, "\033[020q"}, {(SKEY)K_S_F9, "\033[021q"}, {(SKEY)K_S_F10, "\033[022q"}, {(SKEY)K_S_F11, "\033[023q"}, {(SKEY)K_S_F12, "\033[024q"}, {(SKEY)K_INS, "\033[139q"}, {(SKEY)K_HOME, "\033[H"}, {(SKEY)K_END, "\033[146q"}, {(SKEY)K_PAGEUP, "\033[150q"}, {(SKEY)K_PAGEDOWN, "\033[154q"}, # endif # if defined(DEBUG) || defined(ALL_BUILTIN_TCAPS) /* * for debugging */ {KS_NAME, "debug"}, {KS_CE, "[CE]"}, {KS_CD, "[CD]"}, {KS_AL, "[AL]"}, # ifdef TERMINFO {KS_CAL, "[CAL%p1%d]"}, # else {KS_CAL, "[CAL%d]"}, # endif {KS_DL, "[DL]"}, # ifdef TERMINFO {KS_CDL, "[CDL%p1%d]"}, # else {KS_CDL, "[CDL%d]"}, # endif # ifdef TERMINFO {KS_CS, "[%dCS%p1%d]"}, # else {KS_CS, "[%dCS%d]"}, # endif # ifdef TERMINFO {KS_CAB, "[CAB%p1%d]"}, {KS_CAF, "[CAF%p1%d]"}, {KS_CSB, "[CSB%p1%d]"}, {KS_CSF, "[CSF%p1%d]"}, # else {KS_CAB, "[CAB%d]"}, {KS_CAF, "[CAF%d]"}, {KS_CSB, "[CSB%d]"}, {KS_CSF, "[CSF%d]"}, # endif {KS_CL, "[CL]"}, {KS_VI, "[VI]"}, {KS_VE, "[VE]"}, {KS_VS, "[VS]"}, {KS_ME, "[ME]"}, {KS_MR, "[MR]"}, {KS_MB, "[MB]"}, {KS_MD, "[MD]"}, {KS_SE, "[SE]"}, {KS_SO, "[SO]"}, {KS_UE, "[UE]"}, {KS_US, "[US]"}, {KS_MS, "[MS]"}, # ifdef TERMINFO {KS_CM, "[%p1%dCM%p2%d]"}, # else {KS_CM, "[%dCM%d]"}, # endif {KS_SR, "[SR]"}, # ifdef TERMINFO {KS_CRI, "[CRI%p1%d]"}, # else {KS_CRI, "[CRI%d]"}, # endif {KS_VB, "[VB]"}, {KS_KS, "[KS]"}, {KS_KE, "[KE]"}, {KS_TI, "[TI]"}, {KS_TE, "[TE]"}, {(SKEY)K_UP, "[KU]"}, {(SKEY)K_DOWN, "[KD]"}, {(SKEY)K_LEFT, "[KL]"}, {(SKEY)K_RIGHT, "[KR]"}, {(SKEY)K_S_UP, "[S-KU]"}, {(SKEY)K_S_DOWN, "[S-KD]"}, {(SKEY)K_S_LEFT, "[S-KL]"}, {(SKEY)K_S_RIGHT, "[S-KR]"}, {(SKEY)K_F1, "[F1]"}, {(SKEY)K_F2, "[F2]"}, {(SKEY)K_F3, "[F3]"}, {(SKEY)K_F4, "[F4]"}, {(SKEY)K_F5, "[F5]"}, {(SKEY)K_F6, "[F6]"}, {(SKEY)K_F7, "[F7]"}, {(SKEY)K_F8, "[F8]"}, {(SKEY)K_F9, "[F9]"}, {(SKEY)K_F10, "[F10]"}, {(SKEY)K_F11, "[F11]"}, {(SKEY)K_F12, "[F12]"}, {(SKEY)K_S_F1, "[S-F1]"}, {(SKEY)K_S_F2, "[S-F2]"}, {(SKEY)K_S_F3, "[S-F3]"}, {(SKEY)K_S_F4, "[S-F4]"}, {(SKEY)K_S_F5, "[S-F5]"}, {(SKEY)K_S_F6, "[S-F6]"}, {(SKEY)K_S_F7, "[S-F7]"}, {(SKEY)K_S_F8, "[S-F8]"}, {(SKEY)K_S_F9, "[S-F9]"}, {(SKEY)K_S_F10, "[S-F10]"}, {(SKEY)K_S_F11, "[S-F11]"}, {(SKEY)K_S_F12, "[S-F12]"}, {(SKEY)K_HELP, "[HELP]"}, {(SKEY)K_UNDO, "[UNDO]"}, {(SKEY)K_BS, "[BS]"}, {(SKEY)K_INS, "[INS]"}, {(SKEY)K_DEL, "[DEL]"}, {(SKEY)K_HOME, "[HOME]"}, {(SKEY)K_END, "[END]"}, {(SKEY)K_PAGEUP, "[PAGEUP]"}, {(SKEY)K_PAGEDOWN, "[PAGEDOWN]"}, {(SKEY)K_KHOME, "[KHOME]"}, {(SKEY)K_KEND, "[KEND]"}, {(SKEY)K_KPAGEUP, "[KPAGEUP]"}, {(SKEY)K_KPAGEDOWN, "[KPAGEDOWN]"}, {(SKEY)K_MOUSE, "[MOUSE]"}, # endif #endif /* NO_BUILTIN_TCAPS */ /* * The most minimal terminal: only clear screen and cursor positioning * Always included. */ {KS_NAME, "dumb"}, {KS_CL, "\014"}, #ifdef TERMINFO {KS_CM, "\033[%i%p1%d;%p2%dH"}, #else {KS_CM, "\033[%i%d;%dH"}, #endif /* * end marker */ {KS_NAME, NULL} }; /* end of builtin_termcaps */ /* * DEFAULT_TERM is used, when no terminal is specified with -T option or $TERM. */ #ifdef AMIGA # define DEFAULT_TERM (char_u *)"amiga" #endif #ifdef WIN32 # define DEFAULT_TERM (char_u *)"win32" #endif #ifdef MSDOS # define DEFAULT_TERM (char_u *)"pcterm" #endif #if defined(UNIX) && !defined(__MINT__) # define DEFAULT_TERM (char_u *)"ansi" #endif #ifdef __MINT__ # define DEFAULT_TERM (char_u *)"vt52" #endif #ifdef __EMX__ # define DEFAULT_TERM (char_u *)"os2ansi" #endif #ifdef VMS # define DEFAULT_TERM (char_u *)"ansi" #endif #ifdef BEBOX # undef DEFAULT_TERM # define DEFAULT_TERM (char_u *)"bebox-ansi" #endif /* * Term_strings contains currently used terminal output strings. * It is initialized with the default values by parse_builtin_tcap(). * The values can be changed by setting the option with the same name. */ char_u *(term_strings[(int)KS_LAST + 1]); static int need_gather = FALSE; /* need to fill termleader[] */ static char_u termleader[256 + 1]; /* for check_termcode() */ static struct builtin_term * find_builtin_term(term) char_u *term; { struct builtin_term *p; p = builtin_termcaps; while (p->bt_string != NULL) { if (p->bt_entry == KS_NAME) { #ifdef UNIX if (STRCMP(p->bt_string, "iris-ansi") == 0 && is_iris_ansi(term)) return p; else if (STRCMP(p->bt_string, "xterm") == 0 && is_xterm(term)) return p; else #endif if (STRCMP(term, p->bt_string) == 0) return p; } ++p; } return p; } /* * Parsing of the builtin termcap entries. * Caller should check if 'name' is a valid builtin term. * The terminal's name is not set, as this is already done in termcapinit(). */ static void parse_builtin_tcap(term) char_u *term; { struct builtin_term *p; char_u name[2]; p = find_builtin_term(term); for (++p; p->bt_entry != KS_NAME && p->bt_entry != (SKEY)BT_EXTRA_KEYS; ++p) { if ((int)p->bt_entry < 0x100) /* KS_xx entry */ { if (term_strings[p->bt_entry] == NULL || term_strings[p->bt_entry] == empty_option) term_strings[p->bt_entry] = (char_u *)p->bt_string; } else { name[0] = KEY2TERMCAP0((int)p->bt_entry); name[1] = KEY2TERMCAP1((int)p->bt_entry); if (find_termcode(name) == NULL) add_termcode(name, (char_u *)p->bt_string); } } } /* * Set terminal options for terminal "term". * Return OK if terminal 'term' was found in a termcap, FAIL otherwise. * * While doing this, until ttest(), some options may be NULL, be careful. */ int set_termname(term) char_u *term; { struct builtin_term *termp; #ifdef HAVE_TGETENT int builtin_first = p_tbi; int try; int termcap_cleared = FALSE; static char nr_colors[15]; /* string for number of colors */ #endif int width = 0, height = 0; char_u *error_msg = NULL; char_u *bs_p, *del_p; if (is_builtin_term(term)) { term += 8; #ifdef HAVE_TGETENT builtin_first = 1; #endif } /* * If HAVE_TGETENT is not defined, only the builtin termcap is used, otherwise: * If builtin_first is TRUE: * 0. try builtin termcap * 1. try external termcap * 2. if both fail default to a builtin terminal * If builtin_first is FALSE: * 1. try external termcap * 2. try builtin termcap, if both fail default to a builtin terminal */ #ifdef HAVE_TGETENT for (try = builtin_first ? 0 : 1; try < 3; ++try) { /* * Use external termcap */ if (try == 1) { char_u *p; static char_u tstrbuf[TBUFSZ]; int i; char_u tbuf[TBUFSZ]; char_u *tp = tstrbuf; static char *(key_names[]) = { "ku", "kd", "kr", /* "kl" is a special case */ # ifdef ARCHIE "su", "sd", /* Termcap code made up! */ # endif "#4", "%i", "k1", "k2", "k3", "k4", "k5", "k6", "k7", "k8", "k9", "k;", "F1", "F2", "%1", "&8", "kb", "kI", "kD", "kh", "@7", "kP", "kN", "K1", "K3", "K4", "K5", NULL }; static struct { enum SpecialKey dest; /* index in term_strings[] */ char *name; /* termcap name for string */ } string_names[] = { {KS_CE, "ce"}, {KS_AL, "al"}, {KS_CAL, "AL"}, {KS_DL, "dl"}, {KS_CDL, "DL"}, {KS_CS, "cs"}, {KS_CL, "cl"}, {KS_CD, "cd"}, {KS_VI, "vi"}, {KS_VE, "ve"}, {KS_MB, "mb"}, {KS_VS, "vs"}, {KS_ME, "me"}, {KS_MR, "mr"}, {KS_MD, "md"}, {KS_SE, "se"}, {KS_SO, "so"}, {KS_CZH, "ZH"}, {KS_CZR, "ZR"}, {KS_UE, "ue"}, {KS_US, "us"}, {KS_CM, "cm"}, {KS_SR, "sr"}, {KS_CRI, "RI"}, {KS_VB, "vb"}, {KS_KS, "ks"}, {KS_KE, "ke"}, {KS_TI, "ti"}, {KS_TE, "te"}, {KS_BC, "bc"}, {KS_CSB, "Sb"}, {KS_CSF, "Sf"}, {KS_CAB, "AB"}, {KS_CAF, "AF"}, {KS_CCO, "Co"}, {0, NULL} }; /* * If the external termcap does not have a matching entry, try the * builtin ones. */ if ((error_msg = tgetent_error(tbuf, term)) == NULL) { if (!termcap_cleared) { clear_termoptions(); /* clear old options */ termcap_cleared = TRUE; } /* get output strings */ for (i = 0; string_names[i].name != NULL; ++i) { if (term_strings[string_names[i].dest] == NULL || term_strings[string_names[i].dest] == empty_option) term_strings[string_names[i].dest] = TGETSTR(string_names[i].name, &tp); } if ((T_MS == NULL || T_MS == empty_option) && tgetflag("ms")) T_MS = (char_u *)"y"; if ((T_XS == NULL || T_XS == empty_option) && tgetflag("xs")) T_XS = (char_u *)"y"; if ((T_DB == NULL || T_DB == empty_option) && tgetflag("db")) T_DB = (char_u *)"y"; if ((T_DA == NULL || T_DA == empty_option) && tgetflag("da")) T_DA = (char_u *)"y"; /* get key codes */ for (i = 0; key_names[i] != NULL; ++i) { if (find_termcode((char_u *)key_names[i]) == NULL) add_termcode((char_u *)key_names[i], TGETSTR(key_names[i], &tp)); } /* if cursor-left == backspace, ignore it (televideo 925) */ if (find_termcode((char_u *)"kl") == NULL) { p = TGETSTR("kl", &tp); if (p != NULL && *p != Ctrl('H')) add_termcode((char_u *)"kl", p); } if (height == 0) height = tgetnum("li"); if (width == 0) width = tgetnum("co"); /* * Get number of colors. If non-zero, store as string in * nr_colors[]. */ i = tgetnum("Co"); if (i > 0) { sprintf(nr_colors, "%d", i); T_CCO = (char_u *)nr_colors; } # ifndef hpux BC = (char *)TGETSTR("bc", &tp); UP = (char *)TGETSTR("up", &tp); p = TGETSTR("pc", &tp); if (p) PC = *p; # endif /* hpux */ } } else /* try == 0 || try == 2 */ #endif /* HAVE_TGETENT */ /* * Use builtin termcap */ { #ifdef HAVE_TGETENT /* * If builtin termcap was already used, there is no need to search * for the builtin termcap again, quit now. */ if (try == 2 && builtin_first && termcap_cleared) break; #endif /* * search for 'term' in builtin_termcaps[] */ termp = find_builtin_term(term); if (termp->bt_string == NULL) /* did not find it */ { #ifdef HAVE_TGETENT /* * If try == 0, first try the external termcap. If that is not * found we'll get back here with try == 2. * If termcap_cleared is set we used the external termcap, * don't complain about not finding the term in the builtin * termcap. */ if (try == 0) /* try external one */ continue; if (termcap_cleared) /* found in external termcap */ break; #endif fprintf(stderr, "\r\n"); if (error_msg != NULL) { fprintf(stderr, (char *)error_msg); fprintf(stderr, "\r\n"); } fprintf(stderr, "'%s' not known. Available builtin terminals are:\r\n", term); for (termp = &(builtin_termcaps[0]); termp->bt_string != NULL; ++termp) { if (termp->bt_entry == KS_NAME) #ifdef HAVE_TGETENT fprintf(stderr, " builtin_%s\r\n", termp->bt_string); #else fprintf(stderr, " %s\r\n", termp->bt_string); #endif } if (!starting) /* when user typed :set term=xxx, quit here */ { screen_start(); /* don't know where cursor is now */ wait_return(TRUE); return FAIL; } term = DEFAULT_TERM; fprintf(stderr, "defaulting to '%s'\r\n", term); screen_start(); /* don't know where cursor is now */ ui_delay(2000L, TRUE); set_string_option((char_u *)"term", -1, term, TRUE); } flushbuf(); #ifdef HAVE_TGETENT if (!termcap_cleared) { #endif clear_termoptions(); /* clear old options */ #ifdef HAVE_TGETENT termcap_cleared = TRUE; } #endif parse_builtin_tcap(term); #ifdef USE_GUI if (STRCMP(term, "gui") == 0) { flushbuf(); gui_init(); #ifdef HAVE_TGETENT break; /* don't try using external termcap */ #endif } #endif /* USE_GUI */ } #ifdef HAVE_TGETENT } #endif /* * special: There is no info in the termcap about whether the cursor * positioning is relative to the start of the screen or to the start of the * scrolling region. We just guess here. Only msdos pcterm is known to do it * relative. */ if (STRCMP(term, "pcterm") == 0) T_CCS = (char_u *)"yes"; else T_CCS = empty_option; #ifdef UNIX /* * Any "stty" settings override the default for t_kb from the termcap. * This is in os_unix.c, because it depends a lot on the version of unix that * is being used. * Don't do this when the GUI is active, it uses "t_kb" and "t_kD" directly. */ #ifdef USE_GUI if (!gui.in_use) #endif get_stty(); #endif /* * If the termcap has no entry for 'bs' and/or 'del' and the ioctl() also * didn't work, use the default CTRL-H * The default for t_kD is DEL, unless t_kb is DEL. * The vim_strsave'd strings are probably lost forever, well it's only two * bytes. Don't do this when the GUI is active, it uses "t_kb" and "t_kD" * directly. */ #ifdef USE_GUI if (!gui.in_use) #endif { bs_p = find_termcode((char_u *)"kb"); del_p = find_termcode((char_u *)"kD"); if (bs_p == NULL || *bs_p == NUL) add_termcode((char_u *)"kb", (bs_p = (char_u *)"\010")); if ((del_p == NULL || *del_p == NUL) && (bs_p == NULL || *bs_p != '\177')) add_termcode((char_u *)"kD", (char_u *)"\177"); } #ifdef USE_MOUSE /* * Recognize mouse events in the input stream for xterm, msdos and win32. * Also for Netterm and Dec mouse, when defined at compile time. */ { char_u name[2]; name[0] = KS_MOUSE; name[1] = K_FILLER; # ifdef UNIX # ifdef XTERM_MOUSE if (is_xterm(term)) add_termcode(name, (char_u *)"\033[M"); # endif # ifdef NETTERM_MOUSE name[0] = KS_NETTERM_MOUSE; /* balancing { */ add_termcode(name, (char_u *)"\033}"); # endif /* NETTERM_MOUSE */ # ifdef DEC_MOUSE name[0] = KS_DEC_MOUSE; add_termcode(name, (char_u *)"\033["); # endif /* NETTERM_MOUSE */ # else /* UNIX */ add_termcode(name, (char_u *)"\233M"); # endif /* UNIX */ } #endif /* USE_MOUSE */ #if defined(AMIGA) || defined(MSDOS) || defined(WIN32) || defined(OS2) || defined(BEBOX) /* DEFAULT_TERM indicates that it is the machine console. */ if (STRCMP(term, DEFAULT_TERM)) term_console = FALSE; else { term_console = TRUE; # ifdef AMIGA win_resize_on(); /* enable window resizing reports */ # endif } #endif #ifdef UNIX /* * 'ttyfast' is default on for xterm, iris-ansi and a few others. */ if (is_fastterm(term)) p_tf = TRUE; #endif #if defined(AMIGA) || defined(MSDOS) || defined(WIN32) || defined(OS2) || defined(BEBOX) /* * 'ttyfast' is default on Amiga, MSDOS, Win32, BeBox and OS/2 consoles */ if (term_console) p_tf = TRUE; #endif ttest(TRUE); /* make sure we have a valid set of terminal codes */ set_term_defaults(); /* use current values as defaults */ /* * Initialize the terminal with the appropriate termcap codes. * Set the mouse and window title if possible. * Don't do this when starting, need to parse the .vimrc first, because it * may redefine t_TI etc. */ if (!starting) { starttermcap(); /* may change terminal mode */ #ifdef USE_MOUSE setmouse(); /* may start using the mouse */ #endif maketitle(); /* may display window title */ } /* display initial screen after ttest() checking. jw. */ if (width <= 0 || height <= 0) { /* termcap failed to report size */ /* set defaults, in case ui_get_winsize also fails */ width = 80; #if defined MSDOS || defined WIN32 height = 25; /* console is often 25 lines */ #else height = 24; /* most terminals are 24 lines */ #endif } set_winsize(width, height, FALSE); /* may change Rows */ if (!starting) { if (scroll_region) scroll_region_reset(); /* In case Rows changed */ check_map_keycodes(); /* check mappings for terminal codes used */ #ifdef AUTOCMD { BUF *old_curbuf; /* * Execute the TermChanged autocommands for each buffer that is * loaded. */ old_curbuf = curbuf; for (curbuf = firstbuf; curbuf != NULL; curbuf = curbuf->b_next) { if (curbuf->b_ml.ml_mfp != NULL) apply_autocmds(EVENT_TERMCHANGED, NULL, NULL, FALSE); } if (buf_valid(old_curbuf)) curbuf = old_curbuf; } #endif } return OK; } #ifdef HAVE_TGETENT /* * Call tgetent() * Return error message if it fails, NULL if it's OK. */ static char_u * tgetent_error(tbuf, term) char_u *tbuf; char_u *term; { int i; i = TGETENT(tbuf, term); if (i == -1) return (char_u *)"Cannot open termcap file"; if (i == 0) #ifdef TERMINFO return (char_u *)"Terminal entry not found in terminfo"; #else return (char_u *)"Terminal entry not found in termcap"; #endif return NULL; } #endif /* HAVE_TGETENT */ #if defined(HAVE_TGETENT) && (defined(UNIX) || defined(__EMX__)) /* * Get Columns and Rows from the termcap. Used after a window signal if the * ioctl() fails. It doesn't make sense to call tgetent each time if the "co" * and "li" entries never change. But on some systems this works. * Errors while getting the entries are ignored. */ void getlinecol() { char_u tbuf[TBUFSZ]; if (term_strings[KS_NAME] != NULL && *term_strings[KS_NAME] != NUL && TGETENT(tbuf, term_strings[KS_NAME]) > 0) { if (Columns == 0) Columns = tgetnum("co"); if (Rows == 0) Rows = tgetnum("li"); } } #endif /* defined(HAVE_TGETENT) && defined(UNIX) */ /* * Get a string entry from the termcap and add it to the list of termcodes. * Used for special keys. * Give an error message for failure when not sourcing. * If force given, replace an existing entry. * Return FAIL if the entry was not found, OK if the entry was added. */ int add_termcap_entry(name, force) char_u *name; int force; { char_u *term; int key; struct builtin_term *termp; #ifdef HAVE_TGETENT char_u *string; int i; int builtin_first; char_u tbuf[TBUFSZ]; char_u tstrbuf[TBUFSZ]; char_u *tp = tstrbuf; char_u *error_msg = NULL; #endif /* * If the GUI is running or will start in a moment, we only support the keys * that the GUI can produce. */ #ifdef USE_GUI if (gui.in_use || gui.starting) return gui_mch_haskey(name); #endif if (!force && find_termcode(name) != NULL) /* it's already there */ return OK; term = term_strings[KS_NAME]; if (term == NULL || *term == NUL) /* 'term' not defined yet */ return FAIL; if (is_builtin_term(term)) /* name starts with "builtin_" */ { term += 8; #ifdef HAVE_TGETENT builtin_first = TRUE; #endif } #ifdef HAVE_TGETENT else builtin_first = p_tbi; #endif #ifdef HAVE_TGETENT /* * We can get the entry from the builtin termcap and from the external one. * If 'ttybuiltin' is on or the terminal name starts with "builtin_", try * builtin termcap first. * If 'ttybuiltin' is off, try external termcap first. */ for (i = 0; i < 2; ++i) { if (!builtin_first == i) #endif /* * Search in builtin termcap */ { termp = find_builtin_term(term); if (termp->bt_string != NULL) /* found it */ { key = TERMCAP2KEY(name[0], name[1]); while (termp->bt_entry != KS_NAME) { if ((int)termp->bt_entry == key) { add_termcode(name, (char_u *)termp->bt_string); return OK; } ++termp; } } } #ifdef HAVE_TGETENT else /* * Search in external termcap */ { error_msg = tgetent_error(tbuf, term); if (error_msg == NULL) { string = TGETSTR((char *)name, &tp); if (string != NULL && *string != NUL) { add_termcode(name, string); return OK; } } } } #endif if (sourcing_name == NULL) { #ifdef HAVE_TGETENT if (error_msg != NULL) EMSG(error_msg); else #endif EMSG2("No \"%s\" entry in termcap", name); } return FAIL; } static int is_builtin_term(name) char_u *name; { return (STRNCMP(name, "builtin_", (size_t)8) == 0); } static char_u *tltoa __PARMS((unsigned long)); static char_u * tltoa(i) unsigned long i; { static char_u buf[16]; char_u *p; p = buf + 15; *p = '\0'; do { --p; *p = (char_u) (i % 10 + '0'); i /= 10; } while (i > 0 && p > buf); return p; } #ifndef HAVE_TGETENT /* * minimal tgoto() implementation. * no padding and we only parse for %i %d and %+char */ char *tgoto __ARGS((char *, int, int)); char * tgoto(cm, x, y) char *cm; int x, y; { static char buf[30]; char *p, *s, *e; if (!cm) return "OOPS"; e = buf + 29; for (s = buf; s < e && *cm; cm++) { if (*cm != '%') { *s++ = *cm; continue; } switch (*++cm) { case 'd': p = (char *)tltoa((unsigned long)y); y = x; while (*p) *s++ = *p++; break; case 'i': x++; y++; break; case '+': *s++ = (char)(*++cm + y); y = x; break; case '%': *s++ = *cm; break; default: return "OOPS"; } } *s = '\0'; return buf; } #endif /* HAVE_TGETENT */ /* * Set the terminal name to "term" and initialize the terminal options. * If "term" is NULL or empty, get the terminal name from the environment. * If that fails, use the default terminal name. */ void termcapinit(term) char_u *term; { #ifdef BEBOX /* * TERM environment variable is normally set to 'ansi' on the Bebox; * Since the BeBox doesn't quite support full ANSI yet, we use our * own custom 'ansi-bebox' termcap instead, unless the -T option has * been given on the command line. */ if (term == NULL && strcmp((char *)vim_getenv((char_u *)"TERM"), "ansi") == 0) term = DEFAULT_TERM; #endif #ifndef WIN32 if (term == NULL || *term == NUL) term = vim_getenv((char_u *)"TERM"); #endif if (term == NULL || *term == NUL) term = DEFAULT_TERM; set_string_option((char_u *)"term", -1, term, TRUE); /* * Avoid using "term" here, because the next vim_getenv() may overwrite it. */ set_termname(term_strings[KS_NAME] != NULL ? term_strings[KS_NAME] : term); } /* * the number of calls to ui_write is reduced by using the buffer "outbuf" */ #undef BSIZE /* hpux has BSIZE in sys/option.h */ #define BSIZE 2048 static char_u outbuf[BSIZE]; static int bpos = 0; /* number of chars in outbuf */ /* * flushbuf(): flush the output buffer */ void flushbuf() { if (bpos != 0) { ui_write(outbuf, bpos); bpos = 0; } } #ifdef USE_GUI /* * trash_output_buf(): Throw away the contents of the output buffer */ void trash_output_buf() { bpos = 0; } #endif /* * outchar(c): put a character into the output buffer. * Flush it if it becomes full. * This should not be used for outputting text on the screen (use functions * like msg_puts() and screen_putchar() for that). */ void outchar(c) unsigned c; { #if defined(UNIX) || defined(VMS) || defined(AMIGA) if (c == '\n') /* turn LF into CR-LF (CRMOD doesn't seem to do this) */ outchar('\r'); #endif outbuf[bpos++] = c; /* For testing we flush each time. */ if (bpos >= BSIZE || p_wd) flushbuf(); } static void outchar_nf __ARGS((unsigned)); /* * outchar_nf(c): like outchar(), but don't flush when p_wd is set */ static void outchar_nf(c) unsigned c; { #if defined(UNIX) || defined(VMS) || defined(AMIGA) if (c == '\n') /* turn LF into CR-LF (CRMOD doesn't seem to do this) */ outchar_nf('\r'); #endif outbuf[bpos++] = c; /* For testing we flush each time. */ if (bpos >= BSIZE) flushbuf(); } /* * a never-padding outstr. * use this whenever you don't want to run the string through tputs. * tputs above is harmless, but tputs from the termcap library * is likely to strip off leading digits, that it mistakes for padding * information. (jw) * This should only be used for writing terminal codes, not for outputting * normal text (use functions like msg_puts() and screen_putchar() for that). */ void outstrn(s) char_u *s; { if (bpos > BSIZE - 20) /* avoid terminal strings being split up */ flushbuf(); while (*s) outchar_nf(*s++); /* For testing we write one string at a time. */ if (p_wd) flushbuf(); } /* * outstr(s): Put a string character at a time into the output buffer. * If HAVE_TGETENT is defined use the termcap parser. (jw) * This should only be used for writing terminal codes, not for outputting * normal text (use functions like msg_puts() and screen_putchar() for that). */ void outstr(s) char_u *s; { if (bpos > BSIZE - 20) /* avoid terminal strings being split up */ flushbuf(); if (s != NULL) #ifdef HAVE_TGETENT tputs((char *)s, 1, TPUTSFUNCAST outchar_nf); #else while (*s) outchar_nf(*s++); #endif /* For testing we write one string at a time. */ if (p_wd) flushbuf(); } /* * cursor positioning using termcap parser. (jw) */ void term_windgoto(row, col) int row; int col; { OUTSTR(tgoto((char *)T_CM, col, row)); } void term_cursor_right(i) int i; { OUTSTR(tgoto((char *)T_CRI, 0, i)); } void term_append_lines(line_count) int line_count; { OUTSTR(tgoto((char *)T_CAL, 0, line_count)); } void term_delete_lines(line_count) int line_count; { OUTSTR(tgoto((char *)T_CDL, 0, line_count)); } void term_fg_color(n) int n; { /* Use "AF" termcap entry if present, "Sf" entry otherwise */ if (*T_CAF) OUTSTR(tgoto((char *)T_CAF, 0, n)); else if (*T_CSF) OUTSTR(tgoto((char *)T_CSF, 0, n)); } void term_bg_color(n) int n; { /* Use "AB" termcap entry if present, "Sb" entry otherwise */ if (*T_CAB) OUTSTR(tgoto((char *)T_CAB, 0, n)); else if (*T_CSB) OUTSTR(tgoto((char *)T_CSB, 0, n)); } /* * Make sure we have a valid set or terminal options. * Replace all entries that are NULL by empty_option */ void ttest(pairs) int pairs; { char *t = NULL; check_options(); /* make sure no options are NULL */ /* hard requirements */ if (*T_CL == NUL) /* erase display */ t = "cl"; if (*T_CM == NUL) /* cursor motion */ t = "cm"; if (t != NULL) EMSG2("terminal capability %s required", t); /* * if "cs" defined, use a scroll region, it's faster. */ if (*T_CS != NUL) scroll_region = TRUE; else scroll_region = FALSE; if (pairs) { /* * optional pairs */ /* TP goes to normal mode for TI (invert) and TB (bold) */ if (*T_ME == NUL) T_ME = T_MR = T_MD = T_MB = empty_option; if (*T_SO == NUL || *T_SE == NUL) T_SO = T_SE = empty_option; if (*T_US == NUL || *T_UE == NUL) T_US = T_UE = empty_option; if (*T_CZH == NUL || *T_CZR == NUL) T_CZH = T_CZR = empty_option; /* T_VE is needed even though T_VI is not defined */ if (*T_VE == NUL) T_VI = empty_option; /* if 'mr' or 'me' is not defined use 'so' and 'se' */ if (*T_ME == NUL) { T_ME = T_SE; T_MR = T_SO; T_MD = T_SO; } /* if 'so' or 'se' is not defined use 'mr' and 'me' */ if (*T_SO == NUL) { T_SE = T_ME; if (*T_MR == NUL) T_SO = T_MD; else T_SO = T_MR; } /* if 'ZH' or 'ZR' is not defined use 'mr' and 'me' */ if (*T_CZH == NUL) { T_CZR = T_ME; if (*T_MR == NUL) T_CZH = T_MD; else T_CZH = T_MR; } /* "Sb" and "Sf" come in pairs */ if (*T_CSB == NUL || *T_CSF == NUL) { T_CSB = empty_option; T_CSF = empty_option; } /* "AB" and "AF" come in pairs */ if (*T_CAB == NUL || *T_CAF == NUL) { T_CAB = empty_option; T_CAF = empty_option; } /* if 'Sb' and 'AB' are not defined, reset "Co" */ if (*T_CSB == NUL && *T_CAB == NUL) T_CCO = empty_option; /* Set 'weirdinvert' according to value of 't_xs' */ p_wiv = (*T_XS != NUL); } need_gather = TRUE; } /* * Represent the given long_u as individual bytes, with the most significant * byte first, and store them in dst. */ void add_long_to_buf(val, dst) long_u val; char_u *dst; { int i; int shift; for (i = 1; i <= sizeof(long_u); i++) { shift = 8 * (sizeof(long_u) - i); dst[i - 1] = (char_u) ((val >> shift) & 0xff); } } /* * Interpret the next string of bytes in buf as a long integer, with the most * significant byte first. Note that it is assumed that buf has been through * inchar(), so that NUL and K_SPECIAL will be represented as three bytes each. * Puts result in val, and returns the number of bytes read from buf * (between sizeof(long_u) and 2 * sizeof(long_u)), or -1 if not enough bytes * were present. */ int get_long_from_buf(buf, val) char_u *buf; long_u *val; { int len; char_u bytes[sizeof(long_u)]; int i; int shift; *val = 0; len = get_bytes_from_buf(buf, bytes, (int)sizeof(long_u)); if (len != -1) { for (i = 0; i < sizeof(long_u); i++) { shift = 8 * (sizeof(long_u) - 1 - i); *val += (long_u)bytes[i] << shift; } } return len; } /* * Read the next num_bytes bytes from buf, and store them in bytes. Assume * that buf has been through inchar(). Returns the actual number of bytes used * from buf (between num_bytes and num_bytes*2), or -1 if not enough bytes were * available. */ static int get_bytes_from_buf(buf, bytes, num_bytes) char_u *buf; char_u *bytes; int num_bytes; { int len = 0; int i; char_u c; for (i = 0; i < num_bytes; i++) { if ((c = buf[len++]) == NUL) return -1; if (c == K_SPECIAL) { if (buf[len] == NUL || buf[len + 1] == NUL) /* cannot happen? */ return -1; if (buf[len++] == KS_ZERO) c = NUL; ++len; /* skip K_FILLER */ /* else it should be KS_SPECIAL, and c already equals K_SPECIAL */ } bytes[i] = c; } return len; } /* * outnum - output a (big) number fast */ void outnum(n) long n; { OUTSTRN(tltoa((unsigned long)n)); } void check_winsize() { static int old_Rows = 0; if (Columns < MIN_COLUMNS) Columns = MIN_COLUMNS; if (Rows < min_rows()) /* need room for one window and command line */ Rows = min_rows(); if (old_Rows != Rows) { old_Rows = Rows; screen_new_rows(); /* may need to update window sizes */ } } /* * set window size * If 'mustset' is TRUE, we must set Rows and Columns, do not get real * window size (this is used for the :win command). * If 'mustset' is FALSE, we may try to get the real window size and if * it fails use 'width' and 'height'. */ void set_winsize(width, height, mustset) int width, height; int mustset; { static int busy = FALSE; /* * Avoid recursiveness, can happen when setting the window size causes * another window-changed signal. */ if (busy) return; if (width < 0 || height < 0) /* just checking... */ return; if (State == HITRETURN || State == SETWSIZE) /* postpone the resizing */ { State = SETWSIZE; return; } ++busy; if (State != ASKMORE && State != EXTERNCMD) screenclear(); else screen_start(); /* don't know where cursor is now */ #ifdef AMIGA flushbuf(); /* must do this before mch_get_winsize() for some obscure reason */ #endif /* AMIGA */ if (mustset || (ui_get_winsize() == FAIL && height != 0)) { Rows = height; Columns = width; check_winsize(); /* always check, to get p_scroll right */ ui_set_winsize(); } else check_winsize(); /* always check, to get p_scroll right */ if (!starting) { maketitle(); /* * We only redraw when it's needed: * - While at the more prompt or executing an external command, don't * redraw, but position the cursor. * - While editing the command line, only redraw that. * - in Ex mode, don't redraw anything. * - Otherwise, redraw right now, and position the cursor. * Always need to call update_screen() or screenalloc(), to make * sure Rows/Columns and the size of NextScreen is correct! */ if (State == ASKMORE || State == EXTERNCMD) { screenalloc(FALSE); if (State == ASKMORE) { msg_moremsg(FALSE); /* display --more-- message again */ msg_row = Rows - 1; } else windgoto(msg_row, msg_col); /* put cursor back */ } else if (State == CMDLINE) { update_screen(NOT_VALID); redrawcmdline(); } else if (exmode_active) { screenalloc(FALSE); } else { update_topline(); update_screen(NOT_VALID); if (redrawing()) setcursor(); } } flushbuf(); --busy; } /* * Set the terminal to TMODE_RAW (for Normal mode) or TMODE_COOK (for external * commands and Ex mode). */ void settmode(tmode) int tmode; { static int oldtmode = TMODE_COOK; #ifdef USE_GUI /* don't set the term where gvim was started to any mode */ if (gui.in_use) return; #endif if (full_screen) { /* * When returning after calling a shell we want to really set the * terminal to raw mode, even though we think it already is, because * the shell program may have reset the terminal mode. * When we think the terminal is normal, don't try to set it to * normal again, because that causes problems (logout!) on some * machines. */ if (tmode != TMODE_COOK || oldtmode != TMODE_COOK) { flushbuf(); mch_settmode(tmode); /* machine specific function */ #ifdef USE_MOUSE if (tmode != TMODE_RAW) mch_setmouse(FALSE); /* switch mouse off */ else setmouse(); /* may switch mouse on */ #endif flushbuf(); oldtmode = tmode; } } } void starttermcap() { screen_stop_highlight(); if (full_screen && !termcap_active) { outstr(T_TI); /* start termcap mode */ outstr(T_KS); /* start "keypad transmit" mode */ flushbuf(); termcap_active = TRUE; screen_start(); /* don't know where cursor is now */ } } void stoptermcap() { screen_stop_highlight(); if (termcap_active) { outstr(T_KE); /* stop "keypad transmit" mode */ flushbuf(); termcap_active = FALSE; cursor_on(); /* just in case it is still off */ outstr(T_TE); /* stop termcap mode */ screen_start(); /* don't know where cursor is now */ } } #ifdef USE_MOUSE /* * setmouse() - switch mouse on/off depending on current mode and 'mouse' */ void setmouse() { int checkfor; # ifdef USE_GUI if (gui.in_use) return; # endif if (*p_mouse == NUL) /* be quick when mouse is off */ return; if (VIsual_active) checkfor = MOUSE_VISUAL; else if (State == HITRETURN) checkfor = MOUSE_RETURN; else if (State & INSERT) checkfor = MOUSE_INSERT; else if (State & CMDLINE) checkfor = MOUSE_COMMAND; else checkfor = MOUSE_NORMAL; /* assume normal mode */ if (mouse_has(checkfor)) mch_setmouse(TRUE); else mch_setmouse(FALSE); } /* * Return TRUE if * - "c" is in 'mouse', or * - 'a' is in 'mouse' and "c" is in MOUSE_A, or * - the current buffer is a help file and 'h' is in 'mouse' and we are in a * normal editing mode (not at hit-return message). */ int mouse_has(c) int c; { return (vim_strchr(p_mouse, c) != NULL || (vim_strchr(p_mouse, 'a') != NULL && vim_strchr((char_u *)MOUSE_A, c) != NULL) || (c != MOUSE_RETURN && curbuf->b_help && vim_strchr(p_mouse, MOUSE_HELP))); } #endif /* * By outputting the 'cursor very visible' termcap code, for some windowed * terminals this makes the screen scrolled to the correct position. * Used when starting Vim or returning from a shell. */ void scroll_start() { if (*T_VS != NUL) { outstr(T_VS); outstr(T_VE); screen_start(); /* don't know where cursor is now */ } } /* * enable cursor, unless in Visual mode. */ static int cursor_is_off = FALSE; void cursor_on() { if (cursor_is_off && !VIsual_active) { outstr(T_VE); cursor_is_off = FALSE; } } void cursor_off() { if (full_screen) { if (!cursor_is_off) outstr(T_VI); /* disable cursor */ cursor_is_off = TRUE; } } /* * Set scrolling region for window 'wp'. * The region starts 'off' lines from the start of the window. */ void scroll_region_set(wp, off) WIN *wp; int off; { OUTSTR(tgoto((char *)T_CS, wp->w_winpos + wp->w_height - 1, wp->w_winpos + off)); screen_start(); /* don't know where cursor is now */ } /* * Reset scrolling region to the whole screen. */ void scroll_region_reset() { OUTSTR(tgoto((char *)T_CS, (int)Rows - 1, 0)); screen_start(); /* don't know where cursor is now */ } /* * List of terminal codes that are currently recognized. */ struct termcode { char_u name[2]; /* termcap name of entry */ char_u *code; /* terminal code (in allocated memory) */ int len; /* STRLEN(code) */ } *termcodes = NULL; static int tc_max_len = 0; /* number of entries that termcodes[] can hold */ static int tc_len = 0; /* current number of entries in termcodes[] */ void clear_termcodes() { while (tc_len > 0) vim_free(termcodes[--tc_len].code); vim_free(termcodes); termcodes = NULL; tc_max_len = 0; #ifdef HAVE_TGETENT BC = (char *)empty_option; UP = (char *)empty_option; PC = NUL; /* set pad character to NUL */ ospeed = 0; #endif need_gather = TRUE; /* need to fill termleader[] */ } /* * Add a new entry to the list of terminal codes. * The list is kept alphabetical for ":set termcap" */ void add_termcode(name, string) char_u *name; char_u *string; { struct termcode *new_tc; int i, j; char_u *s; if (string == NULL || *string == NUL) { del_termcode(name); return; } s = vim_strsave(string); if (s == NULL) return; need_gather = TRUE; /* need to fill termleader[] */ /* * need to make space for more entries */ if (tc_len == tc_max_len) { tc_max_len += 20; new_tc = (struct termcode *)alloc( (unsigned)(tc_max_len * sizeof(struct termcode))); if (new_tc == NULL) { tc_max_len -= 20; return; } for (i = 0; i < tc_len; ++i) new_tc[i] = termcodes[i]; vim_free(termcodes); termcodes = new_tc; } /* * Look for existing entry with the same name, it is replaced. * Look for an existing entry that is alphabetical higher, the new entry * is inserted in front of it. */ for (i = 0; i < tc_len; ++i) { if (termcodes[i].name[0] < name[0]) continue; if (termcodes[i].name[0] == name[0]) { if (termcodes[i].name[1] < name[1]) continue; /* * Exact match: Replace old code. */ if (termcodes[i].name[1] == name[1]) { vim_free(termcodes[i].code); --tc_len; break; } } /* * Found alphabetical larger entry, move rest to insert new entry */ for (j = tc_len; j > i; --j) termcodes[j] = termcodes[j - 1]; break; } termcodes[i].name[0] = name[0]; termcodes[i].name[1] = name[1]; termcodes[i].code = s; termcodes[i].len = STRLEN(s); ++tc_len; } char_u * find_termcode(name) char_u *name; { int i; for (i = 0; i < tc_len; ++i) if (termcodes[i].name[0] == name[0] && termcodes[i].name[1] == name[1]) return termcodes[i].code; return NULL; } char_u * get_termcode(i) int i; { if (i >= tc_len) return NULL; return &termcodes[i].name[0]; } void del_termcode(name) char_u *name; { int i; if (termcodes == NULL) /* nothing there yet */ return; need_gather = TRUE; /* need to fill termleader[] */ for (i = 0; i < tc_len; ++i) if (termcodes[i].name[0] == name[0] && termcodes[i].name[1] == name[1]) { vim_free(termcodes[i].code); --tc_len; while (i < tc_len) { termcodes[i] = termcodes[i + 1]; ++i; } return; } /* not found. Give error message? */ } /* * Check if typebuf[] contains a terminal key code. * Check from typebuf[typeoff] to typebuf[typeoff + max_offset]. * Return 0 for no match, -1 for partial match, > 0 for full match. * With a match, the match is removed, the replacement code is inserted in * typebuf[] and the number of characters in typebuf[] is returned. */ int check_termcode(max_offset) int max_offset; { char_u *tp; char_u *p; int slen = 0; /* init for GCC */ int len; int offset; char_u key_name[2]; int new_slen; int extra; char_u string[MAX_KEY_CODE_LEN + 1]; int i, j; #ifdef USE_GUI long_u val; #endif #ifdef USE_MOUSE char_u bytes[3]; int num_bytes; int mouse_code = 0; /* init for GCC */ int modifiers; int is_click, is_drag; int current_button; static int held_button = MOUSE_RELEASE; static int orig_num_clicks = 1; static int orig_mouse_code = 0x0; # if defined(UNIX) && defined(HAVE_GETTIMEOFDAY) && defined(HAVE_SYS_TIME_H) static int orig_mouse_col = 0; static int orig_mouse_row = 0; static linenr_t orig_topline = 0; static struct timeval orig_mouse_time = {0, 0}; /* time of previous mouse click */ struct timeval mouse_time; /* time of current mouse click */ long timediff; /* elapsed time in msec */ # endif #endif /* * Speed up the checks for terminal codes by gathering all first bytes * used in termleader[]. Often this is just a single . */ if (need_gather) gather_termleader(); /* * Check at several positions in typebuf[], to catch something like * "x" that can be mapped. Stop at max_offset, because characters * after that cannot be used for mapping, and with @r commands typebuf[] * can become very long. * This is used often, KEEP IT FAST! */ for (offset = 0; offset < typelen && offset < max_offset; ++offset) { tp = typebuf + typeoff + offset; /* * Don't check characters after K_SPECIAL, those are already * translated terminal chars (avoid translating ~@^Hx). */ if (*tp == K_SPECIAL) { offset += 2; /* there are always 2 extra characters */ continue; } /* * Skip this position if the character does not appear as the first * character in term_strings. This speeds up a lot, since most * termcodes start with the same character (ESC or CSI). */ i = *tp; for (p = termleader; *p && *p != i; ++p) ; if (*p == NUL) continue; /* * Skip this position if p_ek is not set and * typebuf[typeoff + offset] is an ESC and we are in insert mode */ if (*tp == ESC && !p_ek && (State & INSERT)) continue; len = typelen - offset; /* length of the input */ new_slen = 0; /* Length of what will replace the termcode */ key_name[0] = NUL; /* no key name found yet */ #ifdef USE_GUI if (gui.in_use) { /* * GUI special key codes are all of the form [CSI xx]. */ if (*tp == CSI) /* Special key from GUI */ { if (len < 3) return -1; /* Shouldn't happen */ slen = 3; key_name[0] = tp[1]; key_name[1] = tp[2]; } } else #endif /* USE_GUI */ { for (i = 0; i < tc_len; ++i) { /* * Ignore the entry if we are not at the start of typebuf[] * and there are not enough characters to make a match. */ slen = termcodes[i].len; if (offset && len < slen) continue; if (STRNCMP(termcodes[i].code, tp, (size_t)(slen > len ? len : slen)) == 0) { if (len < slen) /* got a partial sequence */ return -1; /* need to get more chars */ /* * When found a keypad key, check if there is another key * that matches and use that one. This makes to be * found instead of when they produce the same * key code. */ if (termcodes[i].name[0] == 'K' && isdigit(termcodes[i].name[1])) { for (j = i + 1; j < tc_len; ++j) if (termcodes[j].len == slen && STRNCMP(termcodes[i].code, termcodes[j].code, slen) == 0) { i = j; break; } } key_name[0] = termcodes[i].name[0]; key_name[1] = termcodes[i].name[1]; #ifdef OLD_KEYSTUFF /* * If it's a shifted special key, then include the SHIFT * modifier */ if (unshift_special_key(&key_name[0])) { string[new_slen++] = K_SPECIAL; string[new_slen++] = KS_MODIFIER; string[new_slen++] = MOD_MASK_SHIFT; } #endif break; } } } if (key_name[0] == NUL) continue; /* No match at this position, try next one */ /* We only get here when we have a complete termcode match */ #ifdef USE_MOUSE /* * If it is a mouse click, get the coordinates. */ if (key_name[0] == KS_MOUSE # ifdef NETTERM_MOUSE || key_name[0] == KS_NETTERM_MOUSE # endif # ifdef DEC_MOUSE || key_name[0] == KS_DEC_MOUSE # endif ) { is_click = is_drag = FALSE; #if !defined(UNIX) || defined(XTERM_MOUSE) if (key_name[0] == KS_MOUSE) { /* * For xterm and MSDOS we get "scr", where * s == encoded button state (0x20 = left, 0x22 = right, etc.) * c == column + ' ' + 1 == column + 33 * r == row + ' ' + 1 == row + 33 * * The coordinates are passed on through global variables. Ugly, * but this avoids trouble with mouse clicks at an unexpected * moment and allows for mapping them. */ num_bytes = get_bytes_from_buf(tp + slen, bytes, 3); if (num_bytes == -1) /* not enough coordinates */ return -1; mouse_code = bytes[0]; mouse_col = bytes[1] - ' ' - 1; mouse_row = bytes[2] - ' ' - 1; slen += num_bytes; } #endif /* !UNIX || XTERM_MOUSE */ #ifdef NETTERM_MOUSE if (key_name[0] == KS_NETTERM_MOUSE) { int mc, mr; /* expect a rather limited sequence like: balancing { * \033}6,45\r * '6' is the row, 45 is the column */ p = tp + slen; mr = getdigits(&p); if (*p++ != ',') return -1; mc = getdigits(&p); if (*p++ != '\r') return -1; mouse_col = mc - 1; mouse_row = mr - 1; mouse_code = MOUSE_LEFT; slen += (p - (tp + slen)); } #endif /* NETTERM_MOUSE */ #ifdef DEC_MOUSE if (key_name[0] == KS_DEC_MOUSE) { /* The DEC Locator Input Model * Netterm delivers the code sequence: * \033[2;4;24;80&w (left button down) * \033[3;0;24;80&w (left button up) * \033[6;1;24;80&w (right button down) * \033[7;0;24;80&w (right button up) * CSI Pe ; Pb ; Pr ; Pc ; Pp & w * Pe is the event code * Pb is the button code * Pr is the row coordinate * Pc is the column coordinate * Pp is the third coordinate (page number) * Pe, the event code indicates what event caused this report * The following event codes are defined: * 0 - request, the terminal received an explicit request * for a locator report, but the locator is unavailable * 1 - request, the terminal received an explicit request * for a locator report * 2 - left button down * 3 - left button up * 4 - middle button down * 5 - middle button up * 6 - right button down * 7 - right button up * 8 - fourth button down * 9 - fourth button up * 10 - locator outside filter rectangle * Pb, the button code, ASCII decimal 0-15 indicating which * buttons are down if any. The state of the four buttons * on the locator correspond to the low four bits of the * decimal value, * "1" means button depressed * 0 - no buttons down, * 1 - right, * 2 - middle, * 4 - left, * 8 - fourth * Pr is the row coordinate of the locator position in the page, * encoded as an ASCII decimal value. * If Pr is omitted, the locator position is undefined * (outside the terminal window for example). * Pc is the column coordinate of the locator position in the * page, encoded as an ASCII decimal value. * If Pc is omitted, the locator position is undefined * (outside the terminal window for example). * Pp is the page coordinate of the locator position * encoded as an ASCII decimal value. * The page coordinate may be omitted if the locator is on * page one (the default). */ int Pe, Pb, Pr, Pc, Pp; p = tp + slen; /* get event status */ Pe = getdigits(&p); if (*p++ != ';') return -1; /* get button status */ Pb = getdigits(&p); if (*p++ != ';') return -1; /* get row status */ Pr = getdigits(&p); if (*p++ != ';') return -1; /* get column status */ Pc = getdigits(&p); /* the page parameter is optional */ if (*p == ';') { p++; Pp = getdigits(&p); } else Pp = 0; if (*p++ != '&') return -1; if (*p++ != 'w') return -1; mouse_code = 0; switch (Pe) { case 0: return -1; /* position request while unavailable */ case 1: /* a response to a locator position request includes the status of all buttons */ Pb &= 7; /* mask off and ignore fourth button */ if (Pb & 4) mouse_code = MOUSE_LEFT; if (Pb & 2) mouse_code = MOUSE_MIDDLE; if (Pb & 1) mouse_code = MOUSE_RIGHT; if (Pb) { held_button = mouse_code; mouse_code |= MOUSE_DRAG; WantQueryMouse = 1; } is_drag = TRUE; showmode(); break; case 2: mouse_code = MOUSE_LEFT; WantQueryMouse = 1; break; case 3: mouse_code = MOUSE_RELEASE | MOUSE_LEFT; break; case 4: mouse_code = MOUSE_MIDDLE; WantQueryMouse = 1; break; case 5: mouse_code = MOUSE_RELEASE | MOUSE_MIDDLE; break; case 6: mouse_code = MOUSE_RIGHT; WantQueryMouse = 1; break; case 7: mouse_code = MOUSE_RELEASE | MOUSE_RIGHT; break; case 8: return -1; /* fourth button down */ case 9: return -1; /* fourth button up */ case 10: return -1; /* mouse outside of filter rectangle */ default: return -1; /* should never occur */ } /* we ignore the Pp word */ mouse_col = Pc - 1; mouse_row = Pr - 1; slen += (p - (tp + slen)); } #endif /* DEC_MOUSE */ /* Interpret the mouse code */ current_button = (mouse_code & MOUSE_CLICK_MASK); if (current_button == MOUSE_RELEASE) { /* * If we get a mouse drag or release event when * there is no mouse button held down (held_button == * MOUSE_RELEASE), produce a K_IGNORE below. * (can happen when you hold down two buttons * and then let them go, or click in the menu bar, but not * on a menu, and drag into the text). */ if ((mouse_code & MOUSE_DRAG) == MOUSE_DRAG) is_drag = TRUE; current_button = held_button; } else { #if defined(UNIX) && defined(HAVE_GETTIMEOFDAY) && defined(HAVE_SYS_TIME_H) # ifdef USE_GUI /* * Only for Unix, when GUI is not active, we handle * multi-clicks here. */ if (!gui.in_use) # endif { /* * Compute the time elapsed since the previous mouse click. */ gettimeofday(&mouse_time, NULL); timediff = (mouse_time.tv_usec - orig_mouse_time.tv_usec) / 1000; if (timediff < 0) --orig_mouse_time.tv_sec; timediff += (mouse_time.tv_sec - orig_mouse_time.tv_sec) * 1000; orig_mouse_time = mouse_time; if (mouse_code == orig_mouse_code && timediff < p_mouset && orig_num_clicks != 4 && orig_mouse_col == mouse_col && orig_mouse_row == mouse_row && orig_topline == curwin->w_topline) ++orig_num_clicks; else orig_num_clicks = 1; orig_mouse_col = mouse_col; orig_mouse_row = mouse_row; orig_topline = curwin->w_topline; } # ifdef USE_GUI else orig_num_clicks = NUM_MOUSE_CLICKS(mouse_code); # endif #else orig_num_clicks = NUM_MOUSE_CLICKS(mouse_code); #endif is_click = TRUE; orig_mouse_code = mouse_code; } if (!is_drag) held_button = mouse_code & MOUSE_CLICK_MASK; /* * Translate the actual mouse event into a pseudo mouse event. * First work out what modifiers are to be used. */ modifiers = 0x0; if (orig_mouse_code & MOUSE_SHIFT) modifiers |= MOD_MASK_SHIFT; if (orig_mouse_code & MOUSE_CTRL) modifiers |= MOD_MASK_CTRL; if (orig_mouse_code & MOUSE_ALT) modifiers |= MOD_MASK_ALT; if (orig_num_clicks == 2) modifiers |= MOD_MASK_2CLICK; else if (orig_num_clicks == 3) modifiers |= MOD_MASK_3CLICK; else if (orig_num_clicks == 4) modifiers |= MOD_MASK_4CLICK; /* Add the modifier codes to our string */ if (modifiers != 0) { string[new_slen++] = K_SPECIAL; string[new_slen++] = KS_MODIFIER; string[new_slen++] = modifiers; } /* Work out our pseudo mouse event */ key_name[0] = KS_EXTRA; key_name[1] = get_pseudo_mouse_code(current_button, is_click, is_drag); } #endif /* USE_MOUSE */ #ifdef USE_GUI /* * If using the GUI, then we get menu and scrollbar events. * * A menu event is encoded as K_SPECIAL, KS_MENU, K_FILLER followed by * four bytes which are to be taken as a pointer to the GuiMenu * structure. * * A scrollbar event is K_SPECIAL, KS_SCROLLBAR, K_FILLER followed by * one byte representing the scrollbar number, and then four bytes * representing a long_u which is the new value of the scrollbar. * * A horizontal scrollbar event is K_SPECIAL, KS_HORIZ_SCROLLBAR, * K_FILLER followed by four bytes representing a long_u which is the * new value of the scrollbar. */ else if (key_name[0] == KS_MENU) { num_bytes = get_long_from_buf(tp + slen, &val); if (num_bytes == -1) return -1; current_menu = (GuiMenu *)val; slen += num_bytes; } else if (key_name[0] == KS_SCROLLBAR) { num_bytes = get_bytes_from_buf(tp + slen, bytes, 1); if (num_bytes == -1) return -1; current_scrollbar = (int)bytes[0]; slen += num_bytes; num_bytes = get_long_from_buf(tp + slen, &val); if (num_bytes == -1) return -1; scrollbar_value = val; slen += num_bytes; } else if (key_name[0] == KS_HORIZ_SCROLLBAR) { num_bytes = get_long_from_buf(tp + slen, &val); if (num_bytes == -1) return -1; scrollbar_value = val; slen += num_bytes; } #endif /* USE_GUI */ /* Finally, add the special key code to our string */ string[new_slen++] = K_SPECIAL; string[new_slen++] = key_name[0]; string[new_slen++] = key_name[1]; string[new_slen] = NUL; extra = new_slen - slen; if (extra < 0) /* remove matched chars, taking care of noremap */ del_typebuf(-extra, offset); else if (extra > 0) /* insert the extra space we need */ ins_typebuf(string + slen, FALSE, offset, FALSE); /* * Careful: del_typebuf() and ins_typebuf() may have * reallocated typebuf[] */ vim_memmove(typebuf + typeoff + offset, string, (size_t)new_slen); return (len + extra + offset); } return 0; /* no match found */ } /* * Replace any terminal code strings in from[] with the equivalent internal * vim representation. This is used for the "from" and "to" part of a * mapping, and the "to" part of a menu command. * Any strings like "" are also replaced, unless 'cpoptions' contains * '<'. * K_SPECIAL by itself is replaced by K_SPECIAL KS_SPECIAL K_FILLER. * * The replacement is done in result[] and finally copied into allocated * memory. If this all works well *bufp is set to the allocated memory and a * pointer to it is returned. If something fails *bufp is set to NULL and from * is returned. * * CTRL-V characters are removed. When "from_part" is TRUE, a trailing CTRL-V * is included, otherwise it is removed (for ":map xx ^V", maps xx to * nothing). When 'cpoptions' does not contain 'B', a backslash can be used * instead of a CTRL-V. */ char_u * replace_termcodes(from, bufp, from_part) char_u *from; char_u **bufp; int from_part; { int i; #ifdef OLD_KEYSTUFF char_u key_name[2]; #endif int slen; int key; int dlen = 0; char_u *src; int do_backslash; /* backslash is a special character */ int do_special; /* recognize <> key codes */ int do_key_code; /* recognize raw key codes */ char_u *result; /* buffer for resulting string */ do_backslash = (vim_strchr(p_cpo, CPO_BSLASH) == NULL); do_special = (vim_strchr(p_cpo, CPO_SPECI) == NULL); do_key_code = (vim_strchr(p_cpo, CPO_KEYCODE) == NULL); /* * Allocate space for the translation. Worst case a single character is * replaced by 6 bytes (shifted special key), plus a NUL at the end. */ result = alloc((unsigned)STRLEN(from) * 6 + 1); if (result == NULL) /* out of memory */ { *bufp = NULL; return from; } src = from; /* * Check for #n at start only: function key n */ if (from_part && src[0] == '#' && isdigit(src[1])) /* function key */ { result[dlen++] = K_SPECIAL; result[dlen++] = 'k'; if (src[1] == '0') result[dlen++] = ';'; /* #0 is F10 is "k;" */ else result[dlen++] = src[1]; /* #3 is F3 is "k3" */ src += 2; } /* * Copy each byte from *from to result[dlen] */ while (*src != NUL) { /* * If 'cpoptions' does not contain '<', check for special key codes, * like "" */ if (do_special) { slen = trans_special(&src, result + dlen); if (slen) { dlen += slen; continue; } } /* * If 'cpoptions' does not contain 'k', see if it's an actual key-code. * Note that this is also checked after replacing the <> form. */ if (do_key_code) { for (i = 0; i < tc_len; ++i) { slen = termcodes[i].len; if (STRNCMP(termcodes[i].code, src, (size_t)slen) == 0) { #ifdef OLD_KEYSTUFF key_name[0] = termcodes[i].name[0]; key_name[1] = termcodes[i].name[1]; /* * If it's a shifted special key, then include the SHIFT * modifier */ if (unshift_special_key(&key_name[0])) { result[dlen++] = K_SPECIAL; result[dlen++] = KS_MODIFIER; result[dlen++] = MOD_MASK_SHIFT; } result[dlen++] = K_SPECIAL; result[dlen++] = key_name[0]; result[dlen++] = key_name[1]; #else result[dlen++] = K_SPECIAL; result[dlen++] = termcodes[i].name[0]; result[dlen++] = termcodes[i].name[1]; #endif src += slen; break; } } /* * If terminal code matched, continue after it. * If no terminal code matched and the character is K_SPECIAL, * replace it with K_SPECIAL KS_SPECIAL K_FILLER */ if (i != tc_len) continue; } if (*src == K_SPECIAL) { result[dlen++] = K_SPECIAL; result[dlen++] = KS_SPECIAL; result[dlen++] = K_FILLER; ++src; continue; } /* * Remove CTRL-V and ignore the next character. * For "from" side the CTRL-V at the end is included, for the "to" * part it is removed. * If 'cpoptions' does not contain 'B', also accept a backslash. */ key = *src; if (key == Ctrl('V') || (do_backslash && key == '\\')) { ++src; /* skip CTRL-V or backslash */ if (*src == NUL) { if (from_part) result[dlen++] = key; break; } } result[dlen++] = *src++; } result[dlen] = NUL; /* * Copy the new string to allocated memory. * If this fails, just return from. */ if ((*bufp = vim_strsave(result)) != NULL) from = *bufp; vim_free(result); return from; } /* * Gather the first characters in the terminal key codes into a string. * Used to speed up check_termcode(). */ static void gather_termleader() { int i; int len = 0; #ifdef USE_GUI if (gui.in_use) termleader[len++] = CSI; /* the GUI codes are not in termcodes[] */ #endif termleader[len] = NUL; for (i = 0; i < tc_len; ++i) if (vim_strchr(termleader, termcodes[i].code[0]) == NULL) { termleader[len++] = termcodes[i].code[0]; termleader[len] = NUL; } need_gather = FALSE; } /* * Show all termcodes (for ":set termcap") * This code looks a lot like showoptions(), but is different. */ void show_termcodes() { int col; int *items; int item_count; int run; int row, rows; int cols; int i; int len; #define INC 27 /* try to make three columns */ #define GAP 2 /* spaces between columns */ if (tc_len == 0) /* no terminal codes (must be GUI) */ return; items = (int *)alloc((unsigned)(sizeof(int) * tc_len)); if (items == NULL) return; /* Highlight title */ MSG_PUTS_TITLE("\n--- Terminal keys ---"); /* * do the loop two times: * 1. display the short items (non-strings and short strings) * 2. display the long items (strings) */ for (run = 1; run <= 2 && !got_int; ++run) { /* * collect the items in items[] */ item_count = 0; for (i = 0; i < tc_len; i++) { len = show_one_termcode(termcodes[i].name, termcodes[i].code, FALSE); if ((len <= INC - GAP && run == 1) || (len > INC - GAP && run == 2)) items[item_count++] = i; } /* * display the items */ if (run == 1) { cols = (Columns + GAP) / INC; if (cols == 0) cols = 1; rows = (item_count + cols - 1) / cols; } else /* run == 2 */ rows = item_count; for (row = 0; row < rows && !got_int; ++row) { msg_putchar('\n'); /* go to next line */ if (got_int) /* 'q' typed in more */ break; col = 0; for (i = row; i < item_count; i += rows) { msg_pos(-1, col); /* make columns */ show_one_termcode(termcodes[items[i]].name, termcodes[items[i]].code, TRUE); col += INC; } flushbuf(); ui_breakcheck(); } } vim_free(items); } /* * Show one termcode entry. * Output goes into IObuff[] */ int show_one_termcode(name, code, printit) char_u *name; char_u *code; int printit; { char_u *p; int len; if (name[0] > '~') { IObuff[0] = ' '; IObuff[1] = ' '; IObuff[2] = ' '; IObuff[3] = ' '; } else { IObuff[0] = 't'; IObuff[1] = '_'; IObuff[2] = name[0]; IObuff[3] = name[1]; } IObuff[4] = ' '; p = get_special_key_name(TERMCAP2KEY(name[0], name[1]), 0); if (p[1] != 't') STRCPY(IObuff + 5, p); else IObuff[5] = NUL; len = STRLEN(IObuff); do IObuff[len++] = ' '; while (len < 17); IObuff[len] = NUL; if (code == NULL) len += 4; else len += strsize(code); if (printit) { msg_puts(IObuff); if (code == NULL) msg_puts((char_u *)"NULL"); else msg_outtrans(code); } return len; }