Annotation of src/usr.bin/vim/term.c, Revision 1.1.1.1
1.1 downsj 1: /* $OpenBSD$ */
2: /* vi:set ts=4 sw=4:
3: *
4: * VIM - Vi IMproved by Bram Moolenaar
5: *
6: * Do ":help uganda" in Vim to read copying and usage conditions.
7: * Do ":help credits" in Vim to see a list of people who contributed.
8: */
9: /*
10: *
11: * term.c: functions for controlling the terminal
12: *
13: * primitive termcap support for Amiga, MSDOS, and Win32 included
14: *
15: * NOTE: padding and variable substitution is not performed,
16: * when compiling without HAVE_TGETENT, we use tputs() and tgoto() dummies.
17: */
18:
19: /*
20: * Some systems have a prototype for tgetstr() with (char *) instead of
21: * (char **). This define removes that prototype. We include our own prototype
22: * below.
23: */
24:
25: #define tgetstr tgetstr_defined_wrong
26: #include "vim.h"
27:
28: #include "globals.h"
29: #include "option.h"
30: #include "proto.h"
31:
32: #ifdef HAVE_TGETENT
33: # ifdef HAVE_TERMCAP_H
34: # include <termcap.h>
35: # endif
36:
37: /*
38: * A few linux systems define outfuntype in termcap.h to be used as the third
39: * argument for tputs().
40: */
41: # ifdef VMS
42: # define TPUTSFUNCAST
43: # else
44: # ifdef HAVE_OUTFUNTYPE
45: # define TPUTSFUNCAST (outfuntype)
46: # else
47: # define TPUTSFUNCAST (int (*)())
48: # endif
49: # endif
50: #endif
51:
52: #undef tgetstr
53:
54: /*
55: * Here are the builtin termcap entries. They are not stored as complete
56: * Tcarr structures, as such a structure is too big.
57: *
58: * The entries are compact, therefore they normally are included even when
59: * HAVE_TGETENT is defined. When HAVE_TGETENT is defined, the builtin entries
60: * can be accessed with "builtin_amiga", "builtin_ansi", "builtin_debug", etc.
61: *
62: * Each termcap is a list of builtin_term structures. It always starts with
63: * KS_NAME, which separates the entries. See parse_builtin_tcap() for all
64: * details.
65: * bt_entry is either a KS_xxx code (< 0x100), or a K_xxx code.
66: */
67: struct builtin_term
68: {
69: int bt_entry;
70: char *bt_string;
71: };
72:
73: /* start of keys that are not directly used by Vim but can be mapped */
74: #define BT_EXTRA_KEYS 0x101
75:
76: static struct builtin_term *find_builtin_term __ARGS((char_u *name));
77: static void parse_builtin_tcap __ARGS((char_u *s));
78: static void gather_termleader __ARGS((void));
79: static int get_bytes_from_buf __ARGS((char_u *, char_u *, int));
80: static int is_builtin_term __ARGS((char_u *));
81:
82: #ifdef HAVE_TGETENT
83: static char_u *tgetent_error __ARGS((char_u *, char_u *));
84:
85: /*
86: * Here is our own prototype for tgetstr(), any prototypes from the include
87: * files have been disabled by the define at the start of this file.
88: */
89: char *tgetstr __PARMS((char *, char **));
90:
91: /*
92: * Don't declare these variables if termcap.h contains them.
93: * Autoconf checks if these variables should be declared extern (not all
94: * systems have them).
95: * Some versions define ospeed to be speed_t, but that is incompatible with
96: * BSD, where ospeed is short and speed_t is long.
97: */
98: # ifndef HAVE_OSPEED
99: # ifdef OSPEED_EXTERN
100: extern short ospeed;
101: # else
102: short ospeed;
103: # endif
104: # endif
105: # ifndef HAVE_UP_BC_PC
106: # ifdef UP_BC_PC_EXTERN
107: extern char *UP, *BC, PC;
108: # else
109: char *UP, *BC, PC;
110: # endif
111: # endif
112:
113: # define TGETSTR(s, p) (char_u *)tgetstr((s), (char **)(p))
114: # define TGETENT(b, t) tgetent((char *)(b), (char *)(t))
115:
116: #endif /* HAVE_TGETENT */
117:
118: struct builtin_term builtin_termcaps[] =
119: {
120:
121: #if defined(USE_GUI)
122: /*
123: * Motif/Athena pseudo term-cap.
124: */
125: {KS_NAME, "gui"},
126: {KS_CE, "\033|$"},
127: {KS_AL, "\033|i"},
128: # ifdef TERMINFO
129: {KS_CAL, "\033|%p1%dI"},
130: # else
131: {KS_CAL, "\033|%dI"},
132: # endif
133: {KS_DL, "\033|d"},
134: # ifdef TERMINFO
135: {KS_CDL, "\033|%p1%dD"},
136: {KS_CS, "\033|%p1%d;%p2%dR"},
137: # else
138: {KS_CDL, "\033|%dD"},
139: {KS_CS, "\033|%d;%dR"},
140: # endif
141: {KS_CL, "\033|C"},
142: {KS_ME, "\033|63H"}, /* 63 = HL_ALL, H = off */
143: {KS_MR, "\033|1h"}, /* 1 = HL_INVERSE, h = on */
144: {KS_MD, "\033|2h"}, /* 2 = HL_BOLD, h = on */
145: {KS_SE, "\033|16H"}, /* 16 = HL_STANDOUT, H = off */
146: {KS_SO, "\033|16h"}, /* 16 = HL_STANDOUT, h = on */
147: {KS_UE, "\033|8H"}, /* 8 = HL_UNDERLINE, H = off */
148: {KS_US, "\033|8h"}, /* 8 = HL_UNDERLINE, h = on */
149: {KS_CZR, "\033|4H"}, /* 4 = HL_ITAL, H = off */
150: {KS_CZH, "\033|4h"}, /* 4 = HL_ITAL, h = on */
151: {KS_VB, "\033|f"},
152: # ifdef TERMINFO
153: {KS_CM, "\033|%p1%d;%p2%dM"},
154: # else
155: {KS_CM, "\033|%d;%dM"},
156: # endif
157: /* there are no key sequences here, the GUI sequences are recognized
158: * in check_termcodes() */
159: #endif
160:
161: #ifndef NO_BUILTIN_TCAPS
162:
163: # if defined(AMIGA) || defined(ALL_BUILTIN_TCAPS)
164: /*
165: * Amiga console window, default for Amiga
166: */
167: {KS_NAME, "amiga"},
168: {KS_CE, "\033[K"},
169: {KS_CD, "\033[J"},
170: {KS_AL, "\033[L"},
171: # ifdef TERMINFO
172: {KS_CAL, "\033[%p1%dL"},
173: # else
174: {KS_CAL, "\033[%dL"},
175: # endif
176: {KS_DL, "\033[M"},
177: # ifdef TERMINFO
178: {KS_CDL, "\033[%p1%dM"},
179: # else
180: {KS_CDL, "\033[%dM"},
181: # endif
182: {KS_CL, "\014"},
183: {KS_VI, "\033[0 p"},
184: {KS_VE, "\033[1 p"},
185: {KS_ME, "\033[0m"},
186: {KS_MR, "\033[7m"},
187: {KS_MD, "\033[1m"},
188: {KS_SE, "\033[0m"},
189: {KS_SO, "\033[33m"},
190: {KS_US, "\033[4m"},
191: {KS_UE, "\033[0m"},
192: {KS_CZH, "\033[3m"},
193: {KS_CZR, "\033[0m"},
194: {KS_MS, "\001"},
195: # ifdef TERMINFO
196: {KS_CM, "\033[%i%p1%d;%p2%dH"},
197: # else
198: {KS_CM, "\033[%i%d;%dH"},
199: # endif
200: # ifdef TERMINFO
201: {KS_CRI, "\033[%p1%dC"},
202: # else
203: {KS_CRI, "\033[%dC"},
204: # endif
205: {K_UP, "\233A"},
206: {K_DOWN, "\233B"},
207: {K_LEFT, "\233D"},
208: {K_RIGHT, "\233C"},
209: {K_S_UP, "\233T"},
210: {K_S_DOWN, "\233S"},
211: {K_S_LEFT, "\233 A"},
212: {K_S_RIGHT, "\233 @"},
213: {K_S_TAB, "\233Z"},
214: {K_F1, "\233\060~"},/* some compilers don't understand "\2330" */
215: {K_F2, "\233\061~"},
216: {K_F3, "\233\062~"},
217: {K_F4, "\233\063~"},
218: {K_F5, "\233\064~"},
219: {K_F6, "\233\065~"},
220: {K_F7, "\233\066~"},
221: {K_F8, "\233\067~"},
222: {K_F9, "\233\070~"},
223: {K_F10, "\233\071~"},
224: {K_S_F1, "\233\061\060~"},
225: {K_S_F2, "\233\061\061~"},
226: {K_S_F3, "\233\061\062~"},
227: {K_S_F4, "\233\061\063~"},
228: {K_S_F5, "\233\061\064~"},
229: {K_S_F6, "\233\061\065~"},
230: {K_S_F7, "\233\061\066~"},
231: {K_S_F8, "\233\061\067~"},
232: {K_S_F9, "\233\061\070~"},
233: {K_S_F10, "\233\061\071~"},
234: {K_HELP, "\233?~"},
235: {K_INS, "\233\064\060~"}, /* 101 key keyboard */
236: {K_PAGEUP, "\233\064\061~"}, /* 101 key keyboard */
237: {K_PAGEDOWN, "\233\064\062~"}, /* 101 key keyboard */
238: {K_HOME, "\233\064\064~"}, /* 101 key keyboard */
239: {K_END, "\233\064\065~"}, /* 101 key keyboard */
240:
241: {BT_EXTRA_KEYS, ""},
242: {TERMCAP2KEY('#', '2'), "\233\065\064~"}, /* shifted home key */
243: {TERMCAP2KEY('#', '3'), "\233\065\060~"}, /* shifted insert key */
244: {TERMCAP2KEY('*', '7'), "\233\065\065~"}, /* shifted end key */
245: # endif
246:
247: # if defined(UNIX) || defined(ALL_BUILTIN_TCAPS) || defined(SOME_BUILTIN_TCAPS) || defined(__EMX__)
248: /*
249: * standard ANSI terminal, default for unix
250: */
251: {KS_NAME, "ansi"},
252: {KS_CE, "\033[K"},
253: {KS_AL, "\033[L"},
254: # ifdef TERMINFO
255: {KS_CAL, "\033[%p1%dL"},
256: # else
257: {KS_CAL, "\033[%dL"},
258: # endif
259: {KS_DL, "\033[M"},
260: # ifdef TERMINFO
261: {KS_CDL, "\033[%p1%dM"},
262: # else
263: {KS_CDL, "\033[%dM"},
264: # endif
265: {KS_CL, "\033[H\033[2J"},
266: {KS_ME, "\033[0m"},
267: {KS_MR, "\033[7m"},
268: {KS_MS, "\001"},
269: # ifdef TERMINFO
270: {KS_CM, "\033[%i%p1%d;%p2%dH"},
271: # else
272: {KS_CM, "\033[%i%d;%dH"},
273: # endif
274: # ifdef TERMINFO
275: {KS_CRI, "\033[%p1%dC"},
276: # else
277: {KS_CRI, "\033[%dC"},
278: # endif
279: # endif
280:
281: # if defined(MSDOS) || defined(ALL_BUILTIN_TCAPS) || defined(__EMX__)
282: /*
283: * These codes are valid when nansi.sys or equivalent has been installed.
284: * Function keys on a PC are preceded with a NUL. These are converted into
285: * K_NUL '\316' in mch_inchar(), because we cannot handle NULs in key codes.
286: * CTRL-arrow is used instead of SHIFT-arrow.
287: */
288: #ifdef __EMX__
289: {KS_NAME, "os2ansi"},
290: #else
291: {KS_NAME, "pcansi"},
292: {KS_DL, "\033[M"},
293: {KS_AL, "\033[L"},
294: #endif
295: {KS_CE, "\033[K"},
296: {KS_CL, "\033[2J"},
297: {KS_ME, "\033[0m"},
298: {KS_MR, "\033[7m"},
299: {KS_MS, "\001"},
300: # ifdef TERMINFO
301: {KS_CM, "\033[%i%p1%d;%p2%dH"},
302: # else
303: {KS_CM, "\033[%i%d;%dH"},
304: # endif
305: # ifdef TERMINFO
306: {KS_CRI, "\033[%p1%dC"},
307: # else
308: {KS_CRI, "\033[%dC"},
309: # endif
310: {K_UP, "\316H"},
311: {K_DOWN, "\316P"},
312: {K_LEFT, "\316K"},
313: {K_RIGHT, "\316M"},
314: {K_S_LEFT, "\316s"},
315: {K_S_RIGHT, "\316t"},
316: {K_F1, "\316;"},
317: {K_F2, "\316<"},
318: {K_F3, "\316="},
319: {K_F4, "\316>"},
320: {K_F5, "\316?"},
321: {K_F6, "\316@"},
322: {K_F7, "\316A"},
323: {K_F8, "\316B"},
324: {K_F9, "\316C"},
325: {K_F10, "\316D"},
326: {K_F11, "\316\205"}, /* guessed */
327: {K_F12, "\316\206"}, /* guessed */
328: {K_S_F1, "\316T"},
329: {K_S_F2, "\316U"},
330: {K_S_F3, "\316V"},
331: {K_S_F4, "\316W"},
332: {K_S_F5, "\316X"},
333: {K_S_F6, "\316Y"},
334: {K_S_F7, "\316Z"},
335: {K_S_F8, "\316["},
336: {K_S_F9, "\316\\"},
337: {K_S_F10, "\316]"},
338: {K_S_F11, "\316\207"}, /* guessed */
339: {K_S_F12, "\316\210"}, /* guessed */
340: {K_INS, "\316R"},
341: {K_DEL, "\316S"},
342: {K_HOME, "\316G"},
343: {K_END, "\316O"},
344: {K_PAGEDOWN, "\316Q"},
345: {K_PAGEUP, "\316I"},
346: # endif
347:
348: # if defined(MSDOS)
349: /*
350: * These codes are valid for the pc video. The entries that start with ESC |
351: * are translated into conio calls in msdos.c. Default for MSDOS.
352: */
353: {KS_NAME, "pcterm"},
354: {KS_CE, "\033|K"},
355: {KS_AL, "\033|L"},
356: {KS_DL, "\033|M"},
357: # ifdef TERMINFO
358: {KS_CS, "\033|%i%p1%d;%p2%dr"},
359: # else
360: {KS_CS, "\033|%i%d;%dr"},
361: # endif
362: {KS_CL, "\033|J"},
363: {KS_ME, "\033|0m"},
364: {KS_MR, "\033|112m"},
365: {KS_MD, "\033|63m"},
366: {KS_SE, "\033|0m"},
367: {KS_SO, "\033|31m"},
368: {KS_MS, "\001"},
369: # ifdef TERMINFO
370: {KS_CM, "\033|%i%p1%d;%p2%dH"},
371: # else
372: {KS_CM, "\033|%i%d;%dH"},
373: # endif
374: {K_UP, "\316H"},
375: {K_DOWN, "\316P"},
376: {K_LEFT, "\316K"},
377: {K_RIGHT, "\316M"},
378: {K_S_LEFT, "\316s"},
379: {K_S_RIGHT, "\316t"},
380: {K_S_TAB, "\316\017"},
381: {K_F1, "\316;"},
382: {K_F2, "\316<"},
383: {K_F3, "\316="},
384: {K_F4, "\316>"},
385: {K_F5, "\316?"},
386: {K_F6, "\316@"},
387: {K_F7, "\316A"},
388: {K_F8, "\316B"},
389: {K_F9, "\316C"},
390: {K_F10, "\316D"},
391: {K_F11, "\316\205"}, /* only when nobioskey */
392: {K_F12, "\316\206"}, /* only when nobioskey */
393: {K_S_F1, "\316T"},
394: {K_S_F2, "\316U"},
395: {K_S_F3, "\316V"},
396: {K_S_F4, "\316W"},
397: {K_S_F5, "\316X"},
398: {K_S_F6, "\316Y"},
399: {K_S_F7, "\316Z"},
400: {K_S_F8, "\316["},
401: {K_S_F9, "\316\\"},
402: {K_S_F10, "\316]"},
403: {K_S_F11, "\316\207"}, /* only when nobioskey */
404: {K_S_F12, "\316\210"}, /* only when nobioskey */
405: {K_INS, "\316R"},
406: {K_DEL, "\316S"},
407: {K_HOME, "\316G"},
408: {K_END, "\316O"},
409: {K_PAGEDOWN, "\316Q"},
410: {K_PAGEUP, "\316I"},
411: # endif
412:
413: # if defined(WIN32) || defined(ALL_BUILTIN_TCAPS) || defined(__EMX__)
414: /*
415: * These codes are valid for the Win32 Console . The entries that start with
416: * ESC | are translated into console calls in win32.c. The function keys
417: * are also translated in win32.c.
418: */
419: {KS_NAME, "win32"},
420: {KS_CE, "\033|K"}, /* clear to end of line */
421: {KS_AL, "\033|L"}, /* add new blank line */
422: # ifdef TERMINFO
423: {KS_CAL, "\033|%p1%dL"}, /* add number of new blank lines */
424: # else
425: {KS_CAL, "\033|%dL"}, /* add number of new blank lines */
426: # endif
427: {KS_DL, "\033|M"}, /* delete line */
428: # ifdef TERMINFO
429: {KS_CDL, "\033|%p1%dM"}, /* delete number of lines */
430: # else
431: {KS_CDL, "\033|%dM"}, /* delete number of lines */
432: # endif
433: {KS_CL, "\033|J"}, /* clear screen */
434: {KS_CD, "\033|j"}, /* clear to end of display */
435: {KS_VI, "\033|v"}, /* cursor invisible */
436: {KS_VE, "\033|V"}, /* cursor visible */
437:
438: {KS_ME, "\033|0m"}, /* normal mode */
439: {KS_MR, "\033|112m"}, /* reverse mode: black text on lightgray */
440: {KS_MD, "\033|63m"}, /* bold mode: white text on cyan */
441: #if 1
442: {KS_SO, "\033|31m"}, /* standout mode: white text on blue */
443: {KS_SE, "\033|0m"}, /* standout mode end */
444: #else
445: {KS_SO, "\033|F"}, /* standout mode: high intensity text */
446: {KS_SE, "\033|f"}, /* standout mode end */
447: #endif
448: {KS_CZH, "\033|225m"}, /* italic mode: blue text on yellow */
449: {KS_CZR, "\033|0m"}, /* italic mode end */
450: {KS_US, "\033|67m"}, /* underscore mode: cyan text on red */
451: {KS_UE, "\033|0m"}, /* underscore mode end */
452:
453: {KS_MS, "\001"}, /* save to move cur in reverse mode */
454: # ifdef TERMINFO
455: {KS_CM, "\033|%i%p1%d;%p2%dH"}, /* cursor motion */
456: # else
457: {KS_CM, "\033|%i%d;%dH"}, /* cursor motion */
458: # endif
459: {KS_VB, "\033|B"}, /* visual bell */
460: {KS_TI, "\033|S"}, /* put terminal in termcap mode */
461: {KS_TE, "\033|E"}, /* out of termcap mode */
462: {KS_CS, "\033|%i%d;%dr"}, /* scroll region */
463:
464: {K_UP, "\316H"},
465: {K_DOWN, "\316P"},
466: {K_LEFT, "\316K"},
467: {K_RIGHT, "\316M"},
468: {K_S_UP, "\316\304"},
469: {K_S_DOWN, "\316\317"},
470: {K_S_LEFT, "\316\311"},
471: {K_S_RIGHT, "\316\313"},
472: {K_S_TAB, "\316\017"},
473: {K_F1, "\316;"},
474: {K_F2, "\316<"},
475: {K_F3, "\316="},
476: {K_F4, "\316>"},
477: {K_F5, "\316?"},
478: {K_F6, "\316@"},
479: {K_F7, "\316A"},
480: {K_F8, "\316B"},
481: {K_F9, "\316C"},
482: {K_F10, "\316D"},
483: {K_F11, "\316\205"},
484: {K_F12, "\316\206"},
485: {K_S_F1, "\316T"},
486: {K_S_F2, "\316U"},
487: {K_S_F3, "\316V"},
488: {K_S_F4, "\316W"},
489: {K_S_F5, "\316X"},
490: {K_S_F6, "\316Y"},
491: {K_S_F7, "\316Z"},
492: {K_S_F8, "\316["},
493: {K_S_F9, "\316\\"},
494: {K_S_F10, "\316]"},
495: {K_S_F11, "\316\207"},
496: {K_S_F12, "\316\210"},
497: {K_INS, "\316R"},
498: {K_DEL, "\316S"},
499: {K_HOME, "\316G"},
500: {K_END, "\316O"},
501: {K_PAGEDOWN, "\316Q"},
502: {K_PAGEUP, "\316I"},
503: # endif
504:
505: # if defined(ALL_BUILTIN_TCAPS) || defined(MINT)
506: /*
507: * Ordinary vt52
508: */
509: {KS_NAME, "vt52"},
510: {KS_CE, "\033K"},
511: {KS_CD, "\033J"},
512: {KS_CM, "\033Y%+ %+ "},
513: # ifdef MINT
514: {KS_AL, "\033L"},
515: {KS_DL, "\033M"},
516: {KS_CL, "\033E"},
517: {KS_SR, "\033I"},
518: {KS_VE, "\033e"},
519: {KS_VI, "\033f"},
520: {KS_SO, "\033p"},
521: {KS_SE, "\033q"},
522: {K_UP, "\033A"},
523: {K_DOWN, "\033B"},
524: {K_LEFT, "\033D"},
525: {K_RIGHT, "\033C"},
526: {K_S_UP, "\033a"},
527: {K_S_DOWN, "\033b"},
528: {K_S_LEFT, "\033d"},
529: {K_S_RIGHT, "\033c"},
530: {K_F1, "\033P"},
531: {K_F2, "\033Q"},
532: {K_F3, "\033R"},
533: {K_F4, "\033S"},
534: {K_F5, "\033T"},
535: {K_F6, "\033U"},
536: {K_F7, "\033V"},
537: {K_F8, "\033W"},
538: {K_F9, "\033X"},
539: {K_F10, "\033Y"},
540: {K_S_F1, "\033p"},
541: {K_S_F2, "\033q"},
542: {K_S_F3, "\033r"},
543: {K_S_F4, "\033s"},
544: {K_S_F5, "\033t"},
545: {K_S_F6, "\033u"},
546: {K_S_F7, "\033v"},
547: {K_S_F8, "\033w"},
548: {K_S_F9, "\033x"},
549: {K_S_F10, "\033y"},
550: {K_INS, "\033I"},
551: {K_HOME, "\033E"},
552: {K_PAGEDOWN, "\033b"},
553: {K_PAGEUP, "\033a"},
554: # else
555: {KS_AL, "\033T"},
556: {KS_DL, "\033U"},
557: {KS_CL, "\033H\033J"},
558: {KS_ME, "\033SO"},
559: {KS_MR, "\033S2"},
560: {KS_MS, "\001"},
561: # endif
562: # endif
563:
564: # if defined(UNIX) || defined(ALL_BUILTIN_TCAPS) || defined(SOME_BUILTIN_TCAPS) || defined(__EMX__)
565: /*
566: * The xterm termcap is missing F14 and F15, because they send the same
567: * codes as the undo and help key, although they don't work on all keyboards.
568: */
569: {KS_NAME, "xterm"},
570: {KS_CE, "\033[K"},
571: {KS_AL, "\033[L"},
572: # ifdef TERMINFO
573: {KS_CAL, "\033[%p1%dL"},
574: # else
575: {KS_CAL, "\033[%dL"},
576: # endif
577: {KS_DL, "\033[M"},
578: # ifdef TERMINFO
579: {KS_CDL, "\033[%p1%dM"},
580: # else
581: {KS_CDL, "\033[%dM"},
582: # endif
583: # ifdef TERMINFO
584: {KS_CS, "\033[%i%p1%d;%p2%dr"},
585: # else
586: {KS_CS, "\033[%i%d;%dr"},
587: # endif
588: {KS_CL, "\033[H\033[2J"},
589: {KS_CD, "\033[J"},
590: {KS_ME, "\033[m"},
591: {KS_MR, "\033[7m"},
592: {KS_MD, "\033[1m"},
593: {KS_UE, "\033[m"},
594: {KS_US, "\033[4m"},
595: {KS_MS, "\001"},
596: # ifdef TERMINFO
597: {KS_CM, "\033[%i%p1%d;%p2%dH"},
598: # else
599: {KS_CM, "\033[%i%d;%dH"},
600: # endif
601: {KS_SR, "\033M"},
602: # ifdef TERMINFO
603: {KS_CRI, "\033[%p1%dC"},
604: # else
605: {KS_CRI, "\033[%dC"},
606: # endif
607: {KS_KS, "\033[?1h\033="},
608: {KS_KE, "\033[?1l\033>"},
609: # ifdef SAVE_XTERM_SCREEN
610: {KS_TI, "\0337\033[?47h"},
611: {KS_TE, "\033[2J\033[?47l\0338"},
612: # endif
613: {K_UP, "\033OA"},
614: {K_DOWN, "\033OB"},
615: {K_LEFT, "\033OD"},
616: {K_RIGHT, "\033OC"},
617: {K_S_UP, "\033Ox"},
618: {K_S_DOWN, "\033Or"},
619: {K_S_LEFT, "\033Ot"},
620: {K_S_RIGHT, "\033Ov"},
621: {K_F1, "\033[11~"},
622: {K_F2, "\033[12~"},
623: {K_F3, "\033[13~"},
624: {K_F4, "\033[14~"},
625: {K_F5, "\033[15~"},
626: {K_F6, "\033[17~"},
627: {K_F7, "\033[18~"},
628: {K_F8, "\033[19~"},
629: {K_F9, "\033[20~"},
630: {K_F10, "\033[21~"},
631: {K_F11, "\033[23~"},
632: {K_F12, "\033[24~"},
633: {K_HELP, "\033[28~"},
634: {K_UNDO, "\033[26~"},
635: {K_INS, "\033[2~"},
636: {K_HOME, "\033[7~"}, /* also seen: "\033[1~" */
637: {K_END, "\033[8~"}, /* also seen: "\033[4~" */
638: {K_PAGEUP, "\033[5~"},
639: {K_PAGEDOWN, "\033[6~"},
640: /* {K_DEL, "\033[3~"}, not used */
641:
642: {BT_EXTRA_KEYS, ""},
643: {TERMCAP2KEY('k', '0'), "\033[10~"}, /* F0 */
644: {TERMCAP2KEY('F', '3'), "\033[25~"}, /* F13 */
645: {TERMCAP2KEY('F', '6'), "\033[29~"}, /* F16 */
646: {TERMCAP2KEY('F', '7'), "\033[31~"}, /* F17 */
647: {TERMCAP2KEY('F', '8'), "\033[32~"}, /* F18 */
648: {TERMCAP2KEY('F', '9'), "\033[33~"}, /* F19 */
649: {TERMCAP2KEY('F', 'A'), "\033[34~"}, /* F20 */
650: # endif
651:
652: # if defined(UNIX) || defined(ALL_BUILTIN_TCAPS)
653: /*
654: * iris-ansi for Silicon Graphics machines.
655: */
656: {KS_NAME, "iris-ansi"},
657: {KS_CE, "\033[K"},
658: {KS_CD, "\033[J"},
659: {KS_AL, "\033[L"},
660: # ifdef TERMINFO
661: {KS_CAL, "\033[%p1%dL"},
662: # else
663: {KS_CAL, "\033[%dL"},
664: # endif
665: {KS_DL, "\033[M"},
666: # ifdef TERMINFO
667: {KS_CDL, "\033[%p1%dM"},
668: # else
669: {KS_CDL, "\033[%dM"},
670: # endif
671: /*
672: * This "cs" is not working correctly. What is the right one?
673: */
674: #if 0
675: # ifdef TERMINFO
676: {KS_CS, "\033[%i%p1%d;%p2%dr"},
677: # else
678: {KS_CS, "\033[%i%d;%dr"},
679: # endif
680: #endif
681: {KS_CL, "\033[H\033[2J"},
682: {KS_VE, "\033[9/y\033[12/y\033[=6l"},
683: {KS_VS, "\033[10/y\033[=1h\033[=2l\033[=6h"},
684: {KS_SE, "\033[m"},
685: {KS_SO, "\033[1;7m"},
686: {KS_ME, "\033[m"},
687: {KS_MR, "\033[7m"},
688: {KS_MD, "\033[1m"},
689: {KS_UE, "\033[m"},
690: {KS_US, "\033[4m"},
691: {KS_MS, "\001"}, /* does this really work? */
692: # ifdef TERMINFO
693: {KS_CM, "\033[%i%p1%d;%p2%dH"},
694: # else
695: {KS_CM, "\033[%i%d;%dH"},
696: # endif
697: {KS_SR, "\033M"},
698: # ifdef TERMINFO
699: {KS_CRI, "\033[%p1%dC"},
700: # else
701: {KS_CRI, "\033[%dC"},
702: # endif
703: {K_UP, "\033[A"},
704: {K_DOWN, "\033[B"},
705: {K_LEFT, "\033[D"},
706: {K_RIGHT, "\033[C"},
707: {K_S_UP, "\033[161q"},
708: {K_S_DOWN, "\033[164q"},
709: {K_S_LEFT, "\033[158q"},
710: {K_S_RIGHT, "\033[167q"},
711: {K_F1, "\033[001q"},
712: {K_F2, "\033[002q"},
713: {K_F3, "\033[003q"},
714: {K_F4, "\033[004q"},
715: {K_F5, "\033[005q"},
716: {K_F6, "\033[006q"},
717: {K_F7, "\033[007q"},
718: {K_F8, "\033[008q"},
719: {K_F9, "\033[009q"},
720: {K_F10, "\033[010q"},
721: {K_F11, "\033[011q"},
722: {K_F12, "\033[012q"},
723: {K_S_F1, "\033[013q"},
724: {K_S_F2, "\033[014q"},
725: {K_S_F3, "\033[015q"},
726: {K_S_F4, "\033[016q"},
727: {K_S_F5, "\033[017q"},
728: {K_S_F6, "\033[018q"},
729: {K_S_F7, "\033[019q"},
730: {K_S_F8, "\033[020q"},
731: {K_S_F9, "\033[021q"},
732: {K_S_F10, "\033[022q"},
733: {K_S_F11, "\033[023q"},
734: {K_S_F12, "\033[024q"},
735: {K_INS, "\033[139q"},
736: {K_HOME, "\033[H"},
737: {K_END, "\033[146q"},
738: {K_PAGEUP, "\033[150q"},
739: {K_PAGEDOWN, "\033[154q"},
740: # endif
741:
742: # if defined(DEBUG) || defined(ALL_BUILTIN_TCAPS)
743: /*
744: * for debugging
745: */
746: {KS_NAME, "debug"},
747: {KS_CE, "[CE]"},
748: {KS_CD, "[CD]"},
749: {KS_AL, "[AL]"},
750: # ifdef TERMINFO
751: {KS_CAL, "[CAL%p1%d]"},
752: # else
753: {KS_CAL, "[CAL%d]"},
754: # endif
755: {KS_DL, "[DL]"},
756: # ifdef TERMINFO
757: {KS_CDL, "[CDL%p1%d]"},
758: # else
759: {KS_CDL, "[CDL%d]"},
760: # endif
761: # ifdef TERMINFO
762: {KS_CS, "[%dCS%p1%d]"},
763: # else
764: {KS_CS, "[%dCS%d]"},
765: # endif
766: {KS_CL, "[CL]"},
767: {KS_VI, "[VI]"},
768: {KS_VE, "[VE]"},
769: {KS_VS, "[VS]"},
770: {KS_ME, "[ME]"},
771: {KS_MR, "[MR]"},
772: {KS_MD, "[MD]"},
773: {KS_SE, "[SE]"},
774: {KS_SO, "[SO]"},
775: {KS_UE, "[UE]"},
776: {KS_US, "[US]"},
777: {KS_MS, "[MS]"},
778: # ifdef TERMINFO
779: {KS_CM, "[%p1%dCM%p2%d]"},
780: # else
781: {KS_CM, "[%dCM%d]"},
782: # endif
783: {KS_SR, "[SR]"},
784: # ifdef TERMINFO
785: {KS_CRI, "[CRI%p1%d]"},
786: # else
787: {KS_CRI, "[CRI%d]"},
788: # endif
789: {KS_VB, "[VB]"},
790: {KS_KS, "[KS]"},
791: {KS_KE, "[KE]"},
792: {KS_TI, "[TI]"},
793: {KS_TE, "[TE]"},
794: {K_UP, "[KU]"},
795: {K_DOWN, "[KD]"},
796: {K_LEFT, "[KL]"},
797: {K_RIGHT, "[KR]"},
798: {K_S_UP, "[S-KU]"},
799: {K_S_DOWN, "[S-KD]"},
800: {K_S_LEFT, "[S-KL]"},
801: {K_S_RIGHT, "[S-KR]"},
802: {K_F1, "[F1]"},
803: {K_F2, "[F2]"},
804: {K_F3, "[F3]"},
805: {K_F4, "[F4]"},
806: {K_F5, "[F5]"},
807: {K_F6, "[F6]"},
808: {K_F7, "[F7]"},
809: {K_F8, "[F8]"},
810: {K_F9, "[F9]"},
811: {K_F10, "[F10]"},
812: {K_F11, "[F11]"},
813: {K_F12, "[F12]"},
814: {K_S_F1, "[S-F1]"},
815: {K_S_F2, "[S-F2]"},
816: {K_S_F3, "[S-F3]"},
817: {K_S_F4, "[S-F4]"},
818: {K_S_F5, "[S-F5]"},
819: {K_S_F6, "[S-F6]"},
820: {K_S_F7, "[S-F7]"},
821: {K_S_F8, "[S-F8]"},
822: {K_S_F9, "[S-F9]"},
823: {K_S_F10, "[S-F10]"},
824: {K_S_F11, "[S-F11]"},
825: {K_S_F12, "[S-F12]"},
826: {K_HELP, "[HELP]"},
827: {K_UNDO, "[UNDO]"},
828: {K_BS, "[BS]"},
829: {K_INS, "[INS]"},
830: {K_DEL, "[DEL]"},
831: {K_HOME, "[HOME]"},
832: {K_END, "[END]"},
833: {K_PAGEUP, "[PAGEUP]"},
834: {K_PAGEDOWN, "[PAGEDOWN]"},
835: {K_MOUSE, "[MOUSE]"},
836: # endif
837:
838: #endif /* NO_BUILTIN_TCAPS */
839:
840: /*
841: * The most minimal terminal: only clear screen and cursor positioning
842: * Always included.
843: */
844: {KS_NAME, "dumb"},
845: {KS_CL, "\014"},
846: #ifdef TERMINFO
847: {KS_CM, "\033[%i%p1%d;%p2%dH"},
848: #else
849: {KS_CM, "\033[%i%d;%dH"},
850: #endif
851:
852: /*
853: * end marker
854: */
855: {KS_NAME, NULL}
856:
857: }; /* end of builtin_termcaps */
858:
859: /*
860: * DEFAULT_TERM is used, when no terminal is specified with -T option or $TERM.
861: */
862: #ifdef AMIGA
863: # define DEFAULT_TERM (char_u *)"amiga"
864: #endif /* AMIGA */
865:
866: #ifdef WIN32
867: # define DEFAULT_TERM (char_u *)"win32"
868: #endif /* WIN32 */
869:
870: #ifdef MSDOS
871: # define DEFAULT_TERM (char_u *)"pcterm"
872: #endif /* MSDOS */
873:
874: #if defined(UNIX) && !defined(MINT)
875: # define DEFAULT_TERM (char_u *)"ansi"
876: #endif /* UNIX */
877:
878: #ifdef MINT
879: # define DEFAULT_TERM (char_u *)"vt52"
880: #endif /* MINT */
881:
882: #ifdef __EMX__
883: # define DEFAULT_TERM (char_u *)"os2ansi"
884: #endif /* __EMX__ */
885:
886: #ifdef VMS
887: # define DEFAULT_TERM (char_u *)"ansi"
888: #endif /* VMS */
889:
890: /*
891: * Term_strings contains currently used terminal output strings.
892: * It is initialized with the default values by parse_builtin_tcap().
893: * The values can be changed by setting the option with the same name.
894: */
895: char_u *(term_strings[KS_LAST + 1]);
896:
897: static int need_gather = FALSE; /* need to fill termleader[] */
898: static char_u termleader[256 + 1]; /* for check_termcode() */
899:
900: static struct builtin_term *
901: find_builtin_term(term)
902: char_u *term;
903: {
904: struct builtin_term *p;
905:
906: p = builtin_termcaps;
907: while (p->bt_string != NULL)
908: {
909: if (p->bt_entry == KS_NAME)
910: {
911: #ifdef UNIX
912: if (STRCMP(p->bt_string, "iris-ansi") == 0 && is_iris_ansi(term))
913: return p;
914: else if (STRCMP(p->bt_string, "xterm") == 0 && is_xterm(term))
915: return p;
916: else
917: #endif
918: if (STRCMP(term, p->bt_string) == 0)
919: return p;
920: }
921: ++p;
922: }
923: return p;
924: }
925:
926: /*
927: * Parsing of the builtin termcap entries.
928: * Caller should check if 'name' is a valid builtin term.
929: * The terminal's name is not set, as this is already done in termcapinit().
930: */
931: static void
932: parse_builtin_tcap(term)
933: char_u *term;
934: {
935: struct builtin_term *p;
936: char_u name[2];
937:
938: p = find_builtin_term(term);
939: for (++p; p->bt_entry != KS_NAME && p->bt_entry != BT_EXTRA_KEYS; ++p)
940: {
941: if (p->bt_entry < 0x100) /* KS_xx entry */
942: {
943: if (term_strings[p->bt_entry] == NULL ||
944: term_strings[p->bt_entry] == empty_option)
945: term_strings[p->bt_entry] = (char_u *)p->bt_string;
946: }
947: else
948: {
949: name[0] = KEY2TERMCAP0(p->bt_entry);
950: name[1] = KEY2TERMCAP1(p->bt_entry);
951: if (find_termcode(name) == NULL)
952: add_termcode(name, (char_u *)p->bt_string);
953: }
954: }
955: }
956:
957: /*
958: * Set terminal options for terminal "term".
959: * Return OK if terminal 'term' was found in a termcap, FAIL otherwise.
960: *
961: * While doing this, until ttest(), some options may be NULL, be careful.
962: */
963: int
964: set_termname(term)
965: char_u *term;
966: {
967: struct builtin_term *termp;
968: #ifdef HAVE_TGETENT
969: int builtin_first = p_tbi;
970: int try;
971: int termcap_cleared = FALSE;
972: #endif
973: int width = 0, height = 0;
974: char_u *error_msg = NULL;
975: char_u *bs_p, *del_p;
976:
977: if (is_builtin_term(term))
978: {
979: term += 8;
980: #ifdef HAVE_TGETENT
981: builtin_first = 1;
982: #endif
983: }
984:
985: /*
986: * If HAVE_TGETENT is not defined, only the builtin termcap is used, otherwise:
987: * If builtin_first is TRUE:
988: * 0. try builtin termcap
989: * 1. try external termcap
990: * 2. if both fail default to a builtin terminal
991: * If builtin_first is FALSE:
992: * 1. try external termcap
993: * 2. try builtin termcap, if both fail default to a builtin terminal
994: */
995: #ifdef HAVE_TGETENT
996: for (try = builtin_first ? 0 : 1; try < 3; ++try)
997: {
998: /*
999: * Use external termcap
1000: */
1001: if (try == 1)
1002: {
1003: char_u *p;
1004: static char_u tstrbuf[TBUFSZ];
1005: int i;
1006: char_u tbuf[TBUFSZ];
1007: char_u *tp = tstrbuf;
1008: static char *(key_names[]) =
1009: {
1010: "ku", "kd", "kr", /* "kl" is a special case */
1011: # ifdef ARCHIE
1012: "su", "sd", /* Termcap code made up! */
1013: # endif
1014: "#4", "%i",
1015: "k1", "k2", "k3", "k4", "k5", "k6",
1016: "k7", "k8", "k9", "k;", "F1", "F2",
1017: "%1", "&8", "kb", "kI", "kD", "kh",
1018: "@7", "kP", "kN",
1019: NULL
1020: };
1021: static struct {
1022: int dest; /* index in term_strings[] */
1023: char *name; /* termcap name for string */
1024: } string_names[] =
1025: { {KS_CE, "ce"}, {KS_AL, "al"}, {KS_CAL, "AL"},
1026: {KS_DL, "dl"}, {KS_CDL, "DL"}, {KS_CS, "cs"},
1027: {KS_CL, "cl"}, {KS_CD, "cd"},
1028: {KS_VI, "vi"}, {KS_VE, "ve"},
1029: {KS_VS, "vs"}, {KS_ME, "me"}, {KS_MR, "mr"},
1030: {KS_MD, "md"}, {KS_SE, "se"}, {KS_SO, "so"},
1031: {KS_CZH, "ZH"}, {KS_CZR, "ZR"}, {KS_UE, "ue"},
1032: {KS_US, "us"}, {KS_CM, "cm"}, {KS_SR, "sr"},
1033: {KS_CRI, "RI"}, {KS_VB, "vb"}, {KS_KS, "ks"},
1034: {KS_KE, "ke"}, {KS_TI, "ti"}, {KS_TE, "te"},
1035: {0, NULL}
1036: };
1037:
1038: /*
1039: * If the external termcap does not have a matching entry, try the
1040: * builtin ones.
1041: */
1042: if ((error_msg = tgetent_error(tbuf, term)) == NULL)
1043: {
1044: if (!termcap_cleared)
1045: {
1046: clear_termoptions(); /* clear old options */
1047: termcap_cleared = TRUE;
1048: }
1049:
1050: /* get output strings */
1051: for (i = 0; string_names[i].name != NULL; ++i)
1052: {
1053: if (term_strings[string_names[i].dest] == NULL ||
1054: term_strings[string_names[i].dest] == empty_option)
1055: term_strings[string_names[i].dest] =
1056: TGETSTR(string_names[i].name, &tp);
1057: }
1058:
1059: if ((T_MS == NULL || T_MS == empty_option) && tgetflag("ms"))
1060: T_MS = (char_u *)"yes";
1061: if ((T_DB == NULL || T_DB == empty_option) && tgetflag("db"))
1062: T_DB = (char_u *)"yes";
1063: if ((T_DA == NULL || T_DA == empty_option) && tgetflag("da"))
1064: T_DA = (char_u *)"yes";
1065:
1066:
1067: /* get key codes */
1068:
1069: for (i = 0; key_names[i] != NULL; ++i)
1070: {
1071: if (find_termcode((char_u *)key_names[i]) == NULL)
1072: add_termcode((char_u *)key_names[i],
1073: TGETSTR(key_names[i], &tp));
1074: }
1075:
1076: /* if cursor-left == backspace, ignore it (televideo 925) */
1077: if (find_termcode((char_u *)"kl") == NULL)
1078: {
1079: p = TGETSTR("kl", &tp);
1080: if (p != NULL && *p != Ctrl('H'))
1081: add_termcode((char_u *)"kl", p);
1082: }
1083:
1084: if (height == 0)
1085: height = tgetnum("li");
1086: if (width == 0)
1087: width = tgetnum("co");
1088:
1089: # ifndef hpux
1090: BC = (char *)TGETSTR("bc", &tp);
1091: UP = (char *)TGETSTR("up", &tp);
1092: p = TGETSTR("pc", &tp);
1093: if (p)
1094: PC = *p;
1095: # endif /* hpux */
1096: }
1097: }
1098: else /* try == 0 || try == 2 */
1099: #endif /* HAVE_TGETENT */
1100: /*
1101: * Use builtin termcap
1102: */
1103: {
1104: #ifdef HAVE_TGETENT
1105: /*
1106: * If builtin termcap was already used, there is no need to search
1107: * for the builtin termcap again, quit now.
1108: */
1109: if (try == 2 && builtin_first && termcap_cleared)
1110: break;
1111: #endif
1112: /*
1113: * search for 'term' in builtin_termcaps[]
1114: */
1115: termp = find_builtin_term(term);
1116: if (termp->bt_string == NULL) /* did not find it */
1117: {
1118: #ifdef HAVE_TGETENT
1119: /*
1120: * If try == 0, first try the external termcap. If that is not
1121: * found we'll get back here with try == 2.
1122: * If termcap_cleared is set we used the external termcap,
1123: * don't complain about not finding the term in the builtin
1124: * termcap.
1125: */
1126: if (try == 0) /* try external one */
1127: continue;
1128: if (termcap_cleared) /* found in external termcap */
1129: break;
1130: #endif
1131:
1132: fprintf(stderr, "\r\n");
1133: if (error_msg != NULL)
1134: {
1135: fprintf(stderr, (char *)error_msg);
1136: fprintf(stderr, "\r\n");
1137: }
1138: fprintf(stderr, "'%s' not known. Available builtin terminals are:\r\n", term);
1139: for (termp = &(builtin_termcaps[0]); termp->bt_string != NULL;
1140: ++termp)
1141: {
1142: if (termp->bt_entry == KS_NAME)
1143: #ifdef HAVE_TGETENT
1144: fprintf(stderr, " builtin_%s\r\n", termp->bt_string);
1145: #else
1146: fprintf(stderr, " %s\r\n", termp->bt_string);
1147: #endif
1148: }
1149: if (!starting) /* when user typed :set term=xxx, quit here */
1150: {
1151: screen_start(); /* don't know where cursor is now */
1152: wait_return(TRUE);
1153: return FAIL;
1154: }
1155: term = DEFAULT_TERM;
1156: fprintf(stderr, "defaulting to '%s'\r\n", term);
1157: screen_start(); /* don't know where cursor is now */
1158: mch_delay(2000L, TRUE);
1159: set_string_option((char_u *)"term", -1, term, TRUE);
1160: }
1161: flushbuf();
1162: #ifdef HAVE_TGETENT
1163: if (!termcap_cleared)
1164: {
1165: #endif
1166: clear_termoptions(); /* clear old options */
1167: #ifdef HAVE_TGETENT
1168: termcap_cleared = TRUE;
1169: }
1170: #endif
1171: parse_builtin_tcap(term);
1172: #ifdef USE_GUI
1173: if (STRCMP(term, "gui") == 0)
1174: {
1175: flushbuf();
1176: settmode(0);
1177: gui_init();
1178: if (!gui.in_use) /* failed to start GUI */
1179: settmode(1);
1180: }
1181: #endif /* USE_GUI */
1182: }
1183: #ifdef HAVE_TGETENT
1184: }
1185: #endif
1186:
1187: /*
1188: * special: There is no info in the termcap about whether the cursor
1189: * positioning is relative to the start of the screen or to the start of the
1190: * scrolling region. We just guess here. Only msdos pcterm is known to do it
1191: * relative.
1192: */
1193: if (STRCMP(term, "pcterm") == 0)
1194: T_CSC = (char_u *)"yes";
1195: else
1196: T_CSC = empty_option;
1197:
1198: #ifdef UNIX
1199: /*
1200: * Any "stty" settings override the default for t_kb from the termcap.
1201: * This is in unix.c, because it depends a lot on the version of unix that is
1202: * being used.
1203: * Don't do this when the GUI is active, it uses "t_kb" and "t_kD" directly.
1204: */
1205: #ifdef USE_GUI
1206: if (!gui.in_use)
1207: #endif
1208: get_stty();
1209: #endif
1210:
1211: /*
1212: * If the termcap has no entry for 'bs' and/or 'del' and the ioctl() also
1213: * didn't work, use the default CTRL-H
1214: * The default for t_kD is DEL, unless t_kb is DEL.
1215: * The strsave'd strings are probably lost forever, well it's only two bytes.
1216: * Don't do this when the GUI is active, it uses "t_kb" and "t_kD" directly.
1217: */
1218: #ifdef USE_GUI
1219: if (!gui.in_use)
1220: #endif
1221: {
1222: bs_p = find_termcode((char_u *)"kb");
1223: del_p = find_termcode((char_u *)"kD");
1224: if (bs_p == NULL || *bs_p == NUL)
1225: add_termcode((char_u *)"kb", (bs_p = (char_u *)"\010"));
1226: if ((del_p == NULL || *del_p == NUL) &&
1227: (bs_p == NULL || *bs_p != '\177'))
1228: add_termcode((char_u *)"kD", (char_u *)"\177");
1229: }
1230:
1231: #ifdef USE_MOUSE
1232: /*
1233: * recognize mouse events in the input stream for xterm, msdos and win32
1234: */
1235: {
1236: char_u name[2];
1237:
1238: name[0] = KS_MOUSE;
1239: name[1] = K_FILLER;
1240: # ifdef UNIX
1241: if (is_xterm(term))
1242: add_termcode(name, (char_u *)"\033[M");
1243: # else
1244: add_termcode(name, (char_u *)"\233M");
1245: # endif
1246: }
1247: #endif
1248:
1249: #if defined(AMIGA) || defined(MSDOS) || defined(WIN32) || defined(OS2)
1250: /* DEFAULT_TERM indicates that it is the machine console. */
1251: if (STRCMP(term, DEFAULT_TERM))
1252: term_console = FALSE;
1253: else
1254: {
1255: term_console = TRUE;
1256: # ifdef AMIGA
1257: win_resize_on(); /* enable window resizing reports */
1258: # endif
1259: }
1260: #endif
1261:
1262: #ifdef UNIX
1263: /*
1264: * 'ttyfast' is default on for xterm, iris-ansi and a few others.
1265: */
1266: if (is_fastterm(term))
1267: p_tf = TRUE;
1268: #endif
1269: #if defined(AMIGA) || defined(MSDOS) || defined(WIN32) || defined(OS2)
1270: /*
1271: * 'ttyfast' is default on Amiga, MSDOS, Win32, and OS/2 consoles
1272: */
1273: if (term_console)
1274: p_tf = TRUE;
1275: #endif
1276:
1277: ttest(TRUE); /* make sure we have a valid set of terminal codes */
1278: set_term_defaults(); /* use current values as defaults */
1279:
1280: /*
1281: * Initialize the terminal with the appropriate termcap codes.
1282: * Set the mouse and window title if possible.
1283: * Don't do this when starting, need to parse the .vimrc first, because it
1284: * may redefine t_TI etc.
1285: */
1286: if (!starting)
1287: {
1288: starttermcap(); /* may change terminal mode */
1289: #ifdef USE_MOUSE
1290: setmouse(); /* may start using the mouse */
1291: #endif
1292: maketitle(); /* may display window title */
1293: }
1294:
1295: /* display initial screen after ttest() checking. jw. */
1296: if (width <= 0 || height <= 0)
1297: {
1298: /* termcap failed to report size */
1299: /* set defaults, in case mch_get_winsize also fails */
1300: width = 80;
1301: #if defined MSDOS || defined WIN32
1302: height = 25; /* console is often 25 lines */
1303: #else
1304: height = 24; /* most terminals are 24 lines */
1305: #endif
1306: }
1307: set_winsize(width, height, FALSE); /* may change Rows */
1308: if (!starting)
1309: {
1310: if (scroll_region)
1311: scroll_region_reset(); /* In case Rows changed */
1312: check_map_keycodes(); /* check mappings for terminal codes used */
1313: }
1314:
1315: return OK;
1316: }
1317:
1318: #ifdef HAVE_TGETENT
1319: /*
1320: * Call tgetent()
1321: * Return error message if it fails, NULL if it's OK.
1322: */
1323: static char_u *
1324: tgetent_error(tbuf, term)
1325: char_u *tbuf;
1326: char_u *term;
1327: {
1328: int i;
1329:
1330: i = TGETENT(tbuf, term);
1331: if (i == -1)
1332: return (char_u *)"Cannot open termcap file";
1333: if (i == 0)
1334: #ifdef TERMINFO
1335: return (char_u *)"Terminal entry not found in terminfo";
1336: #else
1337: return (char_u *)"Terminal entry not found in termcap";
1338: #endif
1339: return NULL;
1340: }
1341: #endif /* HAVE_TGETENT */
1342:
1343: #if defined(HAVE_TGETENT) && (defined(UNIX) || defined(__EMX__))
1344: /*
1345: * Get Columns and Rows from the termcap. Used after a window signal if the
1346: * ioctl() fails. It doesn't make sense to call tgetent each time if the "co"
1347: * and "li" entries never change. But on some systems this works.
1348: * Errors while getting the entries are ignored.
1349: */
1350: void
1351: getlinecol()
1352: {
1353: char_u tbuf[TBUFSZ];
1354:
1355: if (term_strings[KS_NAME] != NULL && TGETENT(tbuf, term_strings[KS_NAME]) > 0)
1356: {
1357: if (Columns == 0)
1358: Columns = tgetnum("co");
1359: if (Rows == 0)
1360: Rows = tgetnum("li");
1361: }
1362: }
1363: #endif /* defined(HAVE_TGETENT) && defined(UNIX) */
1364:
1365: /*
1366: * Get a string entry from the termcap and add it to the list of termcodes.
1367: * Used for <t_xx> special keys.
1368: * Give an error message for failure when not sourcing.
1369: * If force given, replace an existing entry.
1370: * Return FAIL if the entry was not found, OK if the entry was added.
1371: */
1372: int
1373: add_termcap_entry(name, force)
1374: char_u *name;
1375: int force;
1376: {
1377: char_u *term;
1378: int key;
1379: struct builtin_term *termp;
1380: #ifdef HAVE_TGETENT
1381: char_u *string;
1382: int i;
1383: int builtin_first;
1384: char_u tbuf[TBUFSZ];
1385: char_u tstrbuf[TBUFSZ];
1386: char_u *tp = tstrbuf;
1387: char_u *error_msg = NULL;
1388: #endif
1389:
1390: /*
1391: * If the GUI is running or will start in a moment, we only support the keys
1392: * that the GUI can produce.
1393: */
1394: #ifdef USE_GUI
1395: if (gui.in_use || gui.starting)
1396: return gui_mch_haskey(name);
1397: #endif
1398:
1399: if (!force && find_termcode(name) != NULL) /* it's already there */
1400: return OK;
1401:
1402: term = term_strings[KS_NAME];
1403: if (term == NULL) /* just in case */
1404: return FAIL;
1405:
1406: if (is_builtin_term(term)) /* name starts with "builtin_" */
1407: {
1408: term += 8;
1409: #ifdef HAVE_TGETENT
1410: builtin_first = TRUE;
1411: #endif
1412: }
1413: #ifdef HAVE_TGETENT
1414: else
1415: builtin_first = p_tbi;
1416: #endif
1417:
1418: #ifdef HAVE_TGETENT
1419: /*
1420: * We can get the entry from the builtin termcap and from the external one.
1421: * If 'ttybuiltin' is on or the terminal name starts with "builtin_", try
1422: * builtin termcap first.
1423: * If 'ttybuiltin' is off, try external termcap first.
1424: */
1425: for (i = 0; i < 2; ++i)
1426: {
1427: if (!builtin_first == i)
1428: #endif
1429: /*
1430: * Search in builtin termcap
1431: */
1432: {
1433: termp = find_builtin_term(term);
1434: if (termp->bt_string != NULL) /* found it */
1435: {
1436: key = TERMCAP2KEY(name[0], name[1]);
1437: while (termp->bt_entry != KS_NAME)
1438: {
1439: if (termp->bt_entry == key)
1440: {
1441: add_termcode(name, (char_u *)termp->bt_string);
1442: return OK;
1443: }
1444: ++termp;
1445: }
1446: }
1447: }
1448: #ifdef HAVE_TGETENT
1449: else
1450: /*
1451: * Search in external termcap
1452: */
1453: {
1454: error_msg = tgetent_error(tbuf, term);
1455: if (error_msg == NULL)
1456: {
1457: string = TGETSTR((char *)name, &tp);
1458: if (string != NULL && *string != NUL)
1459: {
1460: add_termcode(name, string);
1461: return OK;
1462: }
1463: }
1464: }
1465: }
1466: #endif
1467:
1468: if (sourcing_name == NULL)
1469: {
1470: #ifdef HAVE_TGETENT
1471: if (error_msg != NULL)
1472: EMSG(error_msg);
1473: else
1474: #endif
1475: EMSG2("No \"%s\" entry in termcap", name);
1476: }
1477: return FAIL;
1478: }
1479:
1480: static int
1481: is_builtin_term(name)
1482: char_u *name;
1483: {
1484: return (STRNCMP(name, "builtin_", (size_t)8) == 0);
1485: }
1486:
1487: static char_u *tltoa __PARMS((unsigned long));
1488:
1489: static char_u *
1490: tltoa(i)
1491: unsigned long i;
1492: {
1493: static char_u buf[16];
1494: char_u *p;
1495:
1496: p = buf + 15;
1497: *p = '\0';
1498: do
1499: {
1500: --p;
1501: *p = (char_u) (i % 10 + '0');
1502: i /= 10;
1503: }
1504: while (i > 0 && p > buf);
1505: return p;
1506: }
1507:
1508: #ifndef HAVE_TGETENT
1509:
1510: /*
1511: * minimal tgoto() implementation.
1512: * no padding and we only parse for %i %d and %+char
1513: */
1514: char *tgoto __ARGS((char *, int, int));
1515:
1516: char *
1517: tgoto(cm, x, y)
1518: char *cm;
1519: int x, y;
1520: {
1521: static char buf[30];
1522: char *p, *s, *e;
1523:
1524: if (!cm)
1525: return "OOPS";
1526: e = buf + 29;
1527: for (s = buf; s < e && *cm; cm++)
1528: {
1529: if (*cm != '%')
1530: {
1531: *s++ = *cm;
1532: continue;
1533: }
1534: switch (*++cm)
1535: {
1536: case 'd':
1537: p = (char *)tltoa((unsigned long)y);
1538: y = x;
1539: while (*p)
1540: *s++ = *p++;
1541: break;
1542: case 'i':
1543: x++;
1544: y++;
1545: break;
1546: case '+':
1547: *s++ = (char)(*++cm + y);
1548: y = x;
1549: break;
1550: case '%':
1551: *s++ = *cm;
1552: break;
1553: default:
1554: return "OOPS";
1555: }
1556: }
1557: *s = '\0';
1558: return buf;
1559: }
1560:
1561: #endif /* HAVE_TGETENT */
1562:
1563: /*
1564: * Set the terminal name to "term" and initialize the terminal options.
1565: * If "term" is NULL or empty, get the terminal name from the environment.
1566: * If that fails, use the default terminal name.
1567: */
1568: void
1569: termcapinit(term)
1570: char_u *term;
1571: {
1572: if (!term || !*term)
1573: term = vim_getenv((char_u *)"TERM");
1574: if (!term || !*term)
1575: term = DEFAULT_TERM;
1576: set_string_option((char_u *)"term", -1, term, TRUE);
1577: /*
1578: * Avoid using "term" here, because the next vim_getenv() may overwrite it.
1579: */
1580: set_termname(term_strings[KS_NAME] != NULL ? term_strings[KS_NAME] : term);
1581: }
1582:
1583: /*
1584: * the number of calls to mch_write is reduced by using the buffer "outbuf"
1585: */
1586: #undef BSIZE /* hpux has BSIZE in sys/option.h */
1587: #define BSIZE 2048
1588: static char_u outbuf[BSIZE];
1589: static int bpos = 0; /* number of chars in outbuf */
1590:
1591: /*
1592: * flushbuf(): flush the output buffer
1593: */
1594: void
1595: flushbuf()
1596: {
1597: if (bpos != 0)
1598: {
1599: mch_write(outbuf, bpos);
1600: bpos = 0;
1601: }
1602: }
1603:
1604: #ifdef USE_GUI
1605: /*
1606: * trash_output_buf(): Throw away the contents of the output buffer
1607: */
1608: void
1609: trash_output_buf()
1610: {
1611: bpos = 0;
1612: }
1613: #endif
1614:
1615: /*
1616: * outchar(c): put a character into the output buffer.
1617: * Flush it if it becomes full.
1618: * This should not be used for outputting text on the screen (use functions like
1619: * msg_outstr() and screen_outchar() for that).
1620: */
1621: void
1622: outchar(c)
1623: unsigned c;
1624: {
1625: #if defined(UNIX) || defined(VMS) || defined(AMIGA)
1626: if (c == '\n') /* turn LF into CR-LF (CRMOD doesn't seem to do this) */
1627: outchar('\r');
1628: #endif
1629:
1630: outbuf[bpos++] = c;
1631:
1632: /* For testing we flush each time. */
1633: if (bpos >= BSIZE || p_wd)
1634: flushbuf();
1635: }
1636:
1637: static void outchar_nf __ARGS((unsigned));
1638:
1639: /*
1640: * outchar_nf(c): like outchar(), but don't flush when p_wd is set
1641: */
1642: static void
1643: outchar_nf(c)
1644: unsigned c;
1645: {
1646: #if defined(UNIX) || defined(VMS) || defined(AMIGA)
1647: if (c == '\n') /* turn LF into CR-LF (CRMOD doesn't seem to do this) */
1648: outchar_nf('\r');
1649: #endif
1650:
1651: outbuf[bpos++] = c;
1652:
1653: /* For testing we flush each time. */
1654: if (bpos >= BSIZE)
1655: flushbuf();
1656: }
1657:
1658: /*
1659: * a never-padding outstr.
1660: * use this whenever you don't want to run the string through tputs.
1661: * tputs above is harmless, but tputs from the termcap library
1662: * is likely to strip off leading digits, that it mistakes for padding
1663: * information. (jw)
1664: * This should only be used for writing terminal codes, not for outputting
1665: * normal text (use functions like msg_outstr() and screen_outchar() for that).
1666: */
1667: void
1668: outstrn(s)
1669: char_u *s;
1670: {
1671: if (bpos > BSIZE - 20) /* avoid terminal strings being split up */
1672: flushbuf();
1673: while (*s)
1674: outchar_nf(*s++);
1675:
1676: /* For testing we write one string at a time. */
1677: if (p_wd)
1678: flushbuf();
1679: }
1680:
1681: /*
1682: * outstr(s): put a string character at a time into the output buffer.
1683: * If HAVE_TGETENT is defined use the termcap parser. (jw)
1684: * This should only be used for writing terminal codes, not for outputting
1685: * normal text (use functions like msg_outstr() and screen_outchar() for that).
1686: */
1687: void
1688: outstr(s)
1689: register char_u *s;
1690: {
1691: if (bpos > BSIZE - 20) /* avoid terminal strings being split up */
1692: flushbuf();
1693: if (s)
1694: #ifdef HAVE_TGETENT
1695: tputs((char *)s, 1, TPUTSFUNCAST outchar_nf);
1696: #else
1697: while (*s)
1698: outchar_nf(*s++);
1699: #endif
1700:
1701: /* For testing we write one string at a time. */
1702: if (p_wd)
1703: flushbuf();
1704: }
1705:
1706: /*
1707: * cursor positioning using termcap parser. (jw)
1708: */
1709: void
1710: windgoto(row, col)
1711: int row;
1712: int col;
1713: {
1714: if (col != screen_cur_col || row != screen_cur_row)
1715: {
1716: /*
1717: * When positioning on the same row, column 0, use CR, it's just one
1718: * character. Don't do this when the cursor has moved past the end of
1719: * the line, the cursor position is undefined then.
1720: */
1721: if (row == screen_cur_row && col == 0 && screen_cur_col < Columns)
1722: {
1723: outchar('\r');
1724: screen_cur_col = 0;
1725: }
1726: else
1727: {
1728: OUTSTR(tgoto((char *)T_CM, col, row));
1729: screen_cur_col = col;
1730: screen_cur_row = row;
1731: }
1732: }
1733: }
1734:
1735: /*
1736: * Set cursor to current position.
1737: */
1738:
1739: void
1740: setcursor()
1741: {
1742: if (!RedrawingDisabled)
1743: windgoto(curwin->w_winpos + curwin->w_row,
1744: #ifdef RIGHTLEFT
1745: curwin->w_p_rl ? (int)Columns - 1 - curwin->w_col :
1746: #endif
1747: curwin->w_col);
1748: }
1749:
1750: /*
1751: * Make sure we have a valid set or terminal options.
1752: * Replace all entries that are NULL by empty_option
1753: */
1754: void
1755: ttest(pairs)
1756: int pairs;
1757: {
1758: char *t = NULL;
1759:
1760: check_options(); /* make sure no options are NULL */
1761:
1762: /* hard requirements */
1763: if (*T_CL == NUL) /* erase display */
1764: t = "cl";
1765: if (*T_CM == NUL) /* cursor motion */
1766: t = "cm";
1767:
1768: if (t)
1769: EMSG2("terminal capability %s required", t);
1770:
1771: /*
1772: * if "cs" defined, use a scroll region, it's faster.
1773: */
1774: if (*T_CS != NUL)
1775: scroll_region = TRUE;
1776: else
1777: scroll_region = FALSE;
1778:
1779: if (pairs)
1780: {
1781: /* optional pairs */
1782: /* TP goes to normal mode for TI (invert) and TB (bold) */
1783: if (*T_ME == NUL)
1784: T_ME = T_MR = T_MD = empty_option;
1785: if (*T_SO == NUL || *T_SE == NUL)
1786: T_SO = T_SE = empty_option;
1787: if (*T_US == NUL || *T_UE == NUL)
1788: T_US = T_UE = empty_option;
1789: if (*T_CZH == NUL || *T_CZR == NUL)
1790: T_CZH = T_CZR = empty_option;
1791: /* T_VE is needed even though T_VI is not defined */
1792: if (*T_VE == NUL)
1793: T_VI = empty_option;
1794: /* if 'mr' or 'me' is not defined use 'so' and 'se' */
1795: if (*T_ME == NUL)
1796: {
1797: T_ME = T_SE;
1798: T_MR = T_SO;
1799: T_MD = T_SO;
1800: }
1801: /* if 'so' or 'se' is not defined use 'mr' and 'me' */
1802: if (*T_SO == NUL)
1803: {
1804: T_SE = T_ME;
1805: if (*T_MR == NUL)
1806: T_SO = T_MD;
1807: else
1808: T_SO = T_MR;
1809: }
1810: /* if 'ZH' or 'ZR' is not defined use 'mr' and 'me' */
1811: if (*T_CZH == NUL)
1812: {
1813: T_CZR = T_ME;
1814: if (*T_MR == NUL)
1815: T_CZH = T_MD;
1816: else
1817: T_CZH = T_MR;
1818: }
1819: }
1820: need_gather = TRUE;
1821: }
1822:
1823: /*
1824: * Represent the given long_u as individual bytes, with the most significant
1825: * byte first, and store them in dst.
1826: */
1827: void
1828: add_long_to_buf(val, dst)
1829: long_u val;
1830: char_u *dst;
1831: {
1832: int i;
1833: int shift;
1834:
1835: for (i = 1; i <= sizeof(long_u); i++)
1836: {
1837: shift = 8 * (sizeof(long_u) - i);
1838: dst[i - 1] = (char_u) ((val >> shift) & 0xff);
1839: }
1840: }
1841:
1842: /*
1843: * Interpret the next string of bytes in buf as a long integer, with the most
1844: * significant byte first. Note that it is assumed that buf has been through
1845: * inchar(), so that NUL and K_SPECIAL will be represented as three bytes each.
1846: * Puts result in val, and returns the number of bytes read from buf
1847: * (between sizeof(long_u) and 2 * sizeof(long_u)), or -1 if not enough bytes
1848: * were present.
1849: */
1850: int
1851: get_long_from_buf(buf, val)
1852: char_u *buf;
1853: long_u *val;
1854: {
1855: int len;
1856: char_u bytes[sizeof(long_u)];
1857: int i;
1858: int shift;
1859:
1860: *val = 0;
1861: len = get_bytes_from_buf(buf, bytes, (int)sizeof(long_u));
1862: if (len != -1)
1863: {
1864: for (i = 0; i < sizeof(long_u); i++)
1865: {
1866: shift = 8 * (sizeof(long_u) - 1 - i);
1867: *val += (long_u)bytes[i] << shift;
1868: }
1869: }
1870: return len;
1871: }
1872:
1873: /*
1874: * Read the next num_bytes bytes from buf, and store them in bytes. Assume
1875: * that buf has been through inchar(). Returns the actual number of bytes used
1876: * from buf (between num_bytes and num_bytes*2), or -1 if not enough bytes were
1877: * available.
1878: */
1879: static int
1880: get_bytes_from_buf(buf, bytes, num_bytes)
1881: char_u *buf;
1882: char_u *bytes;
1883: int num_bytes;
1884: {
1885: int len = 0;
1886: int i;
1887: char_u c;
1888:
1889: for (i = 0; i < num_bytes; i++)
1890: {
1891: if ((c = buf[len++]) == NUL)
1892: return -1;
1893: if (c == K_SPECIAL)
1894: {
1895: if (buf[len] == NUL || buf[len + 1] == NUL) /* cannot happen? */
1896: return -1;
1897: if (buf[len++] == KS_ZERO)
1898: c = NUL;
1899: ++len; /* skip K_FILLER */
1900: /* else it should be KS_SPECIAL, and c already equals K_SPECIAL */
1901: }
1902: bytes[i] = c;
1903: }
1904: return len;
1905: }
1906:
1907: /*
1908: * outnum - output a (big) number fast
1909: */
1910: void
1911: outnum(n)
1912: register long n;
1913: {
1914: OUTSTRN(tltoa((unsigned long)n));
1915: }
1916:
1917: void
1918: check_winsize()
1919: {
1920: static int old_Rows = 0;
1921:
1922: if (Columns < MIN_COLUMNS)
1923: Columns = MIN_COLUMNS;
1924: if (Rows < min_rows()) /* need room for one window and command line */
1925: Rows = min_rows();
1926:
1927: if (old_Rows != Rows)
1928: {
1929: old_Rows = Rows;
1930: screen_new_rows(); /* may need to update window sizes */
1931: }
1932: }
1933:
1934: /*
1935: * set window size
1936: * If 'mustset' is TRUE, we must set Rows and Columns, do not get real
1937: * window size (this is used for the :win command).
1938: * If 'mustset' is FALSE, we may try to get the real window size and if
1939: * it fails use 'width' and 'height'.
1940: */
1941: void
1942: set_winsize(width, height, mustset)
1943: int width, height;
1944: int mustset;
1945: {
1946: register int tmp;
1947:
1948: if (width < 0 || height < 0) /* just checking... */
1949: return;
1950:
1951: /* postpone the resizing */
1952: if (State == HITRETURN || State == SETWSIZE)
1953: {
1954: State = SETWSIZE;
1955: return;
1956: }
1957: if (State != ASKMORE && State != EXTERNCMD)
1958: screenclear();
1959: else
1960: screen_start(); /* don't know where cursor is now */
1961: #ifdef AMIGA
1962: flushbuf(); /* must do this before mch_get_winsize for some
1963: obscure reason */
1964: #endif /* AMIGA */
1965: if (mustset || (mch_get_winsize() == FAIL && height != 0))
1966: {
1967: Rows = height;
1968: Columns = width;
1969: check_winsize(); /* always check, to get p_scroll right */
1970: mch_set_winsize();
1971: }
1972: else
1973: check_winsize(); /* always check, to get p_scroll right */
1974: if (!starting)
1975: {
1976: comp_Botline_all();
1977: if (State == ASKMORE || State == EXTERNCMD)
1978: {
1979: screenalloc(FALSE); /* don't redraw, just adjust screen size */
1980: if (State == ASKMORE)
1981: {
1982: msg_moremsg(FALSE); /* display --more-- message again */
1983: msg_row = Rows - 1;
1984: }
1985: else
1986: windgoto(msg_row, msg_col); /* put cursor back */
1987: }
1988: else
1989: {
1990: tmp = RedrawingDisabled;
1991: RedrawingDisabled = FALSE;
1992: updateScreen(CURSUPD);
1993: RedrawingDisabled = tmp;
1994: if (State == CMDLINE)
1995: redrawcmdline();
1996: else
1997: setcursor();
1998: }
1999: }
2000: flushbuf();
2001: }
2002:
2003: void
2004: settmode(raw)
2005: int raw;
2006: {
2007: static int oldraw = FALSE;
2008:
2009: #ifdef USE_GUI
2010: /* don't set the term where gvim was started in raw mode */
2011: if (gui.in_use)
2012: return;
2013: #endif
2014: if (full_screen)
2015: {
2016: /*
2017: * When returning after calling a shell we want to really set the
2018: * terminal to raw mode, even though we think it already is, because
2019: * the shell program may have reset the terminal mode.
2020: * When we think the terminal is not-raw, don't try to set it to
2021: * not-raw again, because that causes problems (logout!) on some
2022: * machines.
2023: */
2024: if (raw || oldraw)
2025: {
2026: flushbuf();
2027: mch_settmode(raw); /* machine specific function */
2028: #ifdef USE_MOUSE
2029: if (!raw)
2030: mch_setmouse(FALSE); /* switch mouse off */
2031: else
2032: setmouse(); /* may switch mouse on */
2033: #endif
2034: flushbuf();
2035: oldraw = raw;
2036: }
2037: }
2038: }
2039:
2040: void
2041: starttermcap()
2042: {
2043: if (full_screen && !termcap_active)
2044: {
2045: outstr(T_TI); /* start termcap mode */
2046: outstr(T_KS); /* start "keypad transmit" mode */
2047: flushbuf();
2048: termcap_active = TRUE;
2049: screen_start(); /* don't know where cursor is now */
2050: }
2051: }
2052:
2053: void
2054: stoptermcap()
2055: {
2056: if (full_screen && termcap_active)
2057: {
2058: outstr(T_KE); /* stop "keypad transmit" mode */
2059: flushbuf();
2060: termcap_active = FALSE;
2061: cursor_on(); /* just in case it is still off */
2062: outstr(T_TE); /* stop termcap mode */
2063: screen_start(); /* don't know where cursor is now */
2064: }
2065: }
2066:
2067: #ifdef USE_MOUSE
2068: /*
2069: * setmouse() - switch mouse on/off depending on current mode and 'mouse'
2070: */
2071: void
2072: setmouse()
2073: {
2074: int checkfor;
2075:
2076: # ifdef USE_GUI
2077: if (gui.in_use)
2078: return;
2079: # endif
2080: if (*p_mouse == NUL) /* be quick when mouse is off */
2081: return;
2082:
2083: if (VIsual_active)
2084: checkfor = MOUSE_VISUAL;
2085: else if (State == HITRETURN)
2086: checkfor = MOUSE_RETURN;
2087: else if (State & INSERT)
2088: checkfor = MOUSE_INSERT;
2089: else if (State & CMDLINE)
2090: checkfor = MOUSE_COMMAND;
2091: else
2092: checkfor = MOUSE_NORMAL; /* assume normal mode */
2093:
2094: if (mouse_has(checkfor))
2095: mch_setmouse(TRUE);
2096: else
2097: mch_setmouse(FALSE);
2098: }
2099:
2100: /*
2101: * Return TRUE if
2102: * - "c" is in 'mouse', or
2103: * - 'a' is in 'mouse' and "c" is in MOUSE_A, or
2104: * - the current buffer is a help file and 'h' is in 'mouse' and we are in a
2105: * normal editing mode (not at hit-return message).
2106: */
2107: int
2108: mouse_has(c)
2109: int c;
2110: {
2111: return (vim_strchr(p_mouse, c) != NULL ||
2112: (vim_strchr(p_mouse, 'a') != NULL &&
2113: vim_strchr((char_u *)MOUSE_A, c) != NULL) ||
2114: (c != MOUSE_RETURN && curbuf->b_help &&
2115: vim_strchr(p_mouse, MOUSE_HELP)));
2116: }
2117: #endif
2118:
2119: /*
2120: * By outputting the 'cursor very visible' termcap code, for some windowed
2121: * terminals this makes the screen scrolled to the correct position.
2122: * Used when starting Vim or returning from a shell.
2123: */
2124: void
2125: scroll_start()
2126: {
2127: if (*T_VS != NUL)
2128: {
2129: outstr(T_VS);
2130: outstr(T_VE);
2131: screen_start(); /* don't know where cursor is now */
2132: }
2133: }
2134:
2135: /*
2136: * enable cursor, unless in Visual mode or no inversion possible
2137: */
2138: static int cursor_is_off = FALSE;
2139:
2140: void
2141: cursor_on()
2142: {
2143: if (full_screen)
2144: {
2145: if (cursor_is_off && (!VIsual_active || highlight == NULL))
2146: {
2147: outstr(T_VE);
2148: cursor_is_off = FALSE;
2149: }
2150: }
2151: }
2152:
2153: void
2154: cursor_off()
2155: {
2156: if (full_screen)
2157: {
2158: if (!cursor_is_off)
2159: outstr(T_VI); /* disable cursor */
2160: cursor_is_off = TRUE;
2161: }
2162: }
2163:
2164: /*
2165: * Set scrolling region for window 'wp'.
2166: * The region starts 'off' lines from the start of the window.
2167: */
2168: void
2169: scroll_region_set(wp, off)
2170: WIN *wp;
2171: int off;
2172: {
2173: OUTSTR(tgoto((char *)T_CS, wp->w_winpos + wp->w_height - 1,
2174: wp->w_winpos + off));
2175: screen_start(); /* don't know where cursor is now */
2176: }
2177:
2178: /*
2179: * Reset scrolling region to the whole screen.
2180: */
2181: void
2182: scroll_region_reset()
2183: {
2184: OUTSTR(tgoto((char *)T_CS, (int)Rows - 1, 0));
2185: screen_start(); /* don't know where cursor is now */
2186: }
2187:
2188:
2189: /*
2190: * List of terminal codes that are currently recognized.
2191: */
2192:
2193: struct termcode
2194: {
2195: char_u name[2]; /* termcap name of entry */
2196: char_u *code; /* terminal code (in allocated memory) */
2197: int len; /* STRLEN(code) */
2198: } *termcodes = NULL;
2199:
2200: static int tc_max_len = 0; /* number of entries that termcodes[] can hold */
2201: static int tc_len = 0; /* current number of entries in termcodes[] */
2202:
2203: void
2204: clear_termcodes()
2205: {
2206: while (tc_len > 0)
2207: vim_free(termcodes[--tc_len].code);
2208: vim_free(termcodes);
2209: termcodes = NULL;
2210: tc_max_len = 0;
2211:
2212: #ifdef HAVE_TGETENT
2213: BC = (char *)empty_option;
2214: UP = (char *)empty_option;
2215: PC = ' '; /* set pad character to space */
2216: ospeed = 0;
2217: #endif
2218:
2219: need_gather = TRUE; /* need to fill termleader[] */
2220: }
2221:
2222: /*
2223: * Add a new entry to the list of terminal codes.
2224: * The list is kept alphabetical for ":set termcap"
2225: */
2226: void
2227: add_termcode(name, string)
2228: char_u *name;
2229: char_u *string;
2230: {
2231: struct termcode *new_tc;
2232: int i, j;
2233: char_u *s;
2234:
2235: if (string == NULL || *string == NUL)
2236: {
2237: del_termcode(name);
2238: return;
2239: }
2240:
2241: s = strsave(string);
2242: if (s == NULL)
2243: return;
2244:
2245: need_gather = TRUE; /* need to fill termleader[] */
2246:
2247: /*
2248: * need to make space for more entries
2249: */
2250: if (tc_len == tc_max_len)
2251: {
2252: tc_max_len += 20;
2253: new_tc = (struct termcode *)alloc(
2254: (unsigned)(tc_max_len * sizeof(struct termcode)));
2255: if (new_tc == NULL)
2256: {
2257: tc_max_len -= 20;
2258: return;
2259: }
2260: for (i = 0; i < tc_len; ++i)
2261: new_tc[i] = termcodes[i];
2262: vim_free(termcodes);
2263: termcodes = new_tc;
2264: }
2265:
2266: /*
2267: * Look for existing entry with the same name, it is replaced.
2268: * Look for an existing entry that is alphabetical higher, the new entry
2269: * is inserted in front of it.
2270: */
2271: for (i = 0; i < tc_len; ++i)
2272: {
2273: if (termcodes[i].name[0] < name[0])
2274: continue;
2275: if (termcodes[i].name[0] == name[0])
2276: {
2277: if (termcodes[i].name[1] < name[1])
2278: continue;
2279: /*
2280: * Exact match: Replace old code.
2281: */
2282: if (termcodes[i].name[1] == name[1])
2283: {
2284: vim_free(termcodes[i].code);
2285: --tc_len;
2286: break;
2287: }
2288: }
2289: /*
2290: * Found alphabetical larger entry, move rest to insert new entry
2291: */
2292: for (j = tc_len; j > i; --j)
2293: termcodes[j] = termcodes[j - 1];
2294: break;
2295: }
2296:
2297: termcodes[i].name[0] = name[0];
2298: termcodes[i].name[1] = name[1];
2299: termcodes[i].code = s;
2300: termcodes[i].len = STRLEN(s);
2301: ++tc_len;
2302: }
2303:
2304: char_u *
2305: find_termcode(name)
2306: char_u *name;
2307: {
2308: int i;
2309:
2310: for (i = 0; i < tc_len; ++i)
2311: if (termcodes[i].name[0] == name[0] && termcodes[i].name[1] == name[1])
2312: return termcodes[i].code;
2313: return NULL;
2314: }
2315:
2316: char_u *
2317: get_termcode(i)
2318: int i;
2319: {
2320: if (i >= tc_len)
2321: return NULL;
2322: return &termcodes[i].name[0];
2323: }
2324:
2325: void
2326: del_termcode(name)
2327: char_u *name;
2328: {
2329: int i;
2330:
2331: if (termcodes == NULL) /* nothing there yet */
2332: return;
2333:
2334: need_gather = TRUE; /* need to fill termleader[] */
2335:
2336: for (i = 0; i < tc_len; ++i)
2337: if (termcodes[i].name[0] == name[0] && termcodes[i].name[1] == name[1])
2338: {
2339: vim_free(termcodes[i].code);
2340: --tc_len;
2341: while (i < tc_len)
2342: {
2343: termcodes[i] = termcodes[i + 1];
2344: ++i;
2345: }
2346: return;
2347: }
2348: /* not found. Give error message? */
2349: }
2350:
2351: /*
2352: * Check if typebuf[] contains a terminal key code.
2353: * Check from typebuf[typeoff] to typebuf[typeoff + max_offset].
2354: * Return 0 for no match, -1 for partial match, > 0 for full match.
2355: * With a match, the match is removed, the replacement code is inserted in
2356: * typebuf[] and the number of characters in typebuf[] is returned.
2357: */
2358: int
2359: check_termcode(max_offset)
2360: int max_offset;
2361: {
2362: register char_u *tp;
2363: register char_u *p;
2364: int slen = 0; /* init for GCC */
2365: int len;
2366: int offset;
2367: char_u key_name[2];
2368: int new_slen;
2369: int extra;
2370: char_u string[MAX_KEY_CODE_LEN + 1];
2371: int i;
2372: #ifdef USE_GUI
2373: long_u val;
2374: #endif
2375: #ifdef USE_MOUSE
2376: char_u bytes[3];
2377: int num_bytes;
2378: int mouse_code;
2379: int modifiers;
2380: int is_click, is_drag;
2381: int current_button;
2382: static int held_button = MOUSE_RELEASE;
2383: static int orig_num_clicks = 1;
2384: static int orig_mouse_code = 0x0;
2385: # if defined(UNIX) && defined(HAVE_GETTIMEOFDAY) && defined(HAVE_SYS_TIME_H)
2386: static int orig_mouse_col = 0;
2387: static int orig_mouse_row = 0;
2388: static linenr_t orig_topline = 0;
2389: static struct timeval orig_mouse_time = {0, 0};
2390: /* time of previous mouse click */
2391: struct timeval mouse_time; /* time of current mouse click */
2392: long timediff; /* elapsed time in msec */
2393: # endif
2394: #endif
2395:
2396: /*
2397: * Speed up the checks for terminal codes by gathering all first bytes
2398: * used in termleader[]. Often this is just a single <Esc>.
2399: */
2400: if (need_gather)
2401: gather_termleader();
2402:
2403: /*
2404: * Check at several positions in typebuf[], to catch something like
2405: * "x<Up>" that can be mapped. Stop at max_offset, because characters
2406: * after that cannot be used for mapping, and with @r commands typebuf[]
2407: * can become very long.
2408: * This is used often, KEEP IT FAST!
2409: */
2410: for (offset = 0; offset < typelen && offset < max_offset; ++offset)
2411: {
2412: tp = typebuf + typeoff + offset;
2413:
2414: /*
2415: * Don't check characters after K_SPECIAL, those are already
2416: * translated terminal chars (avoid translating ~@^Hx).
2417: */
2418: if (*tp == K_SPECIAL)
2419: {
2420: offset += 2; /* there are always 2 extra characters */
2421: continue;
2422: }
2423:
2424: /*
2425: * Skip this position if the character does not appear as the first
2426: * character in term_strings. This speeds up a lot, since most
2427: * termcodes start with the same character (ESC or CSI).
2428: */
2429: i = *tp;
2430: for (p = termleader; *p && *p != i; ++p)
2431: ;
2432: if (*p == NUL)
2433: continue;
2434:
2435: /*
2436: * Skip this position if p_ek is not set and
2437: * typebuf[typeoff + offset] is an ESC and we are in insert mode
2438: */
2439: if (*tp == ESC && !p_ek && (State & INSERT))
2440: continue;
2441:
2442: len = typelen - offset; /* length of the input */
2443: new_slen = 0; /* Length of what will replace the termcode */
2444: key_name[0] = NUL; /* no key name found yet */
2445:
2446: #ifdef USE_GUI
2447: if (gui.in_use)
2448: {
2449: /*
2450: * GUI special key codes are all of the form [CSI xx].
2451: */
2452: if (*tp == CSI) /* Special key from GUI */
2453: {
2454: if (len < 3)
2455: return -1; /* Shouldn't happen */
2456: slen = 3;
2457: key_name[0] = tp[1];
2458: key_name[1] = tp[2];
2459: }
2460: }
2461: else
2462: #endif /* USE_GUI */
2463: {
2464: for (i = 0; i < tc_len; ++i)
2465: {
2466: /*
2467: * Ignore the entry if we are not at the start of typebuf[]
2468: * and there are not enough characters to make a match.
2469: */
2470: slen = termcodes[i].len;
2471: if (offset && len < slen)
2472: continue;
2473: if (STRNCMP(termcodes[i].code, tp,
2474: (size_t)(slen > len ? len : slen)) == 0)
2475: {
2476: if (len < slen) /* got a partial sequence */
2477: return -1; /* need to get more chars */
2478:
2479: key_name[0] = termcodes[i].name[0];
2480: key_name[1] = termcodes[i].name[1];
2481:
2482: /*
2483: * If it's a shifted special key, then include the SHIFT
2484: * modifier
2485: */
2486: if (unshift_special_key(&key_name[0]))
2487: {
2488: string[new_slen++] = K_SPECIAL;
2489: string[new_slen++] = KS_MODIFIER;
2490: string[new_slen++] = MOD_MASK_SHIFT;
2491: }
2492: break;
2493: }
2494: }
2495: }
2496:
2497: if (key_name[0] == NUL)
2498: continue; /* No match at this position, try next one */
2499:
2500: /* We only get here when we have a complete termcode match */
2501:
2502: #ifdef USE_MOUSE
2503: /*
2504: * If it is a mouse click, get the coordinates.
2505: * we get "<t_mouse>scr", where
2506: * s == encoded mouse button state (0x20 = left, 0x22 = right, etc)
2507: * c == column + ' ' + 1 == column + 33
2508: * r == row + ' ' + 1 == row + 33
2509: *
2510: * The coordinates are passed on through global variables. Ugly,
2511: * but this avoids trouble with mouse clicks at an unexpected
2512: * moment and allows for mapping them.
2513: */
2514: if (key_name[0] == KS_MOUSE)
2515: {
2516: num_bytes = get_bytes_from_buf(tp + slen, bytes, 3);
2517: if (num_bytes == -1) /* not enough coordinates */
2518: return -1;
2519: mouse_code = bytes[0];
2520: mouse_col = bytes[1] - ' ' - 1;
2521: mouse_row = bytes[2] - ' ' - 1;
2522: slen += num_bytes;
2523:
2524: /* Interpret the mouse code */
2525: is_click = is_drag = FALSE;
2526: current_button = (mouse_code & MOUSE_CLICK_MASK);
2527: if (current_button == MOUSE_RELEASE)
2528: {
2529: /*
2530: * If we get a mouse drag or release event when
2531: * there is no mouse button held down (held_button ==
2532: * MOUSE_RELEASE), produce a K_IGNORE below.
2533: * (can happen when you hold down two buttons
2534: * and then let them go, or click in the menu bar, but not
2535: * on a menu, and drag into the text).
2536: */
2537: if ((mouse_code & MOUSE_DRAG) == MOUSE_DRAG)
2538: is_drag = TRUE;
2539: current_button = held_button;
2540: }
2541: else
2542: {
2543: #if defined(UNIX) && defined(HAVE_GETTIMEOFDAY) && defined(HAVE_SYS_TIME_H)
2544: # ifdef USE_GUI
2545: /*
2546: * Only for Unix, when GUI is not active, we handle
2547: * multi-clicks here.
2548: */
2549: if (!gui.in_use)
2550: # endif
2551: {
2552: /*
2553: * Compute the time elapsed since the previous mouse click.
2554: */
2555: gettimeofday(&mouse_time, NULL);
2556: timediff = (mouse_time.tv_usec -
2557: orig_mouse_time.tv_usec) / 1000;
2558: if (timediff < 0)
2559: --orig_mouse_time.tv_sec;
2560: timediff += (mouse_time.tv_sec -
2561: orig_mouse_time.tv_sec) * 1000;
2562: orig_mouse_time = mouse_time;
2563: if (mouse_code == orig_mouse_code &&
2564: timediff < p_mouset &&
2565: orig_num_clicks != 4 &&
2566: orig_mouse_col == mouse_col &&
2567: orig_mouse_row == mouse_row &&
2568: orig_topline == curwin->w_topline)
2569: ++orig_num_clicks;
2570: else
2571: orig_num_clicks = 1;
2572: orig_mouse_col = mouse_col;
2573: orig_mouse_row = mouse_row;
2574: orig_topline = curwin->w_topline;
2575: }
2576: # ifdef USE_GUI
2577: else
2578: orig_num_clicks = NUM_MOUSE_CLICKS(mouse_code);
2579: # endif
2580: #else
2581: orig_num_clicks = NUM_MOUSE_CLICKS(mouse_code);
2582: #endif
2583: is_click = TRUE;
2584: orig_mouse_code = mouse_code;
2585: }
2586: if (!is_drag)
2587: held_button = mouse_code & MOUSE_CLICK_MASK;
2588:
2589: /*
2590: * Translate the actual mouse event into a pseudo mouse event.
2591: * First work out what modifiers are to be used.
2592: */
2593: modifiers = 0x0;
2594: if (orig_mouse_code & MOUSE_SHIFT)
2595: modifiers |= MOD_MASK_SHIFT;
2596: if (orig_mouse_code & MOUSE_CTRL)
2597: modifiers |= MOD_MASK_CTRL;
2598: if (orig_mouse_code & MOUSE_ALT)
2599: modifiers |= MOD_MASK_ALT;
2600: if (orig_num_clicks == 2)
2601: modifiers |= MOD_MASK_2CLICK;
2602: else if (orig_num_clicks == 3)
2603: modifiers |= MOD_MASK_3CLICK;
2604: else if (orig_num_clicks == 4)
2605: modifiers |= MOD_MASK_4CLICK;
2606:
2607: /* Add the modifier codes to our string */
2608: if (modifiers != 0)
2609: {
2610: string[new_slen++] = K_SPECIAL;
2611: string[new_slen++] = KS_MODIFIER;
2612: string[new_slen++] = modifiers;
2613: }
2614:
2615: /* Work out our pseudo mouse event */
2616: key_name[0] = KS_EXTRA;
2617: key_name[1] = get_pseudo_mouse_code(current_button,
2618: is_click, is_drag);
2619: }
2620: #endif /* USE_MOUSE */
2621: #ifdef USE_GUI
2622: /*
2623: * If using the GUI, then we get menu and scrollbar events.
2624: *
2625: * A menu event is encoded as K_SPECIAL, KS_MENU, K_FILLER followed by
2626: * four bytes which are to be taken as a pointer to the GuiMenu
2627: * structure.
2628: *
2629: * A scrollbar event is K_SPECIAL, KS_SCROLLBAR, K_FILLER followed by
2630: * one byte representing the scrollbar number, and then four bytes
2631: * representing a long_u which is the new value of the scrollbar.
2632: *
2633: * A horizontal scrollbar event is K_SPECIAL, KS_HORIZ_SCROLLBAR,
2634: * K_FILLER followed by four bytes representing a long_u which is the
2635: * new value of the scrollbar.
2636: */
2637: else if (key_name[0] == KS_MENU)
2638: {
2639: num_bytes = get_long_from_buf(tp + slen, &val);
2640: if (num_bytes == -1)
2641: return -1;
2642: current_menu = (GuiMenu *)val;
2643: slen += num_bytes;
2644: }
2645: else if (key_name[0] == KS_SCROLLBAR)
2646: {
2647: num_bytes = get_bytes_from_buf(tp + slen, bytes, 1);
2648: if (num_bytes == -1)
2649: return -1;
2650: current_scrollbar = (int)bytes[0];
2651: slen += num_bytes;
2652: num_bytes = get_long_from_buf(tp + slen, &val);
2653: if (num_bytes == -1)
2654: return -1;
2655: scrollbar_value = val;
2656: slen += num_bytes;
2657: }
2658: else if (key_name[0] == KS_HORIZ_SCROLLBAR)
2659: {
2660: num_bytes = get_long_from_buf(tp + slen, &val);
2661: if (num_bytes == -1)
2662: return -1;
2663: scrollbar_value = val;
2664: slen += num_bytes;
2665: }
2666: #endif /* USE_GUI */
2667: /* Finally, add the special key code to our string */
2668: string[new_slen++] = K_SPECIAL;
2669: string[new_slen++] = key_name[0];
2670: string[new_slen++] = key_name[1];
2671: string[new_slen] = NUL;
2672: extra = new_slen - slen;
2673: if (extra < 0)
2674: /* remove matched chars, taking care of noremap */
2675: del_typebuf(-extra, offset);
2676: else if (extra > 0)
2677: /* insert the extra space we need */
2678: ins_typebuf(string + slen, FALSE, offset, FALSE);
2679:
2680: /*
2681: * Careful: del_typebuf() and ins_typebuf() may have
2682: * reallocated typebuf[]
2683: */
2684: vim_memmove(typebuf + typeoff + offset, string, (size_t)new_slen);
2685: return (len + extra + offset);
2686: }
2687: return 0; /* no match found */
2688: }
2689:
2690: /*
2691: * Replace any terminal code strings in from[] with the equivalent internal
2692: * vim representation. This is used for the "from" and "to" part of a
2693: * mapping, and the "to" part of a menu command.
2694: * Any strings like "<C_UP>" are also replaced, unless 'cpoptions' contains
2695: * '<'. Also unshifts shifted special keys.
2696: * K_SPECIAL by itself is replaced by K_SPECIAL KS_SPECIAL K_FILLER.
2697: *
2698: * The replacement is done in result[] and finally copied into allocated
2699: * memory. If this all works well *bufp is set to the allocated memory and a
2700: * pointer to it is returned. If something fails *bufp is set to NULL and from
2701: * is returned.
2702: *
2703: * CTRL-V characters are removed. When "from_part" is TRUE, a trailing CTRL-V
2704: * is included, otherwise it is removed (for ":map xx ^V", maps xx to
2705: * nothing). When 'cpoptions' does not contain 'B', a backslash can be used
2706: * instead of a CTRL-V.
2707: */
2708: char_u *
2709: replace_termcodes(from, bufp, from_part)
2710: char_u *from;
2711: char_u **bufp;
2712: int from_part;
2713: {
2714: int i;
2715: char_u key_name[2];
2716: char_u *bp;
2717: char_u *last_dash;
2718: char_u *end_of_name;
2719: int slen;
2720: int modifiers;
2721: int bit;
2722: int key;
2723: int dlen = 0;
2724: char_u *src;
2725: int do_backslash; /* backslash is a special character */
2726: int do_special; /* recognize <> key codes */
2727: int do_key_code; /* recognize raw key codes */
2728: char_u *result; /* buffer for resulting string */
2729:
2730: do_backslash = (vim_strchr(p_cpo, CPO_BSLASH) == NULL);
2731: do_special = (vim_strchr(p_cpo, CPO_SPECI) == NULL);
2732: do_key_code = (vim_strchr(p_cpo, CPO_KEYCODE) == NULL);
2733:
2734: /*
2735: * Allocate space for the translation. Worst case a single character is
2736: * replaced by 6 bytes (shifted special key), plus a NUL at the end.
2737: */
2738: result = alloc((unsigned)STRLEN(from) * 6 + 1);
2739: if (result == NULL) /* out of memory */
2740: {
2741: *bufp = NULL;
2742: return from;
2743: }
2744:
2745: src = from;
2746:
2747: /*
2748: * Check for #n at start only: function key n
2749: */
2750: if (from_part && src[0] == '#' && isdigit(src[1])) /* function key */
2751: {
2752: result[dlen++] = K_SPECIAL;
2753: result[dlen++] = 'k';
2754: if (src[1] == '0')
2755: result[dlen++] = ';'; /* #0 is F10 is "k;" */
2756: else
2757: result[dlen++] = src[1]; /* #3 is F3 is "k3" */
2758: src += 2;
2759: }
2760:
2761: /*
2762: * Copy each byte from *from to result[dlen]
2763: */
2764: while (*src != NUL)
2765: {
2766: /*
2767: * If 'cpoptions' does not contain '<', check for special key codes.
2768: */
2769: if (do_special)
2770: {
2771: /*
2772: * See if it's a string like "<C-S-MouseLeft>"
2773: */
2774: if (src[0] == '<')
2775: {
2776: /* Find end of modifier list */
2777: last_dash = src;
2778: for (bp = src + 1; *bp == '-' || isidchar(*bp); bp++)
2779: {
2780: if (*bp == '-')
2781: {
2782: last_dash = bp;
2783: if (bp[1] != NUL && bp[2] == '>')
2784: ++bp; /* anything accepted, like <C-?> */
2785: }
2786: if (bp[0] == 't' && bp[1] == '_' && bp[2] && bp[3])
2787: bp += 3; /* skip t_xx, xx may be '-' or '>' */
2788: }
2789:
2790: if (*bp == '>') /* found matching '>' */
2791: {
2792: end_of_name = bp + 1;
2793:
2794: /* Which modifiers are given? */
2795: modifiers = 0x0;
2796: for (bp = src + 1; bp < last_dash; bp++)
2797: {
2798: if (*bp != '-')
2799: {
2800: bit = name_to_mod_mask(*bp);
2801: if (bit == 0x0)
2802: break; /* Illegal modifier name */
2803: modifiers |= bit;
2804: }
2805: }
2806:
2807: /*
2808: * Legal modifier name.
2809: */
2810: if (bp >= last_dash)
2811: {
2812: /*
2813: * Modifier with single letter
2814: */
2815: if (modifiers != 0 && last_dash[2] == '>')
2816: {
2817: key = last_dash[1];
2818: if (modifiers & MOD_MASK_SHIFT)
2819: key = TO_UPPER(key);
2820: if (modifiers & MOD_MASK_CTRL)
2821: key &= 0x1f;
2822: if (modifiers & MOD_MASK_ALT)
2823: key |= 0x80;
2824: src = end_of_name;
2825: result[dlen++] = key;
2826: continue;
2827: }
2828:
2829: /*
2830: * Key name with or without modifier.
2831: */
2832: else if ((key = get_special_key_code(last_dash + 1))
2833: != 0)
2834: {
2835: /* Put the appropriate modifier in a string */
2836: if (modifiers != 0)
2837: {
2838: result[dlen++] = K_SPECIAL;
2839: result[dlen++] = KS_MODIFIER;
2840: result[dlen++] = modifiers;
2841: /*
2842: * Special trick: for <S-TAB> K_TAB is used
2843: * instead of TAB (there are two keys for the
2844: * same thing).
2845: */
2846: if (key == TAB)
2847: key = K_TAB;
2848: }
2849:
2850: if (IS_SPECIAL(key))
2851: {
2852: result[dlen++] = K_SPECIAL;
2853: result[dlen++] = KEY2TERMCAP0(key);
2854: result[dlen++] = KEY2TERMCAP1(key);
2855: }
2856: else
2857: result[dlen++] = key; /* only modifiers */
2858: src = end_of_name;
2859: continue;
2860: }
2861: }
2862: }
2863: }
2864: }
2865:
2866: /*
2867: * If 'cpoptions' does not contain 'k', see if it's an actual key-code.
2868: * Note that this is also checked after replacing the <> form.
2869: */
2870: if (do_key_code)
2871: {
2872: for (i = 0; i < tc_len; ++i)
2873: {
2874: slen = termcodes[i].len;
2875: if (STRNCMP(termcodes[i].code, src, (size_t)slen) == 0)
2876: {
2877: key_name[0] = termcodes[i].name[0];
2878: key_name[1] = termcodes[i].name[1];
2879:
2880: /*
2881: * If it's a shifted special key, then include the SHIFT
2882: * modifier
2883: */
2884: if (unshift_special_key(&key_name[0]))
2885: {
2886: result[dlen++] = K_SPECIAL;
2887: result[dlen++] = KS_MODIFIER;
2888: result[dlen++] = MOD_MASK_SHIFT;
2889: }
2890: result[dlen++] = K_SPECIAL;
2891: result[dlen++] = key_name[0];
2892: result[dlen++] = key_name[1];
2893: src += slen;
2894: break;
2895: }
2896: }
2897:
2898: /*
2899: * If terminal code matched, continue after it.
2900: * If no terminal code matched and the character is K_SPECIAL,
2901: * replace it with K_SPECIAL KS_SPECIAL K_FILLER
2902: */
2903: if (i != tc_len)
2904: continue;
2905: }
2906:
2907: if (*src == K_SPECIAL)
2908: {
2909: result[dlen++] = K_SPECIAL;
2910: result[dlen++] = KS_SPECIAL;
2911: result[dlen++] = K_FILLER;
2912: ++src;
2913: continue;
2914: }
2915:
2916: /*
2917: * Remove CTRL-V and ignore the next character.
2918: * For "from" side the CTRL-V at the end is included, for the "to"
2919: * part it is removed.
2920: * If 'cpoptions' does not contain 'B', also accept a backslash.
2921: */
2922: key = *src;
2923: if (key == Ctrl('V') || (do_backslash && key == '\\'))
2924: {
2925: ++src; /* skip CTRL-V or backslash */
2926: if (*src == NUL)
2927: {
2928: if (from_part)
2929: result[dlen++] = key;
2930: break;
2931: }
2932: }
2933: result[dlen++] = *src++;
2934: }
2935: result[dlen] = NUL;
2936:
2937: /*
2938: * Copy the new string to allocated memory.
2939: * If this fails, just return from.
2940: */
2941: if ((*bufp = strsave(result)) != NULL)
2942: from = *bufp;
2943: vim_free(result);
2944: return from;
2945: }
2946:
2947: /*
2948: * Gather the first characters in the terminal key codes into a string.
2949: * Used to speed up check_termcode().
2950: */
2951: static void
2952: gather_termleader()
2953: {
2954: int i;
2955: int len = 0;
2956:
2957: #ifdef USE_GUI
2958: if (gui.in_use)
2959: termleader[len++] = CSI; /* the GUI codes are not in termcodes[] */
2960: #endif
2961: termleader[len] = NUL;
2962:
2963: for (i = 0; i < tc_len; ++i)
2964: if (vim_strchr(termleader, termcodes[i].code[0]) == NULL)
2965: {
2966: termleader[len++] = termcodes[i].code[0];
2967: termleader[len] = NUL;
2968: }
2969:
2970: need_gather = FALSE;
2971: }
2972:
2973: /*
2974: * Show all termcodes (for ":set termcap")
2975: * This code looks a lot like showoptions(), but is different.
2976: */
2977: void
2978: show_termcodes()
2979: {
2980: int col;
2981: int *items;
2982: int item_count;
2983: int run;
2984: int row, rows;
2985: int cols;
2986: int i;
2987: int len;
2988:
2989: #define INC 27 /* try to make three columns */
2990: #define GAP 2 /* spaces between columns */
2991:
2992: if (tc_len == 0) /* no terminal codes (must be GUI) */
2993: return;
2994: items = (int *)alloc((unsigned)(sizeof(int) * tc_len));
2995: if (items == NULL)
2996: return;
2997:
2998: set_highlight('t'); /* Highlight title */
2999: start_highlight();
3000: MSG_OUTSTR("\n--- Terminal keys ---");
3001: stop_highlight();
3002:
3003: /*
3004: * do the loop two times:
3005: * 1. display the short items (non-strings and short strings)
3006: * 2. display the long items (strings)
3007: */
3008: for (run = 1; run <= 2 && !got_int; ++run)
3009: {
3010: /*
3011: * collect the items in items[]
3012: */
3013: item_count = 0;
3014: for (i = 0; i < tc_len; i++)
3015: {
3016: len = show_one_termcode(termcodes[i].name,
3017: termcodes[i].code, FALSE);
3018: if ((len <= INC - GAP && run == 1) || (len > INC - GAP && run == 2))
3019: items[item_count++] = i;
3020: }
3021:
3022: /*
3023: * display the items
3024: */
3025: if (run == 1)
3026: {
3027: cols = (Columns + GAP) / INC;
3028: if (cols == 0)
3029: cols = 1;
3030: rows = (item_count + cols - 1) / cols;
3031: }
3032: else /* run == 2 */
3033: rows = item_count;
3034: for (row = 0; row < rows && !got_int; ++row)
3035: {
3036: msg_outchar('\n'); /* go to next line */
3037: if (got_int) /* 'q' typed in more */
3038: break;
3039: col = 0;
3040: for (i = row; i < item_count; i += rows)
3041: {
3042: msg_pos(-1, col); /* make columns */
3043: show_one_termcode(termcodes[items[i]].name,
3044: termcodes[items[i]].code, TRUE);
3045: col += INC;
3046: }
3047: flushbuf();
3048: mch_breakcheck();
3049: }
3050: }
3051: vim_free(items);
3052: }
3053:
3054: /*
3055: * Show one termcode entry.
3056: * Output goes into IObuff[]
3057: */
3058: int
3059: show_one_termcode(name, code, printit)
3060: char_u *name;
3061: char_u *code;
3062: int printit;
3063: {
3064: char_u *p;
3065: int len;
3066:
3067: if (name[0] > '~')
3068: {
3069: IObuff[0] = ' ';
3070: IObuff[1] = ' ';
3071: IObuff[2] = ' ';
3072: IObuff[3] = ' ';
3073: }
3074: else
3075: {
3076: IObuff[0] = 't';
3077: IObuff[1] = '_';
3078: IObuff[2] = name[0];
3079: IObuff[3] = name[1];
3080: }
3081: IObuff[4] = ' ';
3082:
3083: p = get_special_key_name(TERMCAP2KEY(name[0], name[1]), 0);
3084: if (p[1] != 't')
3085: STRCPY(IObuff + 5, p);
3086: else
3087: IObuff[5] = NUL;
3088: len = STRLEN(IObuff);
3089: do
3090: IObuff[len++] = ' ';
3091: while (len < 17);
3092: IObuff[len] = NUL;
3093: if (code == NULL)
3094: len += 4;
3095: else
3096: len += strsize(code);
3097:
3098: if (printit)
3099: {
3100: msg_outstr(IObuff);
3101: if (code == NULL)
3102: msg_outstr((char_u *)"NULL");
3103: else
3104: msg_outtrans(code);
3105: }
3106: return len;
3107: }
![[BACK]](/icons/back.gif){kind=icon}
Return to term.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim