1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ Terminal capability interaction.
3 *@ For encapsulation purposes provide a basic foundation even without
4 *@ HAVE_TERMCAP, but with nail.h:n_HAVE_TCAP.
5 *@ HOWTO add a new non-dynamic command or query:
6 *@ - add an entry to nail.h:enum n_termcap_{cmd,query}
7 *@ - run mk-tcap-map.pl
8 *@ - update the *termcap* member documentation on changes!
9 *@ Bug: in case of clashes of two-letter names terminfo(5) wins.
11 * Copyright (c) 2016 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
13 * Permission to use, copy, modify, and/or distribute this software for any
14 * purpose with or without fee is hereby granted, provided that the above
15 * copyright notice and this permission notice appear in all copies.
17 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
18 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
20 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
21 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
22 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
23 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
26 #define n_FILE termcap
28 #ifndef HAVE_AMALGAMATION
34 /* If available, curses.h must be included before term.h! */
36 # ifdef HAVE_TERMCAP_CURSES
43 * xxx We are not really compatible with very old and strange terminals since
44 * we don't care at all for circumstances indicated by terminal flags: if we
45 * find a capability we use it and assume it works. E.g., if "Co" indicates
46 * colours we simply use ISO 6429 also for font attributes etc. That is,
47 * we don't use the ncurses/terminfo interface with all its internal logic.
48 * TODO After I/O layer rewrite, "output to STDIN_FILENO".
51 /* Unless HAVE_TERMINFO or HAVE_TGETENT_NULL_BUF are defined we will use this
52 * to space the buffer we pass through to tgetent(3).
53 * Since for (such) elder non-emulated terminals really weird things will
54 * happen if an entry would require more than 1024 bytes, don't really mind.
55 * Use a ui16_t for storage */
56 #define a_TERMCAP_ENTRYSIZE_MAX ((2668 + 64) & ~64) /* As of ncurses 6.0 */
58 n_CTA(a_TERMCAP_ENTRYSIZE_MAX
< UI16_MAX
,
59 "Chosen buffer size exceeds datatype capability");
61 /* For simplicity we store commands and queries in single continuous control
62 * and entry structure arrays: to index queries one has to add
63 * n__TERMCAP_CMD_MAX first! And don't confound with ENTRYSIZE_MAX! */
65 a_TERMCAP_ENT_MAX
= n__TERMCAP_CMD_MAX
+ n__TERMCAP_QUERY_MAX
70 /* enum n_termcap_captype values stored here.
71 * Note that presence of a type in an a_termcap_ent signals initialization */
72 a_TERMCAP_F_TYPE_MASK
= (1<<4) - 1,
74 a_TERMCAP_F_QUERY
= 1<<4, /* A query rather than a command */
75 a_TERMCAP_F_DISABLED
= 1<<5, /* User explicitly disabled command/query */
76 a_TERMCAP_F_ALTERN
= 1<<6, /* Not available, but has alternative */
77 a_TERMCAP_F_NOENT
= 1<<7, /* Not available */
79 /* _cmd() argument interpretion (_T_STR) */
80 a_TERMCAP_F_ARG_IDX1
= 1<<11, /* Argument 1 used, and is an index */
81 a_TERMCAP_F_ARG_IDX2
= 1<<12,
82 a_TERMCAP_F_ARG_CNT
= 1<<13, /* .., and is a count */
84 a_TERMCAP_F__LAST
= a_TERMCAP_F_ARG_CNT
86 n_CTA((ui32_t
)n__TERMCAP_CAPTYPE_MAX
<= (ui32_t
)a_TERMCAP_F_TYPE_MASK
,
87 "enum n_termcap_captype exceeds bit range of a_termcap_flags");
89 struct a_termcap_control
{
91 /* Offset base into a_termcap_namedat[], which stores the two-letter
92 * termcap(5) name directly followed by a NUL terminated terminfo(5) name.
93 * A termcap(5) name may consist of two NULs meaning ENOENT,
94 * a terminfo(5) name may be empty for the same purpose */
97 n_CTA(a_TERMCAP_F__LAST
<= UI16_MAX
,
98 "a_termcap_flags exceed storage datatype in a_termcap_control");
100 struct a_termcap_ent
{
102 ui16_t te_off
; /* in a_termcap_g->tg_dat / value for T_BOOL and T_NUM */
104 n_CTA(a_TERMCAP_F__LAST
<= UI16_MAX
,
105 "a_termcap_flags exceed storage datatype in a_termcap_ent");
107 /* Structure for extended queries, which don't have an entry constant in
108 * n_termcap_query (to allow free query/binding of keycodes) */
109 struct a_termcap_ext_ent
{
110 struct a_termcap_ent tee_super
;
112 struct a_termcap_ext_ent
*tee_next
;
113 /* Resolvable termcap(5)/terminfo(5) name as given by user; the actual data
114 * is stored just like for normal queries */
115 char tee_name
[VFIELD_SIZE(0)];
119 struct a_termcap_ext_ent
*tg_ext_ents
; /* List of extended queries */
120 struct a_termcap_ent tg_ents
[a_TERMCAP_ENT_MAX
];
121 struct n_string tg_dat
; /* Storage for resolved caps */
122 # if !defined HAVE_TGETENT_NULL_BUF && !defined HAVE_TERMINFO
123 char tg_lib_buf
[a_TERMCAP_ENTRYSIZE_MAX
];
127 /* Include the constant mk-tcap-map.pl output */
129 n_CTA(sizeof a_termcap_namedat
<= UI16_MAX
,
130 "Termcap command and query name data exceed storage datatype");
131 n_CTA(a_TERMCAP_ENT_MAX
== NELEM(a_termcap_control
),
132 "Control array doesn't match command/query array to be controlled");
134 static struct a_termcap_g
*a_termcap_g
;
136 /* Query *termcap*, parse it and incorporate into a_termcap_g */
137 static void a_termcap_init_var(struct str
const *termvar
);
139 /* Expand ^CNTRL, \[Ee] and \OCT. False for parse error and empty results */
140 static bool_t
a_termcap__strexp(struct n_string
*store
, char const *ibuf
);
142 /* Initialize any _ent for which we have _F_ALTERN and which isn't yet set */
143 static void a_termcap_init_altern(void);
146 /* Setup the library we use to work with term */
147 static bool_t
a_termcap_load(char const *term
);
149 /* Query the capability tcp and fill in tep (upon success) */
150 static bool_t
a_termcap_ent_query(struct a_termcap_ent
*tep
,
151 char const *cname
, ui16_t cflags
);
152 SINLINE bool_t
a_termcap_ent_query_tcp(struct a_termcap_ent
*tep
,
153 struct a_termcap_control
const *tcp
);
155 /* Output PTF for both, termcap(5) and terminfo(5) */
156 static int a_termcap_putc(int c
);
159 /* Get n_termcap_cmd or n_termcap_query constant belonging to (nlen bytes of)
160 * name, or -1 if not found. min and max have to be used to cramp the result */
161 static si32_t
a_termcap_enum_for_name(char const *name
, size_t nlen
,
162 si32_t min
, si32_t max
);
163 #define a_termcap_cmd_for_name(NB,NL) \
164 a_termcap_enum_for_name(NB, NL, 0, n__TERMCAP_CMD_MAX)
165 #define a_termcap_query_for_name(NB,NL) \
166 a_termcap_enum_for_name(NB, NL, n__TERMCAP_CMD_MAX, a_TERMCAP_ENT_MAX)
169 a_termcap_init_var(struct str
const *termvar
){
170 char *cbp_base
, *cbp
;
175 if(termvar
->l
>= UI16_MAX
){
176 n_err(_("*termcap*: length excesses internal limit, skipping\n"));
180 assert(termvar
->s
[termvar
->l
] == '\0');
182 cbp_base
= salloc(i
);
183 memcpy(cbp
= cbp_base
, termvar
->s
, i
);
185 for(; (ccp
= n_strsep(&cbp
, ',', TRU1
)) != NULL
;){
186 struct a_termcap_ent
*tep
;
191 /* Separate key/value, if any */
192 if(/* no empties ccp[0] == '\0' ||*/ ccp
[1] == '\0'){
194 n_err(_("*termcap*: invalid entry: %s\n"), ccp
);
197 for(kl
= 2, v
= &ccp
[2];; ++kl
, ++v
){
201 f
= n_TERMCAP_CAPTYPE_BOOL
;
204 f
= n_TERMCAP_CAPTYPE_NUMERIC
;
208 f
= n_TERMCAP_CAPTYPE_STRING
;
214 /* Do we know about this one? */
216 struct a_termcap_control
const *tcp
;
219 tci
= a_termcap_enum_for_name(ccp
, kl
, 0, a_TERMCAP_ENT_MAX
);
221 /* For key binding purposes, save any given string */
222 #ifdef HAVE_KEY_BINDINGS
223 if((f
& a_TERMCAP_F_TYPE_MASK
) == n_TERMCAP_CAPTYPE_STRING
){
224 struct a_termcap_ext_ent
*teep
;
226 teep
= smalloc(sizeof(*teep
) -
227 VFIELD_SIZEOF(struct a_termcap_ext_ent
, tee_name
) + kl
+1);
228 teep
->tee_next
= a_termcap_g
->tg_ext_ents
;
229 a_termcap_g
->tg_ext_ents
= teep
;
230 memcpy(teep
->tee_name
, ccp
, kl
);
231 teep
->tee_name
[kl
] = '\0';
233 tep
= &teep
->tee_super
;
234 tep
->te_flags
= n_TERMCAP_CAPTYPE_STRING
| a_TERMCAP_F_QUERY
;
235 tep
->te_off
= (ui16_t
)a_termcap_g
->tg_dat
.s_len
;
236 if(!a_termcap__strexp(&a_termcap_g
->tg_dat
, v
))
237 tep
->te_flags
|= a_TERMCAP_F_DISABLED
;
240 #endif /* HAVE_KEY_BINDINGS */
241 if(options
& OPT_D_V
)
242 n_err(_("*termcap*: unknown capability: %s\n"), ccp
);
247 tcp
= &a_termcap_control
[i
];
248 if((tcp
->tc_flags
& a_TERMCAP_F_TYPE_MASK
) != f
){
249 n_err(_("*termcap*: entry type mismatch: %s\n"), ccp
);
252 tep
= &a_termcap_g
->tg_ents
[i
];
253 tep
->te_flags
= tcp
->tc_flags
;
254 tep
->te_off
= (ui16_t
)a_termcap_g
->tg_dat
.s_len
;
257 if((f
& a_TERMCAP_F_TYPE_MASK
) == n_TERMCAP_CAPTYPE_BOOL
)
260 tep
->te_flags
|= a_TERMCAP_F_DISABLED
;
261 else if((f
& a_TERMCAP_F_TYPE_MASK
) == n_TERMCAP_CAPTYPE_NUMERIC
){
263 long l
= strtol(v
, &eptr
, 10);
265 if(*eptr
!= '\0' || l
< 0 || UICMP(32, l
, >=, UI16_MAX
))
267 tep
->te_off
= (ui16_t
)l
;
268 }else if(!a_termcap__strexp(&a_termcap_g
->tg_dat
, v
))
269 tep
->te_flags
|= a_TERMCAP_F_DISABLED
;
270 #ifdef HAVE_KEY_BINDINGS
273 if(options
& OPT_D_VV
)
274 n_err(_("*termcap*: learned %.*s: %s\n"), (int)kl
, ccp
,
275 (tep
->te_flags
& a_TERMCAP_F_DISABLED
? "<disabled>"
276 : (f
& a_TERMCAP_F_TYPE_MASK
) == n_TERMCAP_CAPTYPE_BOOL
? "true"
279 DBG( if(options
& OPT_D_V
) n_err("*termcap* parsed: buffer used=%lu\n",
280 (ul_i
)a_termcap_g
->tg_dat
.s_len
) );
282 /* Catch some inter-dependencies the user may have triggered */
284 if(a_termcap_g
->tg_ents
[n_TERMCAP_CMD_te
].te_flags
& a_TERMCAP_F_DISABLED
)
285 a_termcap_g
->tg_ents
[n_TERMCAP_CMD_ti
].te_flags
= a_TERMCAP_F_DISABLED
;
286 else if(a_termcap_g
->tg_ents
[n_TERMCAP_CMD_ti
].te_flags
&
287 a_TERMCAP_F_DISABLED
)
288 a_termcap_g
->tg_ents
[n_TERMCAP_CMD_te
].te_flags
= a_TERMCAP_F_DISABLED
;
296 a_termcap__strexp(struct n_string
*store
, char const *ibuf
){ /* XXX ASCII */
304 for(oibuf
= ibuf
; (c
= *ibuf
) != '\0';){
306 if((c
= ibuf
[1]) == '\0')
318 if((c2
= ibuf
[2]) == '\0' || !octalchar(c2
) ||
319 (c3
= ibuf
[3]) == '\0' || !octalchar(c3
)){
320 n_err(_("*termcap*: invalid octal sequence: %s\n"), oibuf
);
323 c
-= '0', c2
-= '0', c3
-= '0';
326 n_err(_("*termcap*: octal number too large: %s\n"), oibuf
);
334 n_err(_("*termcap*: invalid reverse solidus \\ sequence: %s\n"),oibuf
);
337 if((c
= ibuf
[1]) == '\0'){
338 n_err(_("*termcap*: incomplete ^CNTRL sequence: %s\n"), oibuf
);
341 c
= upperconv(c
) ^ 0x40;
342 if((ui8_t
)c
> 0x1F && c
!= 0x7F){ /* ASCII C0: 0..1F, 7F */
343 n_err(_("*termcap*: invalid ^CNTRL sequence: %s\n"), oibuf
);
351 store
= n_string_push_c(store
, c
);
354 c
= (store
->s_len
!= olen
) ? '\1' : '\0';
356 n_string_push_c(store
, '\0');
360 store
= n_string_trunc(store
, olen
);
366 a_termcap_init_altern(void){
367 /* We silently ignore user _F_DISABLED requests for those entries for which
368 * we have fallback entries, and which we need to ensure proper functioning.
369 * I.e., this allows users to explicitly disable some termcap(5) capability
370 * and enforce usage of the builtin fallback */
371 /* xxx Use table-based approach for fallback strategies */
372 #define a_OK(CMD) a_OOK(&a_termcap_g->tg_ents[CMD])
374 ((TEP)->te_flags != 0 && !((TEP)->te_flags & a_TERMCAP_F_NOENT))
375 #define a_SET(TEP,CMD,ALT) \
376 (TEP)->te_flags = a_termcap_control[CMD].tc_flags |\
377 ((ALT) ? a_TERMCAP_F_ALTERN : 0)
379 struct a_termcap_ent
*tep
;
383 /* For simplicity in the rest of this file null flags of disabled commands,
384 * as we won't check and try to lazy query any command */
388 for(i
= n__TERMCAP_CMD_MAX
;;){
391 if((tep
= &a_termcap_g
->tg_ents
[i
])->te_flags
& a_TERMCAP_F_DISABLED
)
398 tep
= &a_termcap_g
->tg_ents
[n_TERMCAP_CMD_cl
];
400 if(a_OK(n_TERMCAP_CMD_cd
) && a_OK(n_TERMCAP_CMD_ho
))
401 a_SET(tep
, n_TERMCAP_CMD_cl
, TRU1
);
406 /* ce == ch + [:SPC:] (start column specified by argument) */
407 tep
= &a_termcap_g
->tg_ents
[n_TERMCAP_CMD_ce
];
409 a_SET(tep
, n_TERMCAP_CMD_ce
, TRU1
);
411 /* ch == cr[\r] + nd[:\033C:] */
412 tep
= &a_termcap_g
->tg_ents
[n_TERMCAP_CMD_ch
];
414 a_SET(tep
, n_TERMCAP_CMD_ch
, TRU1
);
417 tep
= &a_termcap_g
->tg_ents
[n_TERMCAP_CMD_cr
];
419 a_SET(tep
, n_TERMCAP_CMD_cr
, FAL0
);
420 tep
->te_off
= (ui16_t
)a_termcap_g
->tg_dat
.s_len
;
421 n_string_push_c(n_string_push_c(&a_termcap_g
->tg_dat
, '\r'), '\0');
425 tep
= &a_termcap_g
->tg_ents
[n_TERMCAP_CMD_le
];
427 a_SET(tep
, n_TERMCAP_CMD_le
, FAL0
);
428 tep
->te_off
= (ui16_t
)a_termcap_g
->tg_dat
.s_len
;
429 n_string_push_c(n_string_push_c(&a_termcap_g
->tg_dat
, '\b'), '\0');
432 /* nd == \033[C (we may not fail, anyway, so use xterm sequence default) */
433 tep
= &a_termcap_g
->tg_ents
[n_TERMCAP_CMD_nd
];
435 a_SET(tep
, n_TERMCAP_CMD_nd
, FAL0
);
436 tep
->te_off
= (ui16_t
)a_termcap_g
->tg_dat
.s_len
;
437 n_string_push_buf(&a_termcap_g
->tg_dat
, "\033[C", sizeof("\033[C"));
439 #endif /* HAVE_MLE */
448 # ifdef HAVE_TERMINFO
450 a_termcap_load(char const *term
){
455 if(!(rv
= (setupterm(term
, STDOUT_FILENO
, &err
) == OK
)))
456 n_err(_("Unknown ${TERM}inal, using only *termcap*: %s\n"), term
);
462 a_termcap_ent_query(struct a_termcap_ent
*tep
,
463 char const *cname
, ui16_t cflags
){
466 assert(!(pstate
& PS_TERMCAP_DISABLE
));
468 if(UNLIKELY(*cname
== '\0'))
470 else switch((tep
->te_flags
= cflags
) & a_TERMCAP_F_TYPE_MASK
){
471 case n_TERMCAP_CAPTYPE_BOOL
:
472 tep
->te_off
= (tigetflag(cname
) > 0);
475 case n_TERMCAP_CAPTYPE_NUMERIC
:{
476 int r
= tigetnum(cname
);
479 tep
->te_off
= (ui16_t
)MIN(UI16_MAX
, r
);
481 tep
->te_flags
|= a_TERMCAP_F_NOENT
;
484 case n_TERMCAP_CAPTYPE_STRING
:{
487 cp
= tigetstr(cname
);
488 if((rv
= (cp
!= NULL
&& cp
!= (char*)-1))){
489 tep
->te_off
= (ui16_t
)a_termcap_g
->tg_dat
.s_len
;
490 n_string_push_buf(&a_termcap_g
->tg_dat
, cp
, strlen(cp
) +1);
492 tep
->te_flags
|= a_TERMCAP_F_NOENT
;
500 a_termcap_ent_query_tcp(struct a_termcap_ent
*tep
,
501 struct a_termcap_control
const *tcp
){
502 assert(!(pstate
& PS_TERMCAP_DISABLE
));
503 return a_termcap_ent_query(tep
, &a_termcap_namedat
[tcp
->tc_off
] + 2,
507 # else /* HAVE_TERMINFO */
509 a_termcap_load(char const *term
){
513 /* ncurses may return -1 */
514 # ifndef HAVE_TGETENT_NULL_BUF
515 # define a_BUF &a_termcap_g->tg_lib_buf[0]
519 if(!(rv
= tgetent(a_BUF
, term
) > 0))
520 n_err(_("Unknown ${TERM}inal, using only *termcap*: %s\n"), term
);
527 a_termcap_ent_query(struct a_termcap_ent
*tep
,
528 char const *cname
, ui16_t cflags
){
531 assert(!(pstate
& PS_TERMCAP_DISABLE
));
533 if(UNLIKELY(*cname
== '\0'))
535 else switch((tep
->te_flags
= cflags
) & a_TERMCAP_F_TYPE_MASK
){
536 case n_TERMCAP_CAPTYPE_BOOL
:
537 tep
->te_off
= (tgetflag(cname
) > 0);
540 case n_TERMCAP_CAPTYPE_NUMERIC
:{
541 int r
= tgetnum(cname
);
544 tep
->te_off
= (ui16_t
)MIN(UI16_MAX
, r
);
546 tep
->te_flags
|= a_TERMCAP_F_NOENT
;
549 case n_TERMCAP_CAPTYPE_STRING
:{
550 # ifndef HAVE_TGETENT_NULL_BUF
551 char buf_base
[a_TERMCAP_ENTRYSIZE_MAX
], *buf
= &buf_base
[0];
558 if((rv
= ((cp
= tgetstr(cname
, a_BUF
)) != NULL
))){
559 tep
->te_off
= (ui16_t
)a_termcap_g
->tg_dat
.s_len
;
560 n_string_push_buf(&a_termcap_g
->tg_dat
, cp
, strlen(cp
) +1);
563 tep
->te_flags
|= a_TERMCAP_F_NOENT
;
571 a_termcap_ent_query_tcp(struct a_termcap_ent
*tep
,
572 struct a_termcap_control
const *tcp
){
573 assert(!(pstate
& PS_TERMCAP_DISABLE
));
574 return a_termcap_ent_query(tep
, &a_termcap_namedat
[tcp
->tc_off
],
577 # endif /* !HAVE_TERMINFO */
580 a_termcap_putc(int c
){
583 #endif /* HAVE_TERMCAP */
586 a_termcap_enum_for_name(char const *name
, size_t nlen
, si32_t min
, si32_t max
){
587 struct a_termcap_control
const *tcp
;
592 /* Prefer terminfo(5) names */
599 tcp
= &a_termcap_control
[(ui32_t
)rv
];
600 cnam
= &a_termcap_namedat
[tcp
->tc_off
];
602 char const *xcp
= cnam
+ 2;
604 if(nlen
== strlen(xcp
) && !memcmp(xcp
, name
, nlen
))
607 if(nlen
== 2 && cnam
[0] == name
[0] && cnam
[1] == name
[1])
615 n_termcap_init(void){
620 assert((options
& (OPT_INTERACTIVE
| OPT_QUICKRUN_MASK
)) == OPT_INTERACTIVE
);
622 a_termcap_g
= smalloc(sizeof *a_termcap_g
);
623 a_termcap_g
->tg_ext_ents
= NULL
;
624 memset(&a_termcap_g
->tg_ents
[0], 0, sizeof(a_termcap_g
->tg_ents
));
625 if((ccp
= ok_vlook(termcap
)) != NULL
)
626 termvar
.l
= strlen(termvar
.s
= UNCONST(ccp
));
628 /*termvar.s = NULL,*/ termvar
.l
= 0;
629 n_string_reserve(n_string_creat(&a_termcap_g
->tg_dat
),
630 ((termvar
.l
+ (256 - 64)) & ~127));
633 a_termcap_init_var(&termvar
);
635 if(ok_blook(termcap_disable
))
636 pstate
|= PS_TERMCAP_DISABLE
;
638 else if((ccp
= ok_vlook(TERM
)) == NULL
){
639 n_err(_("Environment variable $TERM is not set, using only *termcap*\n"));
640 pstate
|= PS_TERMCAP_DISABLE
;
641 }else if(!a_termcap_load(ccp
))
642 pstate
|= PS_TERMCAP_DISABLE
;
644 /* Query termcap(5) for each command slot that is not yet set */
645 struct a_termcap_ent
*tep
;
648 for(i
= n__TERMCAP_CMD_MAX
;;){
651 if((tep
= &a_termcap_g
->tg_ents
[i
])->te_flags
== 0)
652 a_termcap_ent_query_tcp(tep
, &a_termcap_control
[i
]);
657 a_termcap_init_altern();
660 if(a_termcap_g
->tg_ents
[n_TERMCAP_CMD_te
].te_flags
!= 0)
661 pstate
|= PS_TERMCAP_CA_MODE
;
663 n_TERMCAP_RESUME(TRU1
);
668 n_termcap_destroy(void){
670 assert((options
& (OPT_INTERACTIVE
| OPT_QUICKRUN_MASK
)) == OPT_INTERACTIVE
);
672 n_TERMCAP_SUSPEND(TRU1
);
676 struct a_termcap_ext_ent
*tmp
;
678 while((tmp
= a_termcap_g
->tg_ext_ents
) != NULL
){
679 a_termcap_g
->tg_ext_ents
= tmp
->tee_next
;
683 n_string_gut(&a_termcap_g
->tg_dat
);
692 n_termcap_resume(bool_t complete
){
694 if(!(pstate
& PS_TERMCAP_DISABLE
) &&
695 (options
& (OPT_INTERACTIVE
| OPT_QUICKRUN_MASK
)) == OPT_INTERACTIVE
){
696 if(complete
&& (pstate
& PS_TERMCAP_CA_MODE
))
697 n_termcap_cmdx(n_TERMCAP_CMD_ti
);
698 n_termcap_cmdx(n_TERMCAP_CMD_ks
);
705 n_termcap_suspend(bool_t complete
){
707 if(!(pstate
& PS_TERMCAP_DISABLE
) &&
708 (options
& (OPT_INTERACTIVE
| OPT_QUICKRUN_MASK
)) == OPT_INTERACTIVE
){
709 if(complete
&& (pstate
& PS_TERMCAP_CA_MODE
))
710 n_termcap_cmdx(n_TERMCAP_CMD_ke
);
711 n_termcap_cmdx(n_TERMCAP_CMD_te
);
716 #endif /* HAVE_TERMCAP */
719 n_termcap_cmd(enum n_termcap_cmd cmd
, ssize_t a1
, ssize_t a2
){
720 /* Commands are not lazy queried */
721 struct a_termcap_ent
const *tep
;
722 enum a_termcap_flags flags
;
729 if((options
& (OPT_INTERACTIVE
| OPT_QUICKRUN_MASK
)) != OPT_INTERACTIVE
)
731 assert(a_termcap_g
!= NULL
);
733 flags
= cmd
& ~n__TERMCAP_CMD_MASK
;
734 cmd
&= n__TERMCAP_CMD_MASK
;
735 tep
= a_termcap_g
->tg_ents
;
737 if((flags
& n_TERMCAP_CMD_FLAG_CA_MODE
) && !(pstate
& PS_TERMCAP_CA_MODE
))
739 else if((tep
+= cmd
)->te_flags
== 0 || (tep
->te_flags
& a_TERMCAP_F_NOENT
))
741 else if(!(tep
->te_flags
& a_TERMCAP_F_ALTERN
)){
742 char const *cp
= a_termcap_g
->tg_dat
.s_dat
+ tep
->te_off
;
744 assert((tep
->te_flags
& a_TERMCAP_F_TYPE_MASK
) ==
745 n_TERMCAP_CAPTYPE_STRING
);
748 if(tep
->te_flags
& (a_TERMCAP_F_ARG_IDX1
| a_TERMCAP_F_ARG_IDX2
)){
749 if(pstate
& PS_TERMCAP_DISABLE
){
750 if(options
& OPT_D_V
){
751 char const *cnam
= &a_termcap_namedat
[
752 a_termcap_control
[cmd
].tc_off
];
756 n_err(_("*termcap-disable*d (/$TERM not set/unknown): "
757 "can't perform CAP: %s\n"), cnam
);
762 /* Follow Thomas Dickey's advise on pre-va_arg prototypes, add 0s */
763 # ifdef HAVE_TERMINFO
764 if((cp
= tparm(cp
, a1
, a2
, 0,0,0,0,0,0,0)) == NULL
)
768 * The \fBtgoto\fP function swaps the order of parameters.
769 * It does this also for calls requiring only a single parameter.
770 * In that case, the first parameter is merely a placeholder. */
771 if(!(tep
->te_flags
& a_TERMCAP_F_ARG_IDX2
)){
775 if((cp
= tgoto(cp
, (int)a1
, (int)a2
)) == NULL
)
783 if(!(pstate
& PS_TERMCAP_DISABLE
)){
784 if(tputs(cp
, 1, &a_termcap_putc
) != OK
)
788 if(fputs(cp
, stdout
) == EOF
)
790 if(!(tep
->te_flags
& a_TERMCAP_F_ARG_CNT
) || --a1
<= 0){
803 case n_TERMCAP_CMD_cl
: /* cl = ho + cd */
804 rv
= n_termcap_cmdx(n_TERMCAP_CMD_ho
);
806 rv
= n_termcap_cmdx(n_TERMCAP_CMD_cd
| flags
);
811 case n_TERMCAP_CMD_ce
: /* ce == ch + [:SPC:] */
814 if((rv
= n_termcap_cmd(n_TERMCAP_CMD_ch
, a1
, 0)) > 0){
815 for(a2
= scrnwidth
- a1
- 1; a2
> 0; --a2
)
816 if(putchar(' ') == EOF
){
820 if(rv
&& n_termcap_cmd(n_TERMCAP_CMD_ch
, a1
, -1) != TRU1
)
824 case n_TERMCAP_CMD_ch
: /* ch == cr + nd */
825 rv
= n_termcap_cmdx(n_TERMCAP_CMD_cr
);
826 if(rv
> 0 && a1
> 0){
827 rv
= n_termcap_cmd(n_TERMCAP_CMD_nd
, a1
, -1);
830 #endif /* HAVE_MLE */
834 if(flags
& n_TERMCAP_CMD_FLAG_FLUSH
)
846 n_termcap_query(enum n_termcap_query query
, struct n_termcap_value
*tvp
){
847 /* Queries are lazy queried upon request */
848 struct a_termcap_ent
const *tep
;
855 if((options
& (OPT_INTERACTIVE
| OPT_QUICKRUN_MASK
)) != OPT_INTERACTIVE
)
857 assert(a_termcap_g
!= NULL
);
859 /* Is it a builtin query? */
860 if(query
!= n__TERMCAP_QUERY_MAX
){
861 tep
= &a_termcap_g
->tg_ents
[n__TERMCAP_CMD_MAX
+ query
];
863 if(tep
->te_flags
== 0
865 && ((pstate
& PS_TERMCAP_DISABLE
) ||
866 !a_termcap_ent_query_tcp(UNCONST(tep
),
867 &a_termcap_control
[n__TERMCAP_CMD_MAX
+ query
]))
875 struct a_termcap_ext_ent
*teep
;
876 char const *ndat
= tvp
->tv_data
.tvd_string
;
878 for(teep
= a_termcap_g
->tg_ext_ents
; teep
!= NULL
; teep
= teep
->tee_next
)
879 if(!strcmp(teep
->tee_name
, ndat
)){
880 tep
= &teep
->tee_super
;
885 if(pstate
& PS_TERMCAP_DISABLE
)
889 nlen
= strlen(ndat
) +1;
890 teep
= smalloc(sizeof(*teep
) -
891 VFIELD_SIZEOF(struct a_termcap_ext_ent
, tee_name
) + nlen
);
892 tep
= &teep
->tee_super
;
893 teep
->tee_next
= a_termcap_g
->tg_ext_ents
;
894 a_termcap_g
->tg_ext_ents
= teep
;
895 memcpy(teep
->tee_name
, ndat
, nlen
);
897 if(!a_termcap_ent_query(UNCONST(tep
), ndat
,
898 n_TERMCAP_CAPTYPE_STRING
| a_TERMCAP_F_QUERY
))
904 if(tep
->te_flags
& a_TERMCAP_F_NOENT
)
907 rv
= (tep
->te_flags
& a_TERMCAP_F_ALTERN
) ? TRUM1
: TRU1
;
909 switch((tvp
->tv_captype
= tep
->te_flags
& a_TERMCAP_F_TYPE_MASK
)){
910 case n_TERMCAP_CAPTYPE_BOOL
:
911 tvp
->tv_data
.tvd_bool
= (bool_t
)tep
->te_off
;
913 case n_TERMCAP_CAPTYPE_NUMERIC
:
914 tvp
->tv_data
.tvd_numeric
= (ui32_t
)tep
->te_off
;
917 case n_TERMCAP_CAPTYPE_STRING
:
918 tvp
->tv_data
.tvd_string
= a_termcap_g
->tg_dat
.s_dat
+ tep
->te_off
;
926 #ifdef HAVE_KEY_BINDINGS
928 n_termcap_query_for_name(char const *name
, enum n_termcap_captype type
){
932 if((rv
= a_termcap_query_for_name(name
, strlen(name
))) >= 0){
933 struct a_termcap_control
const *tcp
= &a_termcap_control
[(ui32_t
)rv
];
935 if(type
!= n_TERMCAP_CAPTYPE_NONE
&&
936 (tcp
->tc_flags
& a_TERMCAP_F_TYPE_MASK
) != type
)
939 rv
-= n__TERMCAP_CMD_MAX
;
946 n_termcap_name_of_query(enum n_termcap_query query
){
950 rv
= &a_termcap_namedat
[
951 a_termcap_control
[n__TERMCAP_CMD_MAX
+ query
].tc_off
+ 2];
955 #endif /* HAVE_KEY_BINDINGS */
956 #endif /* n_HAVE_TCAP */