/****************************************************************************
- * Copyright 2018-2019,2020 Thomas E. Dickey *
+ * 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 *
#include <ctype.h>
#include <tic.h>
-MODULE_ID("$Id: parse_entry.c,v 1.99 2020/02/02 23:34:34 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[] =
/* 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];
}
#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
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)
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
* ----------------------------------------------------------------------
/*
* ----------------------------------------------------------------------
*/
+ returnVoidDB;
}
/*