/****************************************************************************
- * Copyright (c) 1998-2011,2012 Free Software Foundation, Inc. *
+ * Copyright (c) 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.78 2012/02/22 22:40:24 tom Exp $")
+MODULE_ID("$Id: parse_entry.c,v 1.84 2017/04/21 21:09:54 tom Exp $")
#ifdef LINT
static short const parametrized[] =
#include <parametrized.h>
#endif
-static void postprocess_termcap(TERMTYPE *, bool);
-static void postprocess_terminfo(TERMTYPE *);
+static void postprocess_termcap(TERMTYPE2 *, bool);
+static void postprocess_terminfo(TERMTYPE2 *);
static struct name_table_entry const *lookup_fullname(const char *name);
#if NCURSES_XNAMES
_nc_extend_names(ENTRY * entryp, char *name, int token_type)
{
static struct name_table_entry temp;
- TERMTYPE *tp = &(entryp->tterm);
+ TERMTYPE2 *tp = &(entryp->tterm);
unsigned offset = 0;
unsigned actual;
unsigned tindex;
case BOOLEAN:
tp->ext_Booleans++;
tp->num_Booleans++;
- tp->Booleans = typeRealloc(NCURSES_SBOOL, tp->num_Booleans, tp->Booleans);
+ TYPE_REALLOC(NCURSES_SBOOL, tp->num_Booleans, tp->Booleans);
for_each_value(tp->num_Booleans)
tp->Booleans[last] = tp->Booleans[last - 1];
break;
case NUMBER:
tp->ext_Numbers++;
tp->num_Numbers++;
- tp->Numbers = typeRealloc(short, tp->num_Numbers, tp->Numbers);
+ TYPE_REALLOC(NCURSES_INT2, tp->num_Numbers, tp->Numbers);
for_each_value(tp->num_Numbers)
tp->Numbers[last] = tp->Numbers[last - 1];
break;
case STRING:
tp->ext_Strings++;
tp->num_Strings++;
- tp->Strings = typeRealloc(char *, tp->num_Strings, tp->Strings);
+ TYPE_REALLOC(char *, tp->num_Strings, tp->Strings);
for_each_value(tp->num_Strings)
tp->Strings[last] = tp->Strings[last - 1];
break;
}
actual = NUM_EXT_NAMES(tp);
- tp->ext_Names = typeRealloc(char *, actual, tp->ext_Names);
+ 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);
#define MAX_NUMBER 0x7fff /* positive shorts only */
NCURSES_EXPORT(int)
-_nc_parse_entry(struct entry *entryp, int literal, bool silent)
+_nc_parse_entry(ENTRY * entryp, int literal, bool silent)
{
int token_type;
struct name_table_entry const *entry_ptr;
if (token_type != NAMES)
_nc_err_abort("Entry does not start with terminal names in column one");
- _nc_init_entry(&entryp->tterm);
+ _nc_init_entry(entryp);
entryp->cstart = _nc_comment_start;
entryp->cend = _nc_comment_end;
}
/* deal with bad type/value combinations. */
- if (token_type != CANCEL && entry_ptr->nte_type != token_type) {
+ if (token_type == CANCEL) {
+ /*
+ * Prefer terminfo in this (long-obsolete) ambiguity:
+ */
+ if (!strcmp("ma", _nc_curr_token.tk_name)) {
+ entry_ptr = _nc_find_type_entry("ma", NUMBER,
+ _nc_syntax != 0);
+ assert(entry_ptr != 0);
+ }
+ } else if (entry_ptr->nte_type != token_type) {
/*
* Nasty special cases here handle situations in which type
* information can resolve name clashes. Normal lookup
if (!literal) {
if (_nc_syntax == SYN_TERMCAP) {
bool has_base_entry = FALSE;
- unsigned 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, '+'))
+ if (strchr(entryp->tterm.term_names, '+')) {
has_base_entry = TRUE;
- else
+ } else {
+ unsigned i;
/*
* 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
* list. For each capability, we may assume there is a keycap that sends the
* string which is the value of that capability.
*/
+#define DATA(from, to) { { from }, { to } }
typedef struct {
- const char *from;
- const char *to;
+ const char from[3];
+ const char to[6];
} assoc;
static assoc const ko_xlate[] =
{
- {"al", "kil1"}, /* insert line key -> KEY_IL */
- {"bt", "kcbt"}, /* back tab -> KEY_BTAB */
- {"cd", "ked"}, /* clear-to-eos key -> KEY_EOL */
- {"ce", "kel"}, /* clear-to-eol key -> KEY_EOS */
- {"cl", "kclr"}, /* clear key -> KEY_CLEAR */
- {"ct", "tbc"}, /* clear all tabs -> KEY_CATAB */
- {"dc", "kdch1"}, /* delete char -> KEY_DC */
- {"dl", "kdl1"}, /* delete line -> KEY_DL */
- {"do", "kcud1"}, /* down key -> KEY_DOWN */
- {"ei", "krmir"}, /* exit insert key -> KEY_EIC */
- {"ho", "khome"}, /* home key -> KEY_HOME */
- {"ic", "kich1"}, /* insert char key -> KEY_IC */
- {"im", "kIC"}, /* insert-mode key -> KEY_SIC */
- {"le", "kcub1"}, /* le key -> KEY_LEFT */
- {"nd", "kcuf1"}, /* nd key -> KEY_RIGHT */
- {"nl", "kent"}, /* new line key -> KEY_ENTER */
- {"st", "khts"}, /* set-tab key -> KEY_STAB */
- {"ta", CANCELLED_STRING},
- {"up", "kcuu1"}, /* up-arrow key -> KEY_UP */
- {(char *) 0, (char *) 0},
+ DATA("al", "kil1"), /* insert line key -> KEY_IL */
+ DATA("bt", "kcbt"), /* back tab -> KEY_BTAB */
+ DATA("cd", "ked"), /* clear-to-eos key -> KEY_EOL */
+ DATA("ce", "kel"), /* clear-to-eol key -> KEY_EOS */
+ DATA("cl", "kclr"), /* clear key -> KEY_CLEAR */
+ DATA("ct", "tbc"), /* clear all tabs -> KEY_CATAB */
+ DATA("dc", "kdch1"), /* delete char -> KEY_DC */
+ DATA("dl", "kdl1"), /* delete line -> KEY_DL */
+ DATA("do", "kcud1"), /* down key -> KEY_DOWN */
+ DATA("ei", "krmir"), /* exit insert key -> KEY_EIC */
+ DATA("ho", "khome"), /* home key -> KEY_HOME */
+ DATA("ic", "kich1"), /* insert char key -> KEY_IC */
+ DATA("im", "kIC"), /* insert-mode key -> KEY_SIC */
+ DATA("le", "kcub1"), /* le key -> KEY_LEFT */
+ DATA("nd", "kcuf1"), /* nd key -> KEY_RIGHT */
+ DATA("nl", "kent"), /* new line key -> KEY_ENTER */
+ DATA("st", "khts"), /* set-tab key -> KEY_STAB */
+ DATA("ta", ""),
+ DATA("up", "kcuu1"), /* up-arrow key -> KEY_UP */
};
/*
#define CUR tp->
static void
-postprocess_termcap(TERMTYPE *tp, bool has_base)
+postprocess_termcap(TERMTYPE2 *tp, bool has_base)
{
char buf[MAX_LINE * 2 + 2];
string_desc result;
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;
(cp = strchr(base, ',')) != 0;
base = cp + 1) {
size_t len = (unsigned) (cp - base);
+ size_t n;
+ assoc const *ap = 0;
- for (ap = ko_xlate; ap->from; ap++) {
- if (len == strlen(ap->from)
- && strncmp(ap->from, base, len) == 0)
+ for (n = 0; n < SIZEOF(ko_xlate); ++n) {
+ if (len == strlen(ko_xlate[n].from)
+ && strncmp(ko_xlate[n].from, base, len) == 0) {
+ ap = ko_xlate + n;
break;
+ }
}
- if (!(ap->from && ap->to)) {
+ if (ap == 0) {
_nc_warning("unknown capability `%.*s' in ko string",
(int) len, base);
continue;
- } else if (ap->to == CANCELLED_STRING) /* ignore it */
+ } else if (ap->to[0] == '\0') /* ignore it */
continue;
/* now we know we found a match in ko_table, so... */
}
static void
-postprocess_terminfo(TERMTYPE *tp)
+postprocess_terminfo(TERMTYPE2 *tp)
{
/*
* TERMINFO-TO-TERMINFO MAPPINGS FOR SOURCE TRANSLATION
projects / ncurses.git / blobdiff