for (token_type = _nc_get_token(silent);
token_type != EOF && token_type != NAMES;
token_type = _nc_get_token(silent)) {
bool is_use = (strcmp(_nc_curr_token.tk_name, "use") == 0);
bool is_tc = !is_use && (strcmp(_nc_curr_token.tk_name, "tc") == 0);
if (is_use || is_tc) {
entryp->uses[entryp->nuses].name = _nc_save_str(_nc_curr_token.tk_valstring);
entryp->uses[entryp->nuses].line = _nc_curr_line;
entryp->nuses++;
if (entryp->nuses > 1 && is_tc) {
BAD_TC_USAGE
}
} else {
/* normal token lookup */
entry_ptr = _nc_find_entry(_nc_curr_token.tk_name,
_nc_syntax ? _nc_cap_hash_table : _nc_info_hash_table);
/*
* Our kluge to handle aliasing. The reason it's done
* this ugly way, with a linear search, is so the hashing
* machinery doesn't have to be made really complicated
* (also we get better warnings this way). No point in
* making this case fast, aliased caps aren't common now
* and will get rarer.
*/
if (entry_ptr == NOTFOUND) {
const struct alias *ap;
if (_nc_syntax == SYN_TERMCAP) {
if (entryp->nuses != 0) {
BAD_TC_USAGE
static void
postprocess_termcap(TERMTYPE * tp, bool has_base)
{
char buf[MAX_LINE * 2 + 2];
string_desc result;
/*
* TERMCAP DEFAULTS AND OBSOLETE-CAPABILITY TRANSLATIONS
*
* This first part of the code is the functional inverse of the
* fragment in capdefaults.c.
* ----------------------------------------------------------------------
*/
/* if there was a tc entry, assume we picked up defaults via that */
if (!has_base) {
if (WANTED(init_3string) && termcap_init2)
init_3string = _nc_save_str(termcap_init2);
if (WANTED(reset_2string) && termcap_reset)
reset_2string = _nc_save_str(termcap_reset);
if (WANTED(carriage_return)) {
if (carriage_return_delay > 0) {
sprintf(buf, "%s$<%d>", C_CR, carriage_return_delay);
carriage_return = _nc_save_str(buf);
} else
carriage_return = _nc_save_str(C_CR);
}
if (WANTED(cursor_left)) {
if (backspace_delay > 0) {
sprintf(buf, "%s$<%d>", C_BS, backspace_delay);
cursor_left = _nc_save_str(buf);
} else if (backspaces_with_bs == 1)
cursor_left = _nc_save_str(C_BS);
else if (PRESENT(backspace_if_not_bs))
cursor_left = backspace_if_not_bs;
}
/* vi doesn't use "do", but it does seems to use nl (or '\n') instead */
if (WANTED(cursor_down)) {
if (PRESENT(linefeed_if_not_lf))
cursor_down = linefeed_if_not_lf;
else if (linefeed_is_newline != 1) {
if (new_line_delay > 0) {
sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
cursor_down = _nc_save_str(buf);
} else
cursor_down = _nc_save_str(C_LF);
}
}
if (WANTED(scroll_forward) && crt_no_scrolling != 1) {
if (PRESENT(linefeed_if_not_lf))
cursor_down = linefeed_if_not_lf;
else if (linefeed_is_newline != 1) {
if (new_line_delay > 0) {
sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
scroll_forward = _nc_save_str(buf);
} else
scroll_forward = _nc_save_str(C_LF);
}
}
if (WANTED(newline)) {
if (linefeed_is_newline == 1) {
if (new_line_delay > 0) {
sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
newline = _nc_save_str(buf);
} else
newline = _nc_save_str(C_LF);
} else if (PRESENT(carriage_return) && PRESENT(scroll_forward)) {
_nc_str_init(&result, buf, sizeof(buf));
if (_nc_safe_strcat(&result, carriage_return)
&& _nc_safe_strcat(&result, scroll_forward))
newline = _nc_save_str(buf);
} else if (PRESENT(carriage_return) && PRESENT(cursor_down)) {
_nc_str_init(&result, buf, sizeof(buf));
if (_nc_safe_strcat(&result, carriage_return)
&& _nc_safe_strcat(&result, cursor_down))
newline = _nc_save_str(buf);
}
}
}
/*
* Inverse of capdefaults.c code ends here.
* ----------------------------------------------------------------------
*
* TERMCAP-TO TERMINFO MAPPINGS FOR SOURCE TRANSLATION
*
* These translations will *not* be inverted by tgetent().
*/
if (!has_base) {
/*
* We wait until now to decide if we've got a working cr because even
* one that doesn't work can be used for newline. Unfortunately the
* space allocated for it is wasted.
*/
if (return_does_clr_eol == 1 || no_correctly_working_cr == 1)
carriage_return = ABSENT_STRING;
/*
* Supposedly most termcap entries have ta now and '\t' is no longer a
* default, but it doesn't seem to be true...
*/
if (WANTED(tab)) {
if (horizontal_tab_delay > 0) {
sprintf(buf, "%s$<%d>", C_HT, horizontal_tab_delay);
tab = _nc_save_str(buf);
} else
tab = _nc_save_str(C_HT);
}
if (init_tabs == ABSENT_NUMERIC && has_hardware_tabs == TRUE)
init_tabs = 8;
/*
* Assume we can beep with ^G unless we're given bl@.
*/
if (WANTED(bell))
bell = _nc_save_str("\007");
}
/*
* Translate the old termcap :pt: capability to it#8 + ht=\t
*/
if (has_hardware_tabs == TRUE) {
if (init_tabs != 8 && init_tabs != ABSENT_NUMERIC)
_nc_warning("hardware tabs with a width other than 8: %d", init_tabs);
else {
if (tab && _nc_capcmp(tab, C_HT))
_nc_warning("hardware tabs with a non-^I tab string %s",
_nc_visbuf(tab));
else {
if (WANTED(tab))
tab = _nc_save_str(C_HT);
init_tabs = 8;
}
}
}
/*
* Now translate the ko capability, if there is one. This
* isn't from mytinfo...
*/
if (PRESENT(other_non_function_keys)) {
char *base = other_non_function_keys;
char *bp, *cp, *dp;
struct name_table_entry const *from_ptr;
struct name_table_entry const *to_ptr;
assoc const *ap;
char buf2[MAX_TERMINFO_LENGTH];
bool foundim;
/* we're going to use this for a special case later */
dp = strchr(other_non_function_keys, 'i');
foundim = (dp != 0) && (dp[1] == 'm');
/* look at each comma-separated capability in the ko string... */
for (base = other_non_function_keys;
(cp = strchr(base, ',')) != 0;
base = cp + 1) {
size_t len = cp - base;
for (ap = ko_xlate; ap->from; ap++)
if (len == strlen(ap->from)
&& strncmp(ap->from, base, len) == 0)
break;
if (!ap->to) {
_nc_warning("unknown capability `%.*s' in ko string",
(int) len, base);
continue;
} else if (ap->to == CANCELLED_STRING) /* ignore it */
continue;
/* now we know we found a match in ko_table, so... */
from_ptr = _nc_find_entry(ap->from, _nc_cap_hash_table);
to_ptr = _nc_find_entry(ap->to, _nc_info_hash_table);
if (!from_ptr || !to_ptr) /* should never happen! */
_nc_err_abort("ko translation table is invalid, I give up");
if (WANTED(tp->Strings[from_ptr->nte_index])) {
_nc_warning("no value for ko capability %s", ap->from);
continue;
}
if (tp->Strings[to_ptr->nte_index]) {
/* There's no point in warning about it if it's the same
* string; that's just an inefficiency.
*/
if (strcmp(
tp->Strings[from_ptr->nte_index],
tp->Strings[to_ptr->nte_index]) != 0)
_nc_warning("%s (%s) already has an explicit value %s, ignoring ko",
ap->to, ap->from,
_nc_visbuf(tp->Strings[to_ptr->nte_index]));
continue;
}
/*
* The magic moment -- copy the mapped key string over,
* stripping out padding.
*/
for (dp = buf2, bp = tp->Strings[from_ptr->nte_index]; *bp; bp++) {
if (bp[0] == '$' && bp[1] == '<') {
while (*bp && *bp != '>') {
++bp;
}
} else
*dp++ = *bp;
}
*dp++ = '\0';
tp->Strings[to_ptr->nte_index] = _nc_save_str(buf2);
}
/*
* Note: ko=im and ko=ic both want to grab the `Insert'
* keycap. There's a kich1 but no ksmir, so the ic capability
* got mapped to kich1 and im to kIC to avoid a collision.
* If the description has im but not ic, hack kIC back to kich1.
*/
if (foundim && WANTED(key_ic) && key_sic) {
key_ic = key_sic;
key_sic = ABSENT_STRING;
}
}
if (!hard_copy) {
if (WANTED(key_backspace))
key_backspace = _nc_save_str(C_BS);
if (WANTED(key_left))
key_left = _nc_save_str(C_BS);
if (WANTED(key_down))
key_down = _nc_save_str(C_LF);
}
/*
* Translate XENIX forms characters.
*/
if (PRESENT(acs_ulcorner) ||
PRESENT(acs_llcorner) ||
PRESENT(acs_urcorner) ||
PRESENT(acs_lrcorner) ||
PRESENT(acs_ltee) ||
PRESENT(acs_rtee) ||
PRESENT(acs_btee) ||
PRESENT(acs_ttee) ||
PRESENT(acs_hline) ||
PRESENT(acs_vline) ||
PRESENT(acs_plus)) {
char buf2[MAX_TERMCAP_LENGTH];
_nc_str_init(&result, buf2, sizeof(buf2));
_nc_safe_strcat(&result, acs_chars);
append_acs (&result, 'j', acs_lrcorner);
append_acs (&result, 'k', acs_urcorner);
append_acs (&result, 'l', acs_ulcorner);
append_acs (&result, 'm', acs_llcorner);
append_acs (&result, 'n', acs_plus);
append_acs (&result, 'q', acs_hline);
append_acs (&result, 't', acs_ltee);
append_acs (&result, 'u', acs_rtee);
append_acs (&result, 'v', acs_btee);
append_acs (&result, 'w', acs_ttee);
append_acs (&result, 'x', acs_vline);
if (buf2[0]) {
acs_chars = _nc_save_str(buf2);
_nc_warning("acsc string synthesized from XENIX capabilities");
}
} else if (acs_chars == 0
&& enter_alt_charset_mode != 0
&& exit_alt_charset_mode != 0) {
acs_chars =
_nc_save_str("``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~");
}
}
int
_nc_parse_entry(struct entry *entryp, int literal, bool silent)
{
int token_type;
struct name_table_entry const *entry_ptr;
char *ptr, *base;
token_type = _nc_get_token();
if (token_type == EOF)
return (EOF);
if (token_type != NAMES)
_nc_err_abort("Entry does not start with terminal names in column one");
_nc_init_entry(&entryp->tterm);
entryp->cstart = _nc_comment_start;
entryp->cend = _nc_comment_end;
entryp->startline = _nc_start_line;
DEBUG(2, ("Comment range is %ld to %ld", entryp->cstart, entryp->cend));
/* junk the 2-character termcap name, if present */
ptr = _nc_curr_token.tk_name;
if (ptr[2] == '|') {
ptr = _nc_curr_token.tk_name + 3;
_nc_curr_token.tk_name[2] = '\0';
}
entryp->tterm.str_table = entryp->tterm.term_names = _nc_save_str(ptr);
DEBUG(1, ("Starting '%s'", ptr));
/*
* We do this because the one-token lookahead in the parse loop
* results in the terminal type getting prematurely set to correspond
* to that of the next entry.
*/
_nc_set_type(_nc_first_name(entryp->tterm.term_names));
/* check for overly-long names and aliases */
for (base = entryp->tterm.term_names; (ptr = strchr(base, '|')) != 0;
base = ptr + 1) {
if (ptr - base > MAX_ALIAS) {
_nc_warning("%s `%.*s' may be too long",
(base == entryp->tterm.term_names)
? "primary name"
: "alias",
ptr - base, base);
}
}
entryp->nuses = 0;
for (token_type = _nc_get_token();
token_type != EOF && token_type != NAMES;
token_type = _nc_get_token()) {
if (strcmp(_nc_curr_token.tk_name, "use") == 0
|| strcmp(_nc_curr_token.tk_name, "tc") == 0) {
entryp->uses[entryp->nuses].name = _nc_save_str(_nc_curr_token.tk_valstring);
entryp->uses[entryp->nuses].line = _nc_curr_line;
entryp->nuses++;
} else {
/* normal token lookup */
entry_ptr = _nc_find_entry(_nc_curr_token.tk_name,
_nc_syntax ? _nc_cap_hash_table : _nc_info_hash_table);
/*
* Our kluge to handle aliasing. The reason it's done
* this ugly way, with a linear search, is so the hashing
* machinery doesn't have to be made really complicated
* (also we get better warnings this way). No point in
* making this case fast, aliased caps aren't common now
* and will get rarer.
*/
if (entry_ptr == NOTFOUND) {
const struct alias *ap;
if (_nc_syntax == SYN_TERMCAP) {
for (ap = _nc_capalias_table; ap->from; ap++)
if (strcmp(ap->from, _nc_curr_token.tk_name) == 0) {
if (ap->to == (char *) 0) {
_nc_warning("%s (%s termcap extension) ignored",
ap->from, ap->source);
goto nexttok;
}
entry_ptr = _nc_find_entry(ap->to, _nc_cap_hash_table);
if (entry_ptr && !silent)
_nc_warning("%s (%s termcap extension) aliased to %s",
ap->from, ap->source, ap->to);
break;
}
} else { /* if (_nc_syntax == SYN_TERMINFO) */
for (ap = _nc_infoalias_table; ap->from; ap++)
if (strcmp(ap->from, _nc_curr_token.tk_name) == 0) {
if (ap->to == (char *) 0) {
_nc_warning("%s (%s terminfo extension) ignored",
ap->from, ap->source);
goto nexttok;
}
entry_ptr = _nc_find_entry(ap->to, _nc_info_hash_table);
if (entry_ptr && !silent)
_nc_warning("%s (%s terminfo extension) aliased to %s",
ap->from, ap->source, ap->to);
break;
}
if (entry_ptr == NOTFOUND) {
entry_ptr = lookup_fullname(_nc_curr_token.tk_name);
}
}
}
#if NCURSES_XNAMES
/*
* If we have extended-names active, we will automatically
* define a name based on its context.
*/
if (entry_ptr == NOTFOUND
&& _nc_user_definable
&& (entry_ptr = _nc_extend_names(entryp,
_nc_curr_token.tk_name,
token_type)) != 0) {
if (_nc_tracing >= DEBUG_LEVEL(1))
_nc_warning("extended capability '%s'", _nc_curr_token.tk_name);
}
#endif /* NCURSES_XNAMES */
/* can't find this cap name, not even as an alias */
if (entry_ptr == NOTFOUND) {
if (!silent)
_nc_warning("unknown capability '%s'",
_nc_curr_token.tk_name);
continue;
}
/* deal with bad type/value combinations. */
if (token_type != CANCEL && entry_ptr->nte_type != token_type) {
/*
* Nasty special cases here handle situations in which type
* information can resolve name clashes. Normal lookup
* finds the last instance in the capability table of a
* given name, regardless of type. find_type_entry looks
* for a first matching instance with given type. So as
* long as all ambiguous names occur in pairs of distinct
* type, this will do the job.
*/
/* tell max_attributes from arrow_key_map */
if (token_type == NUMBER && !strcmp("ma", _nc_curr_token.tk_name))
entry_ptr = _nc_find_type_entry("ma", NUMBER,
_nc_get_table(_nc_syntax
!= 0));
/* map terminfo's string MT to MT */
else if (token_type == STRING && !strcmp("MT", _nc_curr_token.tk_name))
entry_ptr = _nc_find_type_entry("MT", STRING,
_nc_get_table(_nc_syntax
!= 0));
/* treat strings without following "=" as empty strings */
else if (token_type == BOOLEAN && entry_ptr->nte_type == STRING)
token_type = STRING;
/* we couldn't recover; skip this token */
else {
if (!silent) {
const char *type_name;
switch (entry_ptr->nte_type) {
case BOOLEAN:
type_name = "boolean";
break;
case STRING:
type_name = "string";
break;
case NUMBER:
type_name = "numeric";
break;
default:
type_name = "unknown";
break;
}
_nc_warning("wrong type used for %s capability '%s'",
type_name, _nc_curr_token.tk_name);
}
continue;
}
}
/* now we know that the type/value combination is OK */
switch (token_type) {
case CANCEL:
switch (entry_ptr->nte_type) {
case BOOLEAN:
entryp->tterm.Booleans[entry_ptr->nte_index] = CANCELLED_BOOLEAN;
break;
case NUMBER:
entryp->tterm.Numbers[entry_ptr->nte_index] = CANCELLED_NUMERIC;
break;
case STRING:
entryp->tterm.Strings[entry_ptr->nte_index] = CANCELLED_STRING;
break;
}
break;
case BOOLEAN:
entryp->tterm.Booleans[entry_ptr->nte_index] = TRUE;
break;
case NUMBER:
entryp->tterm.Numbers[entry_ptr->nte_index] =
_nc_curr_token.tk_valnumber;
break;
case STRING:
ptr = _nc_curr_token.tk_valstring;
if (_nc_syntax == SYN_TERMCAP)
ptr = _nc_captoinfo(_nc_curr_token.tk_name,
ptr,
parametrized[entry_ptr->nte_index]);
entryp->tterm.Strings[entry_ptr->nte_index] = _nc_save_str(ptr);
break;
default:
if (!silent)
_nc_warning("unknown token type");
_nc_panic_mode((_nc_syntax == SYN_TERMCAP) ? ':' : ',');
continue;
}
} /* end else cur_token.name != "use" */
nexttok:
continue; /* cannot have a label w/o statement */
} /* endwhile (not EOF and not NAMES) */
_nc_push_token(token_type);
_nc_set_type(_nc_first_name(entryp->tterm.term_names));
/*
* Try to deduce as much as possible from extension capabilities
* (this includes obsolete BSD capabilities). Sigh...it would be more
* space-efficient to call this after use resolution, but it has
* to be done before entry allocation is wrapped up.
*/
if (!literal) {
if (_nc_syntax == SYN_TERMCAP) {
bool has_base_entry = FALSE;
int i;
/*
* Don't insert defaults if this is a `+' entry meant only
* for inclusion in other entries (not sure termcap ever
* had these, actually).
*/
if (strchr(entryp->tterm.term_names, '+'))
has_base_entry = TRUE;
else
/*
* Otherwise, look for a base entry that will already
* have picked up defaults via translation.
*/
for (i = 0; i < entryp->nuses; i++)
if (!strchr((char *) entryp->uses[i].name, '+'))
has_base_entry = TRUE;
postprocess_termcap(&entryp->tterm, has_base_entry);
} else
postprocess_terminfo(&entryp->tterm);
}
_nc_wrap_entry(entryp);
return (OK);
}
static int
tput(int argc, char *argv[])
{
NCURSES_CONST char *name;
char *s;
int i, j, c;
int status;
FILE *f;
#if !PURE_TERMINFO
bool termcap = FALSE;
#endif
if ((name = argv[0]) == 0)
name = "";
check_aliases(name);
if (is_reset || is_init) {
if (init_prog != 0) {
system(init_prog);
}
FLUSH;
if (is_reset && reset_1string != 0) {
PUTS(reset_1string);
} else if (init_1string != 0) {
PUTS(init_1string);
}
FLUSH;
if (is_reset && reset_2string != 0) {
PUTS(reset_2string);
} else if (init_2string != 0) {
PUTS(init_2string);
}
FLUSH;
#ifdef set_lr_margin
if (set_lr_margin != 0) {
PUTS(TPARM_2(set_lr_margin, 0, columns - 1));
} else
#endif
#ifdef set_left_margin_parm
if (set_left_margin_parm != 0
&& set_right_margin_parm != 0) {
PUTS(TPARM_1(set_left_margin_parm, 0));
PUTS(TPARM_1(set_right_margin_parm, columns - 1));
} else
#endif
if (clear_margins != 0
&& set_left_margin != 0
&& set_right_margin != 0) {
PUTS(clear_margins);
if (carriage_return != 0) {
PUTS(carriage_return);
} else {
PUTCHAR('\r');
}
PUTS(set_left_margin);
if (parm_right_cursor) {
PUTS(TPARM_1(parm_right_cursor, columns - 1));
} else {
for (i = 0; i < columns - 1; i++) {
PUTCHAR(' ');
}
}
PUTS(set_right_margin);
if (carriage_return != 0) {
PUTS(carriage_return);
} else {
PUTCHAR('\r');
}
}
FLUSH;
if (init_tabs != 8) {
if (clear_all_tabs != 0 && set_tab != 0) {
for (i = 0; i < columns - 1; i += 8) {
if (parm_right_cursor) {
PUTS(TPARM_1(parm_right_cursor, 8));
} else {
for (j = 0; j < 8; j++)
PUTCHAR(' ');
}
PUTS(set_tab);
}
FLUSH;
}
}
if (is_reset && reset_file != 0) {
f = fopen(reset_file, "r");
if (f == 0) {
quit(4 + errno, "Can't open reset_file: '%s'", reset_file);
}
while ((c = fgetc(f)) != EOF) {
PUTCHAR(c);
}
fclose(f);
} else if (init_file != 0) {
f = fopen(init_file, "r");
if (f == 0) {
quit(4 + errno, "Can't open init_file: '%s'", init_file);
}
while ((c = fgetc(f)) != EOF) {
PUTCHAR(c);
}
fclose(f);
}
FLUSH;
if (is_reset && reset_3string != 0) {
PUTS(reset_3string);
} else if (init_3string != 0) {
PUTS(init_3string);
}
FLUSH;
return 0;
}
if (strcmp(name, "longname") == 0) {
PUTS(longname());
return 0;
}
#if !PURE_TERMINFO
retry:
#endif
if ((status = tigetflag(name)) != -1) {
return exit_code(BOOLEAN, status);
} else if ((status = tigetnum(name)) != CANCELLED_NUMERIC) {
(void) printf("%d\n", status);
return exit_code(NUMBER, 0);
} else if ((s = tigetstr(name)) == CANCELLED_STRING) {
#if !PURE_TERMINFO
if (!termcap) {
const struct name_table_entry *np;
termcap = TRUE;
if ((np = _nc_find_entry(name, _nc_get_hash_table(termcap))) != 0) {
switch (np->nte_type) {
case BOOLEAN:
if (bool_from_termcap[np->nte_index])
name = boolnames[np->nte_index];
break;
case NUMBER:
if (num_from_termcap[np->nte_index])
name = numnames[np->nte_index];
break;
case STRING:
if (str_from_termcap[np->nte_index])
name = strnames[np->nte_index];
break;
}
goto retry;
}
}
#endif
quit(4, "unknown terminfo capability '%s'", name);
} else if (s != ABSENT_STRING) {
if (argc > 1) {
int k;
int popcount;
long numbers[1 + NUM_PARM];
char *strings[1 + NUM_PARM];
char *p_is_s[NUM_PARM];
/* Nasty hack time. The tparm function needs to see numeric
* parameters as numbers, not as pointers to their string
* representations
*/
for (k = 1; k < argc; k++) {
char *tmp = 0;
strings[k] = argv[k];
numbers[k] = strtol(argv[k], &tmp, 0);
if (tmp == 0 || *tmp != 0)
numbers[k] = 0;
}
for (k = argc; k <= NUM_PARM; k++) {
numbers[k] = 0;
strings[k] = 0;
}
switch (tparm_type(name)) {
case Num_Str:
s = TPARM_2(s, numbers[1], strings[2]);
break;
case Num_Str_Str:
s = TPARM_3(s, numbers[1], strings[2], strings[3]);
break;
case Numbers:
default:
(void) _nc_tparm_analyze(s, p_is_s, &popcount);
#define myParam(n) (p_is_s[n - 1] != 0 ? ((TPARM_ARG) strings[n]) : numbers[n])
s = TPARM_9(s,
myParam(1),
myParam(2),
myParam(3),
myParam(4),
myParam(5),
myParam(6),
myParam(7),
myParam(8),
myParam(9));
break;
}
}
/* use putp() in order to perform padding */
putp(s);
return exit_code(STRING, 0);
}
return exit_code(STRING, 1);
}
for (token_type = _nc_get_token(silent);
token_type != EOF && token_type != NAMES;
token_type = _nc_get_token(silent)) {
bool is_use = (strcmp(_nc_curr_token.tk_name, "use") == 0);
bool is_tc = !is_use && (strcmp(_nc_curr_token.tk_name, "tc") == 0);
if (is_use || is_tc) {
entryp->uses[entryp->nuses].name = _nc_save_str(_nc_curr_token.tk_valstring);
entryp->uses[entryp->nuses].line = _nc_curr_line;
entryp->nuses++;
if (entryp->nuses > 1 && is_tc) {
BAD_TC_USAGE
}
} else {
/* normal token lookup */
entry_ptr = _nc_find_entry(_nc_curr_token.tk_name,
_nc_get_hash_table(_nc_syntax));
/*
* Our kluge to handle aliasing. The reason it's done
* this ugly way, with a linear search, is so the hashing
* machinery doesn't have to be made really complicated
* (also we get better warnings this way). No point in
* making this case fast, aliased caps aren't common now
* and will get rarer.
*/
if (entry_ptr == NOTFOUND) {
const struct alias *ap;
if (_nc_syntax == SYN_TERMCAP) {
if (entryp->nuses != 0) {
BAD_TC_USAGE
static int
tput(int argc, char *argv[])
{
NCURSES_CONST char *name;
char *s;
int i, j, c;
int status;
FILE *f;
check_aliases(name = argv[0]);
if (is_reset || is_init) {
if (init_prog != 0) {
system(init_prog);
}
FLUSH;
if (is_reset && reset_1string != 0) {
PUTS(reset_1string);
} else if (init_1string != 0) {
PUTS(init_1string);
}
FLUSH;
if (is_reset && reset_2string != 0) {
PUTS(reset_2string);
} else if (init_2string != 0) {
PUTS(init_2string);
}
FLUSH;
if (set_lr_margin != 0) {
PUTS(tparm(set_lr_margin, 0, columns - 1));
} else if (set_left_margin_parm != 0
&& set_right_margin_parm != 0) {
PUTS(tparm(set_left_margin_parm, 0));
PUTS(tparm(set_right_margin_parm, columns - 1));
} else if (clear_margins != 0
&& set_left_margin != 0
&& set_right_margin != 0) {
PUTS(clear_margins);
if (carriage_return != 0) {
PUTS(carriage_return);
} else {
PUTCHAR('\r');
}
PUTS(set_left_margin);
if (parm_right_cursor) {
PUTS(tparm(parm_right_cursor, columns - 1));
} else {
for (i = 0; i < columns - 1; i++) {
PUTCHAR(' ');
}
}
PUTS(set_right_margin);
if (carriage_return != 0) {
PUTS(carriage_return);
} else {
PUTCHAR('\r');
}
}
FLUSH;
if (init_tabs != 8) {
if (clear_all_tabs != 0 && set_tab != 0) {
for (i = 0; i < columns - 1; i += 8) {
if (parm_right_cursor) {
PUTS(tparm(parm_right_cursor, 8));
} else {
for (j = 0; j < 8; j++)
PUTCHAR(' ');
}
PUTS(set_tab);
}
FLUSH;
}
}
if (is_reset && reset_file != 0) {
f = fopen(reset_file, "r");
if (f == 0) {
quit(errno, "Can't open reset_file: '%s'", reset_file);
}
while ((c = fgetc(f)) != EOF) {
PUTCHAR(c);
}
fclose(f);
} else if (init_file != 0) {
f = fopen(init_file, "r");
if (f == 0) {
quit(errno, "Can't open init_file: '%s'", init_file);
}
while ((c = fgetc(f)) != EOF) {
PUTCHAR(c);
}
fclose(f);
}
FLUSH;
if (is_reset && reset_3string != 0) {
PUTS(reset_3string);
} else if (init_2string != 0) {
PUTS(init_2string);
}
FLUSH;
return 0;
}
if (strcmp(name, "longname") == 0) {
PUTS(longname());
return 0;
}
#if !PURE_TERMINFO
{
const struct name_table_entry *np;
if ((np = _nc_find_entry(name, _nc_get_hash_table(1))) != 0)
switch (np->nte_type) {
case BOOLEAN:
if (bool_from_termcap[np->nte_index])
name = boolnames[np->nte_index];
break;
case NUMBER:
if (num_from_termcap[np->nte_index])
name = numnames[np->nte_index];
break;
case STRING:
if (str_from_termcap[np->nte_index])
name = strnames[np->nte_index];
break;
}
}
#endif
if ((status = tigetflag(name)) != -1) {
return (status != 0);
} else if ((status = tigetnum(name)) != CANCELLED_NUMERIC) {
(void) printf("%d\n", status);
return (0);
} else if ((s = tigetstr(name)) == CANCELLED_STRING) {
quit(4, "%s: unknown terminfo capability '%s'", prg_name, name);
} else if (s != ABSENT_STRING) {
if (argc > 1) {
int k;
int numbers[10];
char *strings[10];
/* Nasty hack time. The tparm function needs to see numeric
* parameters as numbers, not as pointers to their string
* representations
*/
for (k = 1; k < argc; k++) {
char *tmp = 0;
strings[k] = argv[k];
numbers[k] = strtol(argv[k], &tmp, 0);
if (tmp == 0 || *tmp != 0)
numbers[k] = 0;
}
for (k = argc; k <= 9; k++) {
numbers[k] = 0;
strings[k] = 0;
}
switch (tparm_type(name)) {
case Num_Str:
s = tparm(s, numbers[1], strings[2]);
break;
case Num_Str_Str:
s = tparm(s, numbers[1], strings[2], strings[3]);
break;
default:
s = tparm(s,
numbers[1], numbers[2], numbers[3],
numbers[4], numbers[5], numbers[6],
numbers[7], numbers[8], numbers[9]);
break;
}
}
/* use putp() in order to perform padding */
putp(s);
return (0);
}
return (0);
}
