/****************************************************************************
- * Copyright (c) 1998-2017,2018 Free Software Foundation, Inc. *
+ * Copyright 2018-2022,2023 Thomas E. Dickey *
+ * Copyright 1998-2016,2017 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <ctype.h>
#include <tic.h>
-MODULE_ID("$Id: parse_entry.c,v 1.93 2018/04/14 17:41:12 tom Exp $")
+MODULE_ID("$Id: parse_entry.c,v 1.108 2023/04/24 22:32:33 tom Exp $")
#ifdef LINT
static short const parametrized[] =
#if NCURSES_XNAMES
static struct name_table_entry const *
-_nc_extend_names(ENTRY * entryp, char *name, int token_type)
+_nc_extend_names(ENTRY * entryp, const char *name, int token_type)
{
static struct name_table_entry temp;
TERMTYPE2 *tp = &(entryp->tterm);
/* Well, we are given a cancel for a name that we don't recognize */
return _nc_extend_names(entryp, name, STRING);
default:
- return 0;
+ return NULL;
}
/* Adjust the 'offset' (insertion-point) to keep the lists of extended
for (last = (unsigned) (max - 1); last > tindex; last--)
if (!found) {
+ char *saved;
+
+ if ((saved = _nc_save_str(name)) == NULL)
+ return NULL;
+
switch (token_type) {
case BOOLEAN:
tp->ext_Booleans++;
TYPE_REALLOC(char *, actual, tp->ext_Names);
while (--actual > offset)
tp->ext_Names[actual] = tp->ext_Names[actual - 1];
- tp->ext_Names[offset] = _nc_save_str(name);
+ tp->ext_Names[offset] = saved;
}
temp.nte_name = tp->ext_Names[offset];
return &temp;
}
+
+static const char *
+usertype2s(int mask)
+{
+ const char *result = "unknown";
+ if (mask & (1 << BOOLEAN)) {
+ result = "boolean";
+ } else if (mask & (1 << NUMBER)) {
+ result = "number";
+ } else if (mask & (1 << STRING)) {
+ result = "string";
+ }
+ return result;
+}
+
+static bool
+expected_type(const char *name, int token_type, bool silent)
+{
+ struct user_table_entry const *entry = _nc_find_user_entry(name);
+ bool result = TRUE;
+ if ((entry != 0) && (token_type != CANCEL)) {
+ int have_type = (1 << token_type);
+ if (!(entry->ute_type & have_type)) {
+ if (!silent)
+ _nc_warning("expected %s-type for %s, have %s",
+ usertype2s(entry->ute_type),
+ name,
+ usertype2s(have_type));
+ result = FALSE;
+ }
+ }
+ return result;
+}
#endif /* NCURSES_XNAMES */
+/*
+ * A valid entry name uses characters from the "portable character set"
+ * (more commonly referred to as US-ASCII), and disallows some of the
+ * punctuation characters:
+ *
+ * '/' is a pathname separator
+ * '\' may be a pathname separator, but more important, is an escape
+ * '|' delimits names and description
+ * '#' denotes a numeric value
+ * '=' denotes a string value
+ * '@' denotes a cancelled symbol
+ * ',' separates terminfo capabilities
+ * ':' separates termcap capabilities
+ *
+ * Termcap capability names may begin with a '#' or '@' (since they have
+ * exactly two characters).
+ */
static bool
valid_entryname(const char *name)
{
bool result = TRUE;
+ bool first = TRUE;
int ch;
while ((ch = UChar(*name++)) != '\0') {
- if (ch <= ' ' || ch > '~' || ch == '/') {
+ if (ch <= ' ' || ch > '~' || strchr("/\\|=,:", ch) != NULL) {
result = FALSE;
break;
}
+ if (!first && strchr("#@", ch) != NULL) {
+ result = FALSE;
+ break;
+ }
+ first = FALSE;
}
return result;
}
const char *name;
bool bad_tc_usage = FALSE;
+ TR(TRACE_DATABASE,
+ (T_CALLED("_nc_parse_entry(entry=%p, literal=%d, silent=%d)"),
+ (void *) entryp, literal, silent));
+
token_type = _nc_get_token(silent);
if (token_type == EOF)
- return (EOF);
+ returnDB(EOF);
if (token_type != NAMES)
_nc_err_abort("Entry does not start with terminal names in column one");
entryp->tterm.str_table = entryp->tterm.term_names = _nc_save_str(ptr);
if (entryp->tterm.str_table == 0)
- return (ERR);
+ returnDB(ERR);
- DEBUG(1, ("Starting '%s'", ptr));
+ DEBUG(2, ("Starting '%s'", ptr));
/*
* We do this because the one-token lookahead in the parse loop
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) {
+ char *saved;
+
if (!VALID_STRING(_nc_curr_token.tk_valstring)
|| _nc_curr_token.tk_valstring[0] == '\0') {
_nc_warning("missing name for use-clause");
_nc_curr_token.tk_valstring);
continue;
}
- 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
+ if ((saved = _nc_save_str(_nc_curr_token.tk_valstring)) != NULL) {
+ entryp->uses[entryp->nuses].name = saved;
+ entryp->uses[entryp->nuses].line = _nc_curr_line;
+ entryp->nuses++;
+ if (entryp->nuses > 1 && is_tc) {
+ BAD_TC_USAGE
+ }
}
} else {
/* normal token lookup */
_nc_get_hash_table(_nc_syntax));
/*
- * Our kluge to handle aliasing. The reason it's done
+ * Our kluge to handle aliasing. The reason it is 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
* 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);
+ && _nc_user_definable) {
+ if (expected_type(_nc_curr_token.tk_name, token_type, silent)) {
+ if ((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);
+ }
+ }
+ } else {
+ /* ignore it: we have already printed error message */
+ continue;
+ }
}
#endif /* NCURSES_XNAMES */
break;
case NUMBER:
+#if !NCURSES_EXT_NUMBERS
if (_nc_curr_token.tk_valnumber > MAX_NUMBER) {
entryp->tterm.Numbers[entry_ptr->nte_index] = MAX_NUMBER;
- } else {
+ } else
+#endif
+ {
entryp->tterm.Numbers[entry_ptr->nte_index] =
(NCURSES_INT2) _nc_curr_token.tk_valnumber;
}
case STRING:
ptr = _nc_curr_token.tk_valstring;
- if (_nc_syntax == SYN_TERMCAP)
+ if (_nc_syntax == SYN_TERMCAP) {
+ int n = entry_ptr->nte_index;
ptr = _nc_captoinfo(_nc_curr_token.tk_name,
ptr,
- parametrized[entry_ptr->nte_index]);
+ (n < (int) SIZEOF(parametrized))
+ ? parametrized[n]
+ : 0);
+ }
entryp->tterm.Strings[entry_ptr->nte_index] = _nc_save_str(ptr);
break;
}
_nc_wrap_entry(entryp, FALSE);
- return (OK);
+ returnDB(OK);
}
NCURSES_EXPORT(int)
}
static void
-append_acs0(string_desc * dst, int code, int src)
+append_acs0(string_desc * dst, int code, char *src, size_t off)
{
- if (src != 0) {
+ if (src != 0 && off < strlen(src)) {
char temp[3];
temp[0] = (char) code;
- temp[1] = (char) src;
+ temp[1] = src[off];
temp[2] = 0;
_nc_safe_strcat(dst, temp);
}
append_acs(string_desc * dst, int code, char *src)
{
if (VALID_STRING(src) && strlen(src) == 1) {
- append_acs0(dst, code, *src);
+ append_acs0(dst, code, src, 0);
}
}
char buf[MAX_LINE * 2 + 2];
string_desc result;
+ TR(TRACE_DATABASE,
+ (T_CALLED("postprocess_termcap(tp=%p, has_base=%d)"),
+ (void *) tp, has_base));
+
/*
* TERMCAP DEFAULTS AND OBSOLETE-CAPABILITY TRANSLATIONS
*
if (tp->Strings[to_ptr->nte_index]) {
const char *s = tp->Strings[from_ptr->nte_index];
const char *t = tp->Strings[to_ptr->nte_index];
- /* There's no point in warning about it if it's the same
+ /* There's no point in warning about it if it is the same
* string; that's just an inefficiency.
*/
if (VALID_STRING(s) && VALID_STRING(t) && strcmp(s, t) != 0)
&& PRESENT(exit_alt_charset_mode)) {
acs_chars = _nc_save_str(VT_ACSC);
}
+ returnVoidDB;
}
static void
postprocess_terminfo(TERMTYPE2 *tp)
{
+ TR(TRACE_DATABASE,
+ (T_CALLED("postprocess_terminfo(tp=%p)"),
+ (void *) tp));
+
/*
* TERMINFO-TO-TERMINFO MAPPINGS FOR SOURCE TRANSLATION
* ----------------------------------------------------------------------
_nc_str_init(&result, buf2, sizeof(buf2));
_nc_safe_strcat(&result, acs_chars);
- append_acs0(&result, 'l', box_chars_1[0]); /* ACS_ULCORNER */
- append_acs0(&result, 'q', box_chars_1[1]); /* ACS_HLINE */
- append_acs0(&result, 'k', box_chars_1[2]); /* ACS_URCORNER */
- append_acs0(&result, 'x', box_chars_1[3]); /* ACS_VLINE */
- append_acs0(&result, 'j', box_chars_1[4]); /* ACS_LRCORNER */
- append_acs0(&result, 'm', box_chars_1[5]); /* ACS_LLCORNER */
- append_acs0(&result, 'w', box_chars_1[6]); /* ACS_TTEE */
- append_acs0(&result, 'u', box_chars_1[7]); /* ACS_RTEE */
- append_acs0(&result, 'v', box_chars_1[8]); /* ACS_BTEE */
- append_acs0(&result, 't', box_chars_1[9]); /* ACS_LTEE */
- append_acs0(&result, 'n', box_chars_1[10]); /* ACS_PLUS */
+ append_acs0(&result, 'l', box_chars_1, 0); /* ACS_ULCORNER */
+ append_acs0(&result, 'q', box_chars_1, 1); /* ACS_HLINE */
+ append_acs0(&result, 'k', box_chars_1, 2); /* ACS_URCORNER */
+ append_acs0(&result, 'x', box_chars_1, 3); /* ACS_VLINE */
+ append_acs0(&result, 'j', box_chars_1, 4); /* ACS_LRCORNER */
+ append_acs0(&result, 'm', box_chars_1, 5); /* ACS_LLCORNER */
+ append_acs0(&result, 'w', box_chars_1, 6); /* ACS_TTEE */
+ append_acs0(&result, 'u', box_chars_1, 7); /* ACS_RTEE */
+ append_acs0(&result, 'v', box_chars_1, 8); /* ACS_BTEE */
+ append_acs0(&result, 't', box_chars_1, 9); /* ACS_LTEE */
+ append_acs0(&result, 'n', box_chars_1, 10); /* ACS_PLUS */
if (buf2[0]) {
acs_chars = _nc_save_str(buf2);
/*
* ----------------------------------------------------------------------
*/
+ returnVoidDB;
}
/*
projects / ncurses.git / blobdiff