aboutsummaryrefslogtreecommitdiff
path: root/contrib/ncurses/ncurses/tinfo/parse_entry.c
diff options
context:
space:
mode:
authorPeter Wemm <peter@FreeBSD.org>2000-07-03 09:24:12 +0000
committerPeter Wemm <peter@FreeBSD.org>2000-07-03 09:24:12 +0000
commit15589c42fa2774d2f8ee650f4f31eb8d3a861316 (patch)
tree27e79485df3c9195e6fe58960df47f675f41f1e9 /contrib/ncurses/ncurses/tinfo/parse_entry.c
parent6b9085fd58b7602b14be0cd2059285baa764a7ee (diff)
downloadsrc-15589c42fa2774d2f8ee650f4f31eb8d3a861316.tar.gz
src-15589c42fa2774d2f8ee650f4f31eb8d3a861316.zip
Import the most recent ncurses 5.1 prerelease (20000701).
Mostly this is intended to resolve the trace() badness once and for all. Obtained from: ftp://dickey.his.com/ncurses/
Notes
Notes: svn path=/vendor/ncurses/dist/; revision=62449
Diffstat (limited to 'contrib/ncurses/ncurses/tinfo/parse_entry.c')
-rw-r--r--contrib/ncurses/ncurses/tinfo/parse_entry.c481
1 files changed, 218 insertions, 263 deletions
diff --git a/contrib/ncurses/ncurses/tinfo/parse_entry.c b/contrib/ncurses/ncurses/tinfo/parse_entry.c
index 07f3868e0b44..1aff562d0dd6 100644
--- a/contrib/ncurses/ncurses/tinfo/parse_entry.c
+++ b/contrib/ncurses/ncurses/tinfo/parse_entry.c
@@ -1,5 +1,5 @@
/****************************************************************************
- * Copyright (c) 1999 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 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 *
@@ -31,7 +31,6 @@
* and: Eric S. Raymond <esr@snark.thyrsus.com> *
****************************************************************************/
-
/*
* parse_entry.c -- compile one terminfo or termcap entry
*
@@ -48,24 +47,23 @@
#define __INTERNAL_CAPS_VISIBLE
#include <term_entry.h>
-MODULE_ID("$Id: parse_entry.c,v 1.39 1999/03/01 02:28:51 tom Exp $")
+MODULE_ID("$Id: parse_entry.c,v 1.44 2000/04/30 00:17:42 tom Exp $")
#ifdef LINT
-static short const parametrized[] = { 0 };
+static short const parametrized[] =
+{0};
#else
#include <parametrized.h>
#endif
-struct token _nc_curr_token;
-
-static void postprocess_termcap(TERMTYPE *, bool);
-static void postprocess_terminfo(TERMTYPE *);
-static struct name_table_entry const * lookup_fullname(const char *name);
+static void postprocess_termcap(TERMTYPE *, bool);
+static void postprocess_terminfo(TERMTYPE *);
+static struct name_table_entry const *lookup_fullname(const char *name);
#if NCURSES_XNAMES
-static struct name_table_entry const *
-_nc_extend_names(ENTRY *entryp, char *name, int token_type)
+static struct name_table_entry const *
+_nc_extend_names(ENTRY * entryp, char *name, int token_type)
{
static struct name_table_entry temp;
TERMTYPE *tp = &(entryp->tterm);
@@ -77,20 +75,20 @@ _nc_extend_names(ENTRY *entryp, char *name, int token_type)
switch (token_type) {
case BOOLEAN:
- first = 0;
- last = tp->ext_Booleans;
+ first = 0;
+ last = tp->ext_Booleans;
offset = tp->ext_Booleans;
tindex = tp->num_Booleans;
break;
case NUMBER:
- first = tp->ext_Booleans;
- last = tp->ext_Numbers + first;
+ first = tp->ext_Booleans;
+ last = tp->ext_Numbers + first;
offset = tp->ext_Booleans + tp->ext_Numbers;
tindex = tp->num_Numbers;
break;
case STRING:
- first = tp->ext_Booleans + tp->ext_Numbers;
- last = tp->ext_Strings + first;
+ first = tp->ext_Booleans + tp->ext_Numbers;
+ last = tp->ext_Strings + first;
offset = tp->ext_Booleans + tp->ext_Numbers + tp->ext_Strings;
tindex = tp->num_Strings;
break;
@@ -98,7 +96,7 @@ _nc_extend_names(ENTRY *entryp, char *name, int token_type)
actual = NUM_EXT_NAMES(tp);
for (n = 0; n < actual; n++) {
if (!strcmp(name, tp->ext_Names[n])) {
- if (n > (unsigned)(tp->ext_Booleans + tp->ext_Numbers)) {
+ if (n > (unsigned) (tp->ext_Booleans + tp->ext_Numbers)) {
token_type = STRING;
} else if (n > tp->ext_Booleans) {
token_type = NUMBER;
@@ -125,9 +123,15 @@ _nc_extend_names(ENTRY *entryp, char *name, int token_type)
offset = n;
tindex = n - first;
switch (token_type) {
- case BOOLEAN: tindex += BOOLCOUNT; break;
- case NUMBER: tindex += NUMCOUNT; break;
- case STRING: tindex += STRCOUNT; break;
+ case BOOLEAN:
+ tindex += BOOLCOUNT;
+ break;
+ case NUMBER:
+ tindex += NUMCOUNT;
+ break;
+ case STRING:
+ tindex += STRCOUNT;
+ break;
}
break;
}
@@ -138,35 +142,35 @@ _nc_extend_names(ENTRY *entryp, char *name, int token_type)
tp->ext_Booleans += 1;
tp->num_Booleans += 1;
tp->Booleans = typeRealloc(char, tp->num_Booleans, tp->Booleans);
- for (last = tp->num_Booleans-1; last > tindex; last--)
- tp->Booleans[last] = tp->Booleans[last-1];
+ for (last = tp->num_Booleans - 1; last > tindex; last--)
+ tp->Booleans[last] = tp->Booleans[last - 1];
break;
case NUMBER:
tp->ext_Numbers += 1;
tp->num_Numbers += 1;
tp->Numbers = typeRealloc(short, tp->num_Numbers, tp->Numbers);
- for (last = tp->num_Numbers-1; last > tindex; last--)
- tp->Numbers[last] = tp->Numbers[last-1];
+ for (last = tp->num_Numbers - 1; last > tindex; last--)
+ tp->Numbers[last] = tp->Numbers[last - 1];
break;
case STRING:
tp->ext_Strings += 1;
tp->num_Strings += 1;
tp->Strings = typeRealloc(char *, tp->num_Strings, tp->Strings);
- for (last = tp->num_Strings-1; last > tindex; last--)
- tp->Strings[last] = tp->Strings[last-1];
+ for (last = tp->num_Strings - 1; last > tindex; last--)
+ tp->Strings[last] = tp->Strings[last - 1];
break;
}
actual = NUM_EXT_NAMES(tp);
- tp->ext_Names = typeRealloc(char *, actual, tp->ext_Names);
+ tp->ext_Names = typeRealloc(char *, actual, tp->ext_Names);
while (--actual > offset)
- tp->ext_Names[actual] = tp->ext_Names[actual-1];
+ tp->ext_Names[actual] = tp->ext_Names[actual - 1];
tp->ext_Names[offset] = _nc_save_str(name);
}
- temp.nte_name = tp->ext_Names[offset];
- temp.nte_type = token_type;
+ temp.nte_name = tp->ext_Names[offset];
+ temp.nte_type = token_type;
temp.nte_index = tindex;
- temp.nte_link = -1;
+ temp.nte_link = -1;
return &temp;
}
@@ -191,16 +195,17 @@ _nc_extend_names(ENTRY *entryp, char *name, int token_type)
* push back token
*/
-int _nc_parse_entry(struct entry *entryp, int literal, bool silent)
+int
+_nc_parse_entry(struct entry *entryp, int literal, bool silent)
{
- int token_type;
- struct name_table_entry const *entry_ptr;
- char *ptr, namecpy[MAX_NAME_SIZE+1];
+ int token_type;
+ struct name_table_entry const *entry_ptr;
+ char *ptr, namecpy[MAX_NAME_SIZE + 1];
token_type = _nc_get_token();
if (token_type == EOF)
- return(EOF);
+ return (EOF);
if (token_type != NAMES)
_nc_err_abort("Entry does not start with terminal names in column one");
@@ -213,8 +218,7 @@ int _nc_parse_entry(struct entry *entryp, int literal, bool silent)
/* junk the 2-character termcap name, if present */
ptr = _nc_curr_token.tk_name;
- if (ptr[2] == '|')
- {
+ if (ptr[2] == '|') {
ptr = _nc_curr_token.tk_name + 3;
_nc_curr_token.tk_name[2] = '\0';
}
@@ -233,30 +237,29 @@ int _nc_parse_entry(struct entry *entryp, int literal, bool silent)
/* check for overly-long names and aliases */
(void) strncpy(namecpy, entryp->tterm.term_names, MAX_NAME_SIZE);
namecpy[MAX_NAME_SIZE] = '\0';
- if ((ptr = strrchr(namecpy, '|')) != (char *)0)
+ if ((ptr = strrchr(namecpy, '|')) != (char *) 0)
*ptr = '\0';
ptr = strtok(namecpy, "|");
if (strlen(ptr) > MAX_ALIAS)
_nc_warning("primary name may be too long");
- while ((ptr = strtok((char *)0, "|")) != (char *)0)
+ while ((ptr = strtok((char *) 0, "|")) != (char *) 0)
if (strlen(ptr) > MAX_ALIAS)
_nc_warning("alias `%s' may be too long", ptr);
entryp->nuses = 0;
for (token_type = _nc_get_token();
- token_type != EOF && token_type != NAMES;
- 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].parent = (void *)_nc_save_str(_nc_curr_token.tk_valstring);
+ 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);
+ _nc_syntax ? _nc_cap_hash_table : _nc_info_hash_table);
/*
* Our kluge to handle aliasing. The reason it's done
@@ -266,43 +269,37 @@ int _nc_parse_entry(struct entry *entryp, int literal, bool silent)
* making this case fast, aliased caps aren't common now
* and will get rarer.
*/
- if (entry_ptr == NOTFOUND)
- {
- const struct alias *ap;
+ if (entry_ptr == NOTFOUND) {
+ const struct alias *ap;
- if (_nc_syntax == SYN_TERMCAP)
- {
+ 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)
- {
+ 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);
+ 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);
+ _nc_warning("%s (%s termcap extension) aliased to %s",
+ ap->from, ap->source, ap->to);
break;
}
- }
- else /* if (_nc_syntax == SYN_TERMINFO) */
- {
+ } 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)
- {
+ 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);
+ 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);
+ _nc_warning("%s (%s terminfo extension) aliased to %s",
+ ap->from, ap->source, ap->to);
break;
}
@@ -311,16 +308,17 @@ int _nc_parse_entry(struct entry *entryp, int literal, bool silent)
}
}
}
-
#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) {
- _nc_warning("extended capability '%s'", _nc_curr_token.tk_name);
+ && _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 */
@@ -328,13 +326,12 @@ int _nc_parse_entry(struct entry *entryp, int literal, bool silent)
if (entry_ptr == NOTFOUND) {
if (!silent)
_nc_warning("unknown capability '%s'",
- _nc_curr_token.tk_name);
+ _nc_curr_token.tk_name);
continue;
}
/* deal with bad type/value combinations. */
- if (token_type != CANCEL && entry_ptr->nte_type != token_type)
- {
+ 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
@@ -348,39 +345,36 @@ int _nc_parse_entry(struct entry *entryp, int literal, bool silent)
/* 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));
+ _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))
+ 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));
+ _nc_get_table(_nc_syntax != 0));
/* treat strings without following "=" as empty strings */
- else if (token_type==BOOLEAN && entry_ptr->nte_type==STRING)
+ else if (token_type == BOOLEAN && entry_ptr->nte_type == STRING)
token_type = STRING;
/* we couldn't recover; skip this token */
- else
- {
- if (!silent)
- {
+ else {
+ if (!silent) {
const char *type_name;
- switch (entry_ptr->nte_type)
- {
+ switch (entry_ptr->nte_type) {
case BOOLEAN:
- type_name = "boolean";
- break;
+ type_name = "boolean";
+ break;
case STRING:
- type_name = "string";
- break;
+ type_name = "string";
+ break;
case NUMBER:
- type_name = "numeric";
- break;
+ type_name = "numeric";
+ break;
default:
- type_name = "unknown";
- break;
+ type_name = "unknown";
+ break;
}
_nc_warning("wrong type used for %s capability '%s'",
- type_name, _nc_curr_token.tk_name);
+ type_name, _nc_curr_token.tk_name);
}
continue;
}
@@ -415,23 +409,23 @@ int _nc_parse_entry(struct entry *entryp, int literal, bool silent)
case STRING:
ptr = _nc_curr_token.tk_valstring;
- if (_nc_syntax==SYN_TERMCAP)
+ if (_nc_syntax == SYN_TERMCAP)
ptr = _nc_captoinfo(_nc_curr_token.tk_name,
- ptr,
- parametrized[entry_ptr->nte_index]);
+ 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) ? ':' : ',');
+ _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) */
+ } /* 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));
@@ -443,10 +437,9 @@ int _nc_parse_entry(struct entry *entryp, int literal, bool silent)
* to be done before entry allocation is wrapped up.
*/
if (!literal) {
- if (_nc_syntax == SYN_TERMCAP)
- {
- bool has_base_entry = FALSE;
- int i;
+ if (_nc_syntax == SYN_TERMCAP) {
+ bool has_base_entry = FALSE;
+ int i;
/*
* Don't insert defaults if this is a `+' entry meant only
@@ -461,50 +454,49 @@ int _nc_parse_entry(struct entry *entryp, int literal, bool silent)
* have picked up defaults via translation.
*/
for (i = 0; i < entryp->nuses; i++)
- if (!strchr((char *)entryp->uses[i].parent, '+'))
+ if (!strchr((char *) entryp->uses[i].name, '+'))
has_base_entry = TRUE;
postprocess_termcap(&entryp->tterm, has_base_entry);
- }
- else
+ } else
postprocess_terminfo(&entryp->tterm);
}
_nc_wrap_entry(entryp);
- return(OK);
+ return (OK);
}
-int _nc_capcmp(const char *s, const char *t)
+int
+_nc_capcmp(const char *s, const char *t)
/* compare two string capabilities, stripping out padding */
{
if (!s && !t)
- return(0);
+ return (0);
else if (!s || !t)
- return(1);
-
- for (;;)
- {
- if (s[0] == '$' && s[1] == '<')
- {
- for (s += 2; ; s++)
- if (!(isdigit(*s) || *s=='.' || *s=='*' || *s=='/' || *s=='>'))
+ return (1);
+
+ for (;;) {
+ if (s[0] == '$' && s[1] == '<') {
+ for (s += 2;; s++)
+ if (!(isdigit(*s) || *s == '.' || *s == '*' || *s == '/' ||
+ *s == '>'))
break;
}
- if (t[0] == '$' && t[1] == '<')
- {
- for (t += 2; ; t++)
- if (!(isdigit(*t) || *t=='.' || *t=='*' || *t=='/' || *t=='>'))
+ if (t[0] == '$' && t[1] == '<') {
+ for (t += 2;; t++)
+ if (!(isdigit(*t) || *t == '.' || *t == '*' || *t == '/' ||
+ *t == '>'))
break;
}
/* we've now pushed s and t past any padding they were pointing at */
if (*s == '\0' && *t == '\0')
- return(0);
+ return (0);
if (*s != *t)
- return(*t - *s);
+ return (*t - *s);
/* else *s == *t but one is not NUL, so continue */
s++, t++;
@@ -516,29 +508,32 @@ int _nc_capcmp(const char *s, const char *t)
* list. For each capability, we may assume there is a keycap that sends the
* string which is the value of that capability.
*/
-typedef struct {const char *from; const char *to;} assoc;
+typedef struct {
+ const char *from;
+ const char *to;
+} 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},
+ {"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},
};
/*
@@ -569,7 +564,8 @@ static const char C_HT[] = "\t";
#define CUR tp->
static
-void postprocess_termcap(TERMTYPE *tp, bool has_base)
+void
+postprocess_termcap(TERMTYPE * tp, bool has_base)
{
char buf[MAX_LINE * 2 + 2];
@@ -582,8 +578,7 @@ void postprocess_termcap(TERMTYPE *tp, bool has_base)
*/
/* if there was a tc entry, assume we picked up defaults via that */
- if (!has_base)
- {
+ if (!has_base) {
if (WANTED(init_3string) && termcap_init2)
init_3string = _nc_save_str(termcap_init2);
@@ -637,15 +632,15 @@ void postprocess_termcap(TERMTYPE *tp, bool has_base)
} else
newline = _nc_save_str(C_LF);
} else if (PRESENT(carriage_return) && PRESENT(scroll_forward)) {
- strncpy(buf, carriage_return, MAX_LINE-2);
- buf[MAX_LINE-1] = '\0';
- strncat(buf, scroll_forward, MAX_LINE-strlen(buf)-1);
+ strncpy(buf, carriage_return, MAX_LINE - 2);
+ buf[MAX_LINE - 1] = '\0';
+ strncat(buf, scroll_forward, MAX_LINE - strlen(buf) - 1);
buf[MAX_LINE] = '\0';
newline = _nc_save_str(buf);
} else if (PRESENT(carriage_return) && PRESENT(cursor_down)) {
- strncpy(buf, carriage_return, MAX_LINE-2);
- buf[MAX_LINE-1] = '\0';
- strncat(buf, cursor_down, MAX_LINE-strlen(buf)-1);
+ strncpy(buf, carriage_return, MAX_LINE - 2);
+ buf[MAX_LINE - 1] = '\0';
+ strncat(buf, cursor_down, MAX_LINE - strlen(buf) - 1);
buf[MAX_LINE] = '\0';
newline = _nc_save_str(buf);
}
@@ -661,8 +656,7 @@ void postprocess_termcap(TERMTYPE *tp, bool has_base)
* These translations will *not* be inverted by tgetent().
*/
- if (!has_base)
- {
+ 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
@@ -698,13 +692,11 @@ void postprocess_termcap(TERMTYPE *tp, bool has_base)
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
- {
+ else {
if (tab && _nc_capcmp(tab, C_HT))
_nc_warning("hardware tabs with a non-^I tab string %s",
- _nc_visbuf(tab));
- else
- {
+ _nc_visbuf(tab));
+ else {
if (WANTED(tab))
tab = _nc_save_str(C_HT);
init_tabs = 8;
@@ -715,14 +707,13 @@ void postprocess_termcap(TERMTYPE *tp, bool has_base)
* Now translate the ko capability, if there is one. This
* isn't from mytinfo...
*/
- if (PRESENT(other_non_function_keys))
- {
- char *dp, *cp = strtok(other_non_function_keys, ",");
- struct name_table_entry const *from_ptr;
- struct name_table_entry const *to_ptr;
- assoc const *ap;
- char buf2[MAX_TERMINFO_LENGTH];
- bool foundim;
+ if (PRESENT(other_non_function_keys)) {
+ char *dp, *cp = strtok(other_non_function_keys, ",");
+ 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');
@@ -733,30 +724,26 @@ void postprocess_termcap(TERMTYPE *tp, bool has_base)
for (ap = ko_xlate; ap->from; ap++)
if (strcmp(ap->from, cp) == 0)
break;
- if (!ap->to)
- {
+ if (!ap->to) {
_nc_warning("unknown capability `%s' in ko string", cp);
continue;
- }
- else if (ap->to == CANCELLED_STRING) /* ignore it */
+ } 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);
+ 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]))
- {
+ 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])
- {
+ 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.
*/
@@ -764,8 +751,8 @@ void postprocess_termcap(TERMTYPE *tp, bool has_base)
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]) );
+ ap->to, ap->from,
+ _nc_visbuf(tp->Strings[to_ptr->nte_index]));
continue;
}
@@ -774,24 +761,21 @@ void postprocess_termcap(TERMTYPE *tp, bool has_base)
* stripping out padding.
*/
dp = buf2;
- for (cp = tp->Strings[from_ptr->nte_index]; *cp; cp++)
- {
- if (cp[0] == '$' && cp[1] == '<')
- {
+ for (cp = tp->Strings[from_ptr->nte_index]; *cp; cp++) {
+ if (cp[0] == '$' && cp[1] == '<') {
while (*cp && *cp != '>')
if (!*cp)
break;
- else
+ else
++cp;
- }
- else
+ } else
*dp++ = *cp;
}
*dp++ = '\0';
tp->Strings[to_ptr->nte_index] = _nc_save_str(buf2);
} while
- ((cp = strtok((char *)0, ",")) != 0);
+ ((cp = strtok((char *) 0, ",")) != 0);
/*
* Note: ko=im and ko=ic both want to grab the `Insert'
@@ -799,15 +783,13 @@ void postprocess_termcap(TERMTYPE *tp, bool has_base)
* 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)
- {
+ if (foundim && WANTED(key_ic) && key_sic) {
key_ic = key_sic;
key_sic = ABSENT_STRING;
}
}
- if (!hard_copy)
- {
+ if (!hard_copy) {
if (WANTED(key_backspace))
key_backspace = _nc_save_str(C_BS);
if (WANTED(key_left))
@@ -829,90 +811,76 @@ void postprocess_termcap(TERMTYPE *tp, bool has_base)
PRESENT(acs_ttee) ||
PRESENT(acs_hline) ||
PRESENT(acs_vline) ||
- PRESENT(acs_plus))
- {
- char buf2[MAX_TERMCAP_LENGTH], *bp = buf2;
+ PRESENT(acs_plus)) {
+ char buf2[MAX_TERMCAP_LENGTH], *bp = buf2;
- if (acs_chars)
- {
- (void)strcpy(bp, acs_chars);
+ if (acs_chars) {
+ (void) strcpy(bp, acs_chars);
bp += strlen(bp);
}
- if (acs_ulcorner && acs_ulcorner[1] == '\0')
- {
+ if (acs_ulcorner && acs_ulcorner[1] == '\0') {
*bp++ = 'l';
*bp++ = *acs_ulcorner;
}
- if (acs_llcorner && acs_llcorner[1] == '\0')
- {
+ if (acs_llcorner && acs_llcorner[1] == '\0') {
*bp++ = 'm';
*bp++ = *acs_llcorner;
}
- if (acs_urcorner && acs_urcorner[1] == '\0')
- {
+ if (acs_urcorner && acs_urcorner[1] == '\0') {
*bp++ = 'k';
*bp++ = *acs_urcorner;
}
- if (acs_lrcorner && acs_lrcorner[1] == '\0')
- {
+ if (acs_lrcorner && acs_lrcorner[1] == '\0') {
*bp++ = 'j';
*bp++ = *acs_lrcorner;
}
- if (acs_ltee && acs_ltee[1] == '\0')
- {
+ if (acs_ltee && acs_ltee[1] == '\0') {
*bp++ = 't';
*bp++ = *acs_ltee;
}
- if (acs_rtee && acs_rtee[1] == '\0')
- {
+ if (acs_rtee && acs_rtee[1] == '\0') {
*bp++ = 'u';
*bp++ = *acs_rtee;
}
- if (acs_btee && acs_btee[1] == '\0')
- {
+ if (acs_btee && acs_btee[1] == '\0') {
*bp++ = 'v';
*bp++ = *acs_btee;
}
- if (acs_ttee && acs_ttee[1] == '\0')
- {
+ if (acs_ttee && acs_ttee[1] == '\0') {
*bp++ = 'w';
*bp++ = *acs_ttee;
}
- if (acs_hline && acs_hline[1] == '\0')
- {
+ if (acs_hline && acs_hline[1] == '\0') {
*bp++ = 'q';
*bp++ = *acs_hline;
}
- if (acs_vline && acs_vline[1] == '\0')
- {
+ if (acs_vline && acs_vline[1] == '\0') {
*bp++ = 'x';
*bp++ = *acs_vline;
}
- if (acs_plus)
- {
+ if (acs_plus) {
*bp++ = 'n';
strcpy(bp, acs_plus);
bp = buf2 + strlen(buf2);
}
- if (bp != buf2)
- {
+ if (bp != buf2) {
*bp++ = '\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{{||}}~~");
+ } else if (acs_chars == 0
+ && enter_alt_charset_mode != 0
+ && exit_alt_charset_mode != 0) {
+ acs_chars =
+ _nc_save_str("``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~");
}
}
static
-void postprocess_terminfo(TERMTYPE *tp)
+void
+postprocess_terminfo(TERMTYPE * tp)
{
/*
* TERMINFO-TO-TERMINFO MAPPINGS FOR SOURCE TRANSLATION
@@ -922,74 +890,60 @@ void postprocess_terminfo(TERMTYPE *tp)
/*
* Translate AIX forms characters.
*/
- if (PRESENT(box_chars_1))
- {
- char buf2[MAX_TERMCAP_LENGTH], *bp = buf2;
+ if (PRESENT(box_chars_1)) {
+ char buf2[MAX_TERMCAP_LENGTH], *bp = buf2;
- if (acs_chars)
- {
- (void)strcpy(bp, acs_chars);
+ if (acs_chars) {
+ (void) strcpy(bp, acs_chars);
bp += strlen(bp);
}
- if (box_chars_1[0]) /* ACS_ULCORNER */
- {
+ if (box_chars_1[0]) { /* ACS_ULCORNER */
*bp++ = 'l';
*bp++ = box_chars_1[0];
}
- if (box_chars_1[1]) /* ACS_HLINE */
- {
+ if (box_chars_1[1]) { /* ACS_HLINE */
*bp++ = 'q';
*bp++ = box_chars_1[1];
}
- if (box_chars_1[2]) /* ACS_URCORNER */
- {
+ if (box_chars_1[2]) { /* ACS_URCORNER */
*bp++ = 'k';
*bp++ = box_chars_1[2];
}
- if (box_chars_1[3]) /* ACS_VLINE */
- {
+ if (box_chars_1[3]) { /* ACS_VLINE */
*bp++ = 'x';
*bp++ = box_chars_1[3];
}
- if (box_chars_1[4]) /* ACS_LRCORNER */
- {
+ if (box_chars_1[4]) { /* ACS_LRCORNER */
*bp++ = 'j';
*bp++ = box_chars_1[4];
}
- if (box_chars_1[5]) /* ACS_LLCORNER */
- {
+ if (box_chars_1[5]) { /* ACS_LLCORNER */
*bp++ = 'm';
*bp++ = box_chars_1[5];
}
- if (box_chars_1[6]) /* ACS_TTEE */
- {
+ if (box_chars_1[6]) { /* ACS_TTEE */
*bp++ = 'w';
*bp++ = box_chars_1[6];
}
- if (box_chars_1[7]) /* ACS_RTEE */
- {
+ if (box_chars_1[7]) { /* ACS_RTEE */
*bp++ = 'u';
*bp++ = box_chars_1[7];
}
- if (box_chars_1[8]) /* ACS_BTEE */
- {
+ if (box_chars_1[8]) { /* ACS_BTEE */
*bp++ = 'v';
*bp++ = box_chars_1[8];
}
- if (box_chars_1[9]) /* ACS_LTEE */
- {
+ if (box_chars_1[9]) { /* ACS_LTEE */
*bp++ = 't';
*bp++ = box_chars_1[9];
}
- if (box_chars_1[10]) /* ACS_PLUS */
- {
+ if (box_chars_1[10]) { /* ACS_PLUS */
*bp++ = 'n';
*bp++ = box_chars_1[10];
}
- if (bp != buf2)
- {
+ if (bp != buf2) {
*bp++ = '\0';
acs_chars = _nc_save_str(buf2);
_nc_warning("acsc string synthesized from AIX capabilities");
@@ -1010,7 +964,8 @@ void postprocess_terminfo(TERMTYPE *tp)
* sorted, but the nte_type fields are not necessarily grouped together.
*/
static
-struct name_table_entry const * lookup_fullname(const char *find)
+struct name_table_entry const *
+lookup_fullname(const char *find)
{
int state = -1;
@@ -1034,10 +989,10 @@ struct name_table_entry const * lookup_fullname(const char *find)
for (count = 0; names[count] != 0; count++) {
if (!strcmp(names[count], find)) {
- struct name_table_entry const *entry_ptr = _nc_get_table(FALSE);
- while (entry_ptr->nte_type != state
+ struct name_table_entry const *entry_ptr = _nc_get_table(FALSE);
+ while (entry_ptr->nte_type != state
|| entry_ptr->nte_index != count)
- entry_ptr++;
+ entry_ptr++;
return entry_ptr;
}
}