/****************************************************************************
- * Copyright (c) 1998-2016,2017 Free Software Foundation, Inc. *
+ * Copyright (c) 1998-2018,2019 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 <tic.h>
-MODULE_ID("$Id: read_entry.c,v 1.142 2017/03/16 08:19:06 tom Exp $")
+MODULE_ID("$Id: read_entry.c,v 1.152 2019/01/21 14:56:40 tom Exp $")
#define TYPE_CALLOC(type,elts) typeCalloc(type, (unsigned)(elts))
#define MyNumber(n) (short) LOW_MSB(n)
+#define SIZEOF_32BITS 4
+
#if NCURSES_USE_DATABASE
-static void
-convert_shorts(char *buf, short *Numbers, int count)
+#if NCURSES_EXT_NUMBERS
+static size_t
+convert_16bits(char *buf, NCURSES_INT2 *Numbers, int count)
+{
+ int i;
+ size_t j;
+ size_t size = SIZEOF_SHORT;
+ for (i = 0; i < count; i++) {
+ unsigned mask = 0xff;
+ unsigned char ch = 0;
+ Numbers[i] = 0;
+ for (j = 0; j < size; ++j) {
+ ch = UChar(*buf++);
+ Numbers[i] |= (ch << (8 * j));
+ mask <<= 8;
+ }
+ if (ch & 0x80) {
+ while (mask != 0) {
+ Numbers[i] |= (int) mask;
+ mask <<= 8;
+ }
+ }
+ TR(TRACE_DATABASE, ("get Numbers[%d]=%d", i, Numbers[i]));
+ }
+ return size;
+}
+
+static size_t
+convert_32bits(char *buf, NCURSES_INT2 *Numbers, int count)
+{
+ int i;
+ size_t j;
+ size_t size = SIZEOF_INT2;
+ unsigned char ch;
+
+ assert(sizeof(NCURSES_INT2) == size);
+ for (i = 0; i < count; i++) {
+ Numbers[i] = 0;
+ for (j = 0; j < size; ++j) {
+ ch = UChar(*buf++);
+ Numbers[i] |= (ch << (8 * j));
+ }
+ /* "unsigned" and NCURSES_INT2 are the same size - no sign-extension */
+ TR(TRACE_DATABASE, ("get Numbers[%d]=%d", i, Numbers[i]));
+ }
+ return size;
+}
+#else
+static size_t
+convert_32bits(char *buf, NCURSES_INT2 *Numbers, int count)
+{
+ int i, j;
+ unsigned char ch;
+ for (i = 0; i < count; i++) {
+ int value = 0;
+ for (j = 0; j < SIZEOF_32BITS; ++j) {
+ ch = UChar(*buf++);
+ value |= (ch << (8 * j));
+ }
+ if (value == -1)
+ Numbers[i] = ABSENT_NUMERIC;
+ else if (value == -2)
+ Numbers[i] = CANCELLED_NUMERIC;
+ else if (value > MAX_OF_TYPE(NCURSES_INT2))
+ Numbers[i] = MAX_OF_TYPE(NCURSES_INT2);
+ else
+ Numbers[i] = (short) value;
+ TR(TRACE_DATABASE, ("get Numbers[%d]=%d", i, Numbers[i]));
+ }
+ return SIZEOF_SHORT;
+}
+
+static size_t
+convert_16bits(char *buf, NCURSES_INT2 *Numbers, int count)
{
int i;
for (i = 0; i < count; i++) {
Numbers[i] = MyNumber(buf + 2 * i);
TR(TRACE_DATABASE, ("get Numbers[%d]=%d", i, Numbers[i]));
}
+ return SIZEOF_SHORT;
}
+#endif
static void
convert_strings(char *buf, char **Strings, int count, int size, char *table)
#define Read(buf, count) fake_read(buffer, &offset, limit, (char *) buf, (unsigned) count)
#define read_shorts(buf, count) \
- (Read(buf, (count)*2) == (int) (count)*2)
+ (Read(buf, (count)*SIZEOF_SHORT) == (int) (count)*SIZEOF_SHORT)
+
+#define read_numbers(buf, count) \
+ (Read(buf, (count)*(unsigned)size_of_numbers) == (int) (count)*size_of_numbers)
#define even_boundary(value) \
if ((value) % 2 != 0) Read(buf, 1)
#endif
NCURSES_EXPORT(void)
-_nc_init_termtype(TERMTYPE *const tp)
+_nc_init_termtype(TERMTYPE2 *const tp)
{
unsigned i;
if (tp->Booleans == 0)
TYPE_MALLOC(NCURSES_SBOOL, BOOLCOUNT, tp->Booleans);
if (tp->Numbers == 0)
- TYPE_MALLOC(short, NUMCOUNT, tp->Numbers);
+ TYPE_MALLOC(NCURSES_INT2, NUMCOUNT, tp->Numbers);
if (tp->Strings == 0)
TYPE_MALLOC(char *, STRCOUNT, tp->Strings);
* Return TGETENT_YES if read, TGETENT_NO if not found or garbled.
*/
NCURSES_EXPORT(int)
-_nc_read_termtype(TERMTYPE *ptr, char *buffer, int limit)
+_nc_read_termtype(TERMTYPE2 *ptr, char *buffer, int limit)
{
int offset = 0;
int name_size, bool_count, num_count, str_count, str_size;
char buf[MAX_ENTRY_SIZE + 2];
char *string_table;
unsigned want, have;
+ bool need_ints;
+ size_t (*convert_numbers) (char *, NCURSES_INT2 *, int);
+ int size_of_numbers;
+ int max_entry_size = MAX_ENTRY_SIZE;
TR(TRACE_DATABASE,
(T_CALLED("_nc_read_termtype(ptr=%p, buffer=%p, limit=%d)"),
|| !IS_TIC_MAGIC(buf)) {
returnDB(TGETENT_NO);
}
+#if NCURSES_EXT_NUMBERS
+ if ((need_ints = (LOW_MSB(buf) == MAGIC2))) {
+ convert_numbers = convert_32bits;
+ size_of_numbers = SIZEOF_INT2;
+ } else {
+ max_entry_size = MAX_ENTRY_SIZE1;
+ convert_numbers = convert_16bits;
+ size_of_numbers = SIZEOF_SHORT;
+ }
+#else
+ if ((need_ints = (LOW_MSB(buf) == MAGIC2))) {
+ convert_numbers = convert_32bits;
+ size_of_numbers = SIZEOF_32BITS;
+ } else {
+ convert_numbers = convert_16bits;
+ size_of_numbers = SIZEOF_INT2;
+ }
+#endif
/* *INDENT-EQLS* */
name_size = MyNumber(buf + 2);
want = (unsigned) (str_size + name_size + 1);
/* try to allocate space for the string table */
- if (str_count * 2 >= MAX_ENTRY_SIZE
+ if (str_count * SIZEOF_SHORT >= max_entry_size
|| (string_table = typeMalloc(char, want)) == 0) {
returnDB(TGETENT_NO);
}
even_boundary(name_size + bool_count);
/* grab the numbers */
- if ((ptr->Numbers = TYPE_CALLOC(short, max(NUMCOUNT, num_count))) == 0
- || !read_shorts(buf, num_count)) {
+ if (!(ptr->Numbers = TYPE_CALLOC(NCURSES_INT2, max(NUMCOUNT, num_count)))
+ || !read_numbers(buf, num_count)) {
returnDB(TGETENT_NO);
}
- convert_shorts(buf, ptr->Numbers, num_count);
+ convert_numbers(buf, ptr->Numbers, num_count);
if ((ptr->Strings = TYPE_CALLOC(char *, max(STRCOUNT, str_count))) == 0) {
returnDB(TGETENT_NO);
int ext_bool_count = MyNumber(buf + 0);
int ext_num_count = MyNumber(buf + 2);
int ext_str_count = MyNumber(buf + 4);
- int ext_str_size = MyNumber(buf + 6);
+ int ext_str_usage = MyNumber(buf + 6);
int ext_str_limit = MyNumber(buf + 8);
unsigned need = (unsigned) (ext_bool_count + ext_num_count + ext_str_count);
int base = 0;
- if (need >= (MAX_ENTRY_SIZE / 2)
- || ext_str_size >= MAX_ENTRY_SIZE
- || ext_str_limit >= MAX_ENTRY_SIZE
+ if ((int) need >= (max_entry_size / 2)
+ || ext_str_usage >= max_entry_size
+ || ext_str_limit >= max_entry_size
|| ext_bool_count < 0
|| ext_num_count < 0
|| ext_str_count < 0
- || ext_str_size < 0
+ || ext_str_usage < 0
|| ext_str_limit < 0) {
returnDB(TGETENT_NO);
}
ptr->num_Strings = UShort(STRCOUNT + ext_str_count);
TYPE_REALLOC(NCURSES_SBOOL, ptr->num_Booleans, ptr->Booleans);
- TYPE_REALLOC(short, ptr->num_Numbers, ptr->Numbers);
+ TYPE_REALLOC(NCURSES_INT2, ptr->num_Numbers, ptr->Numbers);
TYPE_REALLOC(char *, ptr->num_Strings, ptr->Strings);
- TR(TRACE_DATABASE, ("extended header is %d/%d/%d(%d:%d)",
- ext_bool_count, ext_num_count, ext_str_count,
- ext_str_size, ext_str_limit));
+ TR(TRACE_DATABASE, ("extended header: "
+ "bool %d, "
+ "number %d, "
+ "string %d(%d:%d)",
+ ext_bool_count,
+ ext_num_count,
+ ext_str_count,
+ ext_str_usage,
+ ext_str_limit));
TR(TRACE_DATABASE, ("READ %d extended-booleans @%d",
ext_bool_count, offset));
TR(TRACE_DATABASE, ("READ %d extended-numbers @%d",
ext_num_count, offset));
if ((ptr->ext_Numbers = UShort(ext_num_count)) != 0) {
- if (!read_shorts(buf, ext_num_count)) {
+ if (!read_numbers(buf, ext_num_count)) {
returnDB(TGETENT_NO);
}
TR(TRACE_DATABASE, ("Before converting extended-numbers"));
- convert_shorts(buf, ptr->Numbers + NUMCOUNT, ext_num_count);
+ convert_numbers(buf, ptr->Numbers + NUMCOUNT, ext_num_count);
}
TR(TRACE_DATABASE, ("READ extended-offsets @%d", offset));
- if ((unsigned) (ext_str_count + (int) need) >= (MAX_ENTRY_SIZE / 2)) {
+ if ((ext_str_count + (int) need) >= (max_entry_size / 2)) {
returnDB(TGETENT_NO);
}
if ((ext_str_count || need)
}
if ((ptr->ext_Strings = UShort(ext_str_count)) != 0) {
+ int check = (ext_bool_count + ext_num_count + ext_str_count);
+
TR(TRACE_DATABASE,
- ("Before computing extended-string capabilities str_count=%d, ext_str_count=%d",
+ ("Before computing extended-string capabilities "
+ "str_count=%d, ext_str_count=%d",
str_count, ext_str_count));
convert_strings(buf, ptr->Strings + str_count, ext_str_count,
ext_str_limit, ptr->ext_str_table);
i, i + str_count,
_nc_visbuf(ptr->Strings[i + str_count])));
ptr->Strings[i + STRCOUNT] = ptr->Strings[i + str_count];
- if (VALID_STRING(ptr->Strings[i + STRCOUNT]))
+ if (VALID_STRING(ptr->Strings[i + STRCOUNT])) {
base += (int) (strlen(ptr->Strings[i + STRCOUNT]) + 1);
+ ++check;
+ }
TR(TRACE_DATABASE, ("... to [%d] %s",
i + STRCOUNT,
_nc_visbuf(ptr->Strings[i + STRCOUNT])));
}
+ TR(TRACE_DATABASE, ("Check table-size: %d/%d", check, ext_str_usage));
+#if 0
+ /*
+ * Phasing in a proper check will be done "later".
+ */
+ if (check != ext_str_usage)
+ returnDB(TGETENT_NO);
+#endif
}
if (need) {
- if (ext_str_count >= (MAX_ENTRY_SIZE / 2)) {
+ if (ext_str_count >= (max_entry_size / 2)) {
returnDB(TGETENT_NO);
}
if ((ptr->ext_Names = TYPE_CALLOC(char *, need)) == 0) {
* table.
*/
NCURSES_EXPORT(int)
-_nc_read_file_entry(const char *const filename, TERMTYPE *ptr)
+_nc_read_file_entry(const char *const filename, TERMTYPE2 *ptr)
/* return 1 if read, 0 if not found or garbled */
{
FILE *fp = 0;
TR(TRACE_DATABASE, ("read terminfo %s", filename));
if ((code = _nc_read_termtype(ptr, buffer, limit)) == TGETENT_NO) {
- _nc_free_termtype(ptr);
+ _nc_free_termtype2(ptr);
}
} else {
code = TGETENT_NO;
unsigned limit,
const char *const path,
const char *name,
- TERMTYPE *const tp)
+ TERMTYPE2 *const tp)
{
int code = TGETENT_NO;
#if USE_HASHED_DB
(T_CALLED("_nc_read_tic_entry(file=%p, path=%s, name=%s)"),
filename, path, name));
+ assert(TGETENT_YES == TRUE); /* simplify call for _nc_name_match */
+
if ((used = decode_quickdump(buffer, path)) != 0
&& (code = _nc_read_termtype(tp, buffer, used)) == TGETENT_YES
- && _nc_name_match(tp->term_names, name, "|")) {
+ && (code = _nc_name_match(tp->term_names, name, "|")) == TGETENT_YES) {
TR(TRACE_DATABASE, ("loaded quick-dump for %s", name));
+ /* shorten name shown by infocmp */
+ _nc_STRCPY(filename, "$TERMINFO", limit);
} else
#if USE_HASHED_DB
if (make_db_filename(filename, limit, path)
&& IS_TIC_MAGIC(have)) {
code = _nc_read_termtype(tp, have, used);
if (code == TGETENT_NO) {
- _nc_free_termtype(tp);
+ _nc_free_termtype2(tp);
}
}
break;
#endif /* NCURSES_USE_DATABASE */
/*
- * _nc_read_entry(char *name, char *filename, TERMTYPE *tp)
- *
- * Find and read the compiled entry for a given terminal type,
- * if it exists. We take pains here to make sure no combination
- * of environment variables and terminal type name can be used to
- * overrun the file buffer.
+ * Find and read the compiled entry for a given terminal type, if it exists.
+ * We take pains here to make sure no combination of environment variables and
+ * terminal type name can be used to overrun the file buffer.
*/
-
NCURSES_EXPORT(int)
-_nc_read_entry(const char *const name, char *const filename, TERMTYPE *const tp)
+_nc_read_entry2(const char *const name, char *const filename, TERMTYPE2 *const tp)
{
int code = TGETENT_NO;
+ if (name == 0)
+ return _nc_read_entry2("", filename, tp);
+
_nc_SPRINTF(filename, _nc_SLIMIT(PATH_MAX)
"%.*s", PATH_MAX - 1, name);
}
return code;
}
+
+#if NCURSES_EXT_NUMBERS
+/*
+ * This entrypoint is used by tack.
+ */
+NCURSES_EXPORT(int)
+_nc_read_entry(const char *const name, char *const filename, TERMTYPE *const tp)
+{
+ TERMTYPE2 dummy;
+ int rc;
+ rc = _nc_read_entry2(name, filename, &dummy);
+ if (rc == TGETENT_YES)
+ _nc_export_termtype2(tp, &dummy);
+ return rc;
+}
+#endif
projects / ncurses.git / blobdiff