diff options
Diffstat (limited to 'contrib/ncurses/ncurses/tinfo')
19 files changed, 1401 insertions, 887 deletions
diff --git a/contrib/ncurses/ncurses/tinfo/access.c b/contrib/ncurses/ncurses/tinfo/access.c index 54e549497c94..6fbe92176045 100644 --- a/contrib/ncurses/ncurses/tinfo/access.c +++ b/contrib/ncurses/ncurses/tinfo/access.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998 Free Software Foundation, Inc. * + * Copyright (c) 1998,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 * @@ -27,29 +27,68 @@ ****************************************************************************/ /**************************************************************************** - * Author: Thomas E. Dickey <dickey@clark.net> 1998 * + * Author: Thomas E. Dickey <dickey@clark.net> 1998,2000 * ****************************************************************************/ - #include <curses.priv.h> +#include <tic.h> -MODULE_ID("$Id: access.c,v 1.1 1998/07/25 20:17:09 tom Exp $") +MODULE_ID("$Id: access.c,v 1.4 2000/10/08 01:25:06 tom Exp $") -int _nc_access(const char *path, int mode) +char * +_nc_basename(char *path) { - if (access(path, mode) < 0) { - if ((mode & W_OK) != 0 - && errno == ENOENT) { - char head[PATH_MAX]; - char *leaf = strrchr(strcpy(head, path), '/'); - if (leaf == 0) - leaf = head; - *leaf = '\0'; - if (head == leaf) - (void)strcpy(head, "."); - return access(head, R_OK|W_OK|X_OK); - } - return -1; + char *result = strrchr(path, '/'); +#ifdef __EMX__ + if (result == 0) + result = strrchr(path, '\\'); +#endif + if (result == 0) + result = path; + else + result++; + return result; +} + +int +_nc_access(const char *path, int mode) +{ + if (access(path, mode) < 0) { + if ((mode & W_OK) != 0 + && errno == ENOENT + && strlen(path) < PATH_MAX) { + char head[PATH_MAX]; + char *leaf = _nc_basename(strcpy(head, path)); + + if (leaf == 0) + leaf = head; + *leaf = '\0'; + if (head == leaf) + (void) strcpy(head, "."); + + return access(head, R_OK | W_OK | X_OK); } - return 0; + return -1; + } + return 0; +} + +#ifndef USE_ROOT_ENVIRON +/* + * Returns true if we allow application to use environment variables that are + * used for searching lists of directories, etc. + */ +int +_nc_env_access(void) +{ +#if HAVE_ISSETUGID + if (issetugid()) + return FALSE; +#elif HAVE_GETEUID && HAVE_GETEGID + if (getuid() != geteuid() + || getgid() != getegid()) + return FALSE; +#endif + return getuid() != 0; /* ...finally, disallow root */ } +#endif diff --git a/contrib/ncurses/ncurses/tinfo/alloc_ttype.c b/contrib/ncurses/ncurses/tinfo/alloc_ttype.c index 660381a32b5f..eac7c80f0328 100644 --- a/contrib/ncurses/ncurses/tinfo/alloc_ttype.c +++ b/contrib/ncurses/ncurses/tinfo/alloc_ttype.c @@ -43,7 +43,7 @@ #include <tic.h> #include <term_entry.h> -MODULE_ID("$Id: alloc_ttype.c,v 1.8 2000/03/25 17:03:11 tom Exp $") +MODULE_ID("$Id: alloc_ttype.c,v 1.10 2000/08/12 21:56:24 tom Exp $") #if NCURSES_XNAMES /* @@ -54,7 +54,7 @@ static int merge_names(char **dst, char **a, int na, char **b, int nb) { int n = 0; - while (na && nb) { + while (na > 0 && nb > 0) { int cmp = strcmp(*a, *b); if (cmp < 0) { dst[n++] = *a++; @@ -93,7 +93,7 @@ find_name(char **table, int length, char *name) static void realign_data(TERMTYPE * to, char **ext_Names, int ext_Booleans, int - ext_Numbers, int ext_Strings) + ext_Numbers, int ext_Strings) { int n, m, base; int limit = (to->ext_Booleans + to->ext_Numbers + to->ext_Strings); @@ -102,8 +102,8 @@ realign_data(TERMTYPE * to, char **ext_Names, int ext_Booleans, int to->num_Booleans += (ext_Booleans - to->ext_Booleans); to->Booleans = typeRealloc(char, to->num_Booleans, to->Booleans); for (n = to->ext_Booleans - 1, - m = ext_Booleans - 1, - base = to->num_Booleans - (m + 1); m >= 0; m--) { + m = ext_Booleans - 1, + base = to->num_Booleans - (m + 1); m >= 0; m--) { if (find_name(to->ext_Names, limit, ext_Names[m])) { to->Booleans[base + m] = to->Booleans[base + n--]; } else { @@ -116,8 +116,8 @@ realign_data(TERMTYPE * to, char **ext_Names, int ext_Booleans, int to->num_Numbers += (ext_Numbers - to->ext_Numbers); to->Numbers = typeRealloc(short, to->num_Numbers, to->Numbers); for (n = to->ext_Numbers - 1, - m = ext_Numbers - 1, - base = to->num_Numbers - (m + 1); m >= 0; m--) { + m = ext_Numbers - 1, + base = to->num_Numbers - (m + 1); m >= 0; m--) { if (find_name(to->ext_Names, limit, ext_Names[m + ext_Booleans])) { to->Numbers[base + m] = to->Numbers[base + n--]; } else { @@ -130,8 +130,8 @@ realign_data(TERMTYPE * to, char **ext_Names, int ext_Booleans, int to->num_Strings += (ext_Strings - to->ext_Strings); to->Strings = typeRealloc(char *, to->num_Strings, to->Strings); for (n = to->ext_Strings - 1, - m = ext_Strings - 1, - base = to->num_Strings - (m + 1); m >= 0; m--) { + m = ext_Strings - 1, + base = to->num_Strings - (m + 1); m >= 0; m--) { if (find_name(to->ext_Names, limit, ext_Names[m + ext_Booleans + ext_Numbers])) { to->Strings[base + m] = to->Strings[base + n--]; } else { @@ -235,7 +235,7 @@ _nc_ext_data_index(TERMTYPE * tp, int n, int token_type) * Adjust tables to remove (not free) an extended name and its corresponding * data. */ -static void +static bool _nc_del_ext_name(TERMTYPE * tp, char *name, int token_type) { int j; @@ -270,7 +270,9 @@ _nc_del_ext_name(TERMTYPE * tp, char *name, int token_type) tp->num_Strings -= 1; break; } + return TRUE; } + return FALSE; } /* @@ -345,14 +347,22 @@ adjust_cancels(TERMTYPE * to, TERMTYPE * from) if (to->Strings[j + j_str] == CANCELLED_STRING) { if ((k = _nc_find_ext_name(from, to->ext_Names[j], BOOLEAN)) >= 0) { - _nc_del_ext_name(to, name, STRING); - k = _nc_ins_ext_name(to, name, BOOLEAN); - to->Booleans[k] = FALSE; + if (_nc_del_ext_name(to, name, STRING) + || _nc_del_ext_name(to, name, NUMBER)) { + k = _nc_ins_ext_name(to, name, BOOLEAN); + to->Booleans[k] = FALSE; + } else { + j++; + } } else if ((k = _nc_find_ext_name(from, to->ext_Names[j], - NUMBER)) >= 0) { - _nc_del_ext_name(to, name, STRING); - k = _nc_ins_ext_name(to, name, NUMBER); - to->Numbers[k] = CANCELLED_NUMERIC; + NUMBER)) >= 0) { + if (_nc_del_ext_name(to, name, STRING) + || _nc_del_ext_name(to, name, BOOLEAN)) { + k = _nc_ins_ext_name(to, name, NUMBER); + to->Numbers[k] = CANCELLED_NUMERIC; + } else { + j++; + } } } else { j++; @@ -371,7 +381,7 @@ _nc_align_termtype(TERMTYPE * to, TERMTYPE * from) int ext_Booleans, ext_Numbers, ext_Strings; DEBUG(2, ("align_termtype to(%d:%s), from(%d:%s)", na, to->term_names, - nb, from->term_names)); + nb, from->term_names)); if (na != 0 || nb != 0) { if ((na == nb) /* check if the arrays are equivalent */ @@ -402,26 +412,26 @@ _nc_align_termtype(TERMTYPE * to, TERMTYPE * from) adjust_cancels(from, to); ext_Booleans = merge_names(ext_Names, - to->ext_Names, - to->ext_Booleans, - from->ext_Names, - from->ext_Booleans); + to->ext_Names, + to->ext_Booleans, + from->ext_Names, + from->ext_Booleans); ext_Numbers = merge_names(ext_Names + ext_Booleans, - to->ext_Names - + to->ext_Booleans, - to->ext_Numbers, - from->ext_Names - + from->ext_Booleans, - from->ext_Numbers); + to->ext_Names + + to->ext_Booleans, + to->ext_Numbers, + from->ext_Names + + from->ext_Booleans, + from->ext_Numbers); ext_Strings = merge_names(ext_Names + ext_Numbers + ext_Booleans, - to->ext_Names - + to->ext_Booleans - + to->ext_Numbers, - to->ext_Strings, - from->ext_Names - + from->ext_Booleans - + from->ext_Numbers, - from->ext_Strings); + to->ext_Names + + to->ext_Booleans + + to->ext_Numbers, + to->ext_Strings, + from->ext_Names + + from->ext_Booleans + + from->ext_Numbers, + from->ext_Strings); /* * Now we must reallocate the Booleans, etc., to allow the data to be * overlaid. @@ -431,7 +441,7 @@ _nc_align_termtype(TERMTYPE * to, TERMTYPE * from) FreeIfNeeded(to->ext_Names); to->ext_Names = ext_Names; DEBUG(2, ("realigned %d extended names for '%s' (to)", - NUM_EXT_NAMES(to), to->term_names)); + NUM_EXT_NAMES(to), to->term_names)); } if (nb != (ext_Booleans + ext_Numbers + ext_Strings)) { nb = (ext_Booleans + ext_Numbers + ext_Strings); @@ -439,7 +449,7 @@ _nc_align_termtype(TERMTYPE * to, TERMTYPE * from) from->ext_Names = typeRealloc(char *, nb, from->ext_Names); memcpy(from->ext_Names, ext_Names, sizeof(char *) * nb); DEBUG(2, ("realigned %d extended names for '%s' (from)", - NUM_EXT_NAMES(from), from->term_names)); + NUM_EXT_NAMES(from), from->term_names)); } } } diff --git a/contrib/ncurses/ncurses/tinfo/comp_parse.c b/contrib/ncurses/ncurses/tinfo/comp_parse.c index ca58bb5746e7..c4083877ebca 100644 --- a/contrib/ncurses/ncurses/tinfo/comp_parse.c +++ b/contrib/ncurses/ncurses/tinfo/comp_parse.c @@ -52,7 +52,7 @@ #include <tic.h> #include <term_entry.h> -MODULE_ID("$Id: comp_parse.c,v 1.40 2000/04/15 16:57:08 tom Exp $") +MODULE_ID("$Id: comp_parse.c,v 1.41 2000/10/03 09:53:49 tom Exp $") static void sanity_check(TERMTYPE *); void (*_nc_check_termtype) (TERMTYPE *) = sanity_check; @@ -122,26 +122,29 @@ _nc_free_entries(ENTRY * headp) } } +static char * +force_bar(char *dst, char *src) +{ + if (strchr(src, '|') == 0) { + size_t len = strlen(src); + if (len >= MAX_NAME_SIZE) + len = MAX_NAME_SIZE; + (void) strncpy(dst, src, len); + (void) strcpy(dst + len, "|"); + src = dst; + } + return src; +} + bool _nc_entry_match(char *n1, char *n2) /* do any of the aliases in a pair of terminal names match? */ { char *pstart, *qstart, *pend, *qend; - char nc1[MAX_NAME_SIZE + 1], nc2[MAX_NAME_SIZE + 1]; + char nc1[MAX_NAME_SIZE + 2], nc2[MAX_NAME_SIZE + 2]; - if (strchr(n1, '|') == 0) { - (void) strncpy(nc1, n1, sizeof(nc1) - 2); - nc1[sizeof(nc1) - 2] = '\0'; - (void) strcat(nc1, "|"); - n1 = nc1; - } - - if (strchr(n2, '|') == 0) { - (void) strncpy(nc2, n2, sizeof(nc2) - 2); - nc2[sizeof(nc2) - 2] = '\0'; - (void) strcat(nc2, "|"); - n2 = nc2; - } + n1 = force_bar(nc1, n1); + n2 = force_bar(nc2, n2); for (pstart = n1; (pend = strchr(pstart, '|')); pstart = pend + 1) for (qstart = n2; (qend = strchr(qstart, '|')); qstart = qend + 1) diff --git a/contrib/ncurses/ncurses/tinfo/comp_scan.c b/contrib/ncurses/ncurses/tinfo/comp_scan.c index 8997e417ae57..e1118f6f9ea9 100644 --- a/contrib/ncurses/ncurses/tinfo/comp_scan.c +++ b/contrib/ncurses/ncurses/tinfo/comp_scan.c @@ -50,7 +50,7 @@ #include <term_entry.h> #include <tic.h> -MODULE_ID("$Id: comp_scan.c,v 1.44 2000/06/10 21:59:21 tom Exp $") +MODULE_ID("$Id: comp_scan.c,v 1.47 2000/09/24 01:15:17 tom Exp $") /* * Maximum length of string capability we'll accept before raising an error. @@ -80,6 +80,10 @@ static char separator; /* capability separator */ static int pushtype; /* type of pushback token */ static char pushname[MAX_NAME_SIZE + 1]; +#if NCURSES_EXT_FUNCS +bool _nc_disable_period = FALSE; /* used by tic -a option */ +#endif + static int last_char(void); static int next_char(void); static long stream_pos(void); @@ -149,7 +153,7 @@ _nc_get_token(void) _nc_set_type(pushname); DEBUG(3, ("pushed-back token: `%s', class %d", - _nc_curr_token.tk_name, pushtype)); + _nc_curr_token.tk_name, pushtype)); pushtype = NO_PUSHBACK; pushname[0] = '\0'; @@ -176,10 +180,10 @@ _nc_get_token(void) ch = next_char(); if (ch == '.' -#ifdef NCURSES_EXT_FUNCS - && !_nc_disable_period +#if NCURSES_EXT_FUNCS + && !_nc_disable_period #endif - ) { + ) { dot_flag = TRUE; DEBUG(8, ("dot-flag set")); @@ -194,12 +198,12 @@ _nc_get_token(void) /* have to make some punctuation chars legal for terminfo */ if (!isalnum(ch) -#ifdef NCURSES_EXT_FUNCS - && !(ch == '.' && _nc_disable_period) +#if NCURSES_EXT_FUNCS + && !(ch == '.' && _nc_disable_period) #endif - && !strchr(terminfo_punct, (char) ch)) { + && !strchr(terminfo_punct, (char) ch)) { _nc_warning("Illegal character (expected alphanumeric or %s) - %s", - terminfo_punct, unctrl(ch)); + terminfo_punct, unctrl(ch)); _nc_panic_mode(separator); goto start_token; } @@ -334,7 +338,7 @@ _nc_get_token(void) case '@': if ((ch = next_char()) != separator) _nc_warning("Missing separator after `%s', have %s", - buffer, unctrl(ch)); + buffer, unctrl(ch)); _nc_curr_token.tk_name = buffer; type = CANCEL; break; @@ -387,30 +391,30 @@ _nc_get_token(void) switch (type) { case BOOLEAN: _tracef("Token: Boolean; name='%s'", - _nc_curr_token.tk_name); + _nc_curr_token.tk_name); break; case NUMBER: _tracef("Token: Number; name='%s', value=%d", - _nc_curr_token.tk_name, - _nc_curr_token.tk_valnumber); + _nc_curr_token.tk_name, + _nc_curr_token.tk_valnumber); break; case STRING: _tracef("Token: String; name='%s', value=%s", - _nc_curr_token.tk_name, - _nc_visbuf(_nc_curr_token.tk_valstring)); + _nc_curr_token.tk_name, + _nc_visbuf(_nc_curr_token.tk_valstring)); break; case CANCEL: _tracef("Token: Cancel; name='%s'", - _nc_curr_token.tk_name); + _nc_curr_token.tk_name); break; case NAMES: _tracef("Token: Names; value='%s'", - _nc_curr_token.tk_name); + _nc_curr_token.tk_name); break; case EOF: @@ -567,7 +571,7 @@ _nc_trans_string(char *ptr, char *last) default: _nc_warning("Illegal character %s in \\ sequence", - unctrl(ch)); + unctrl(ch)); *(ptr++) = (char) ch; } /* endswitch (ch) */ } /* endelse (ch < '0' || ch > '7') */ @@ -617,7 +621,7 @@ _nc_push_token(int tokclass) _nc_get_type(pushname); DEBUG(3, ("pushing token: `%s', class %d", - _nc_curr_token.tk_name, pushtype)); + _nc_curr_token.tk_name, pushtype)); } /* @@ -732,7 +736,7 @@ next_char(void) } while (bufstart != NULL && line[0] == '#'); - if (bufstart == NULL) + if (bufstart == NULL || *bufstart == 0) return (EOF); while (iswhite(*bufptr)) @@ -745,10 +749,19 @@ next_char(void) if ((len = strlen(bufptr)) > 1) { if (bufptr[len - 1] == '\n' && bufptr[len - 2] == '\r') { - bufptr[len - 2] = '\n'; - bufptr[len - 1] = '\0'; + len--; + bufptr[len - 1] = '\n'; + bufptr[len] = '\0'; } } + + /* + * If we don't have a trailing newline, it's because the line is simply + * too long. Give up. (FIXME: We could instead reallocate the line + * buffer and allow arbitrary-length lines). + */ + if (len == 0 || (bufptr[len - 1] != '\n')) + return (EOF); } first_column = (bufptr == bufstart); @@ -778,7 +791,7 @@ end_of_stream(void) /* are we at end of input? */ { return ((yyin ? feof(yyin) : (bufptr && *bufptr == '\0')) - ? TRUE : FALSE); + ? TRUE : FALSE); } /* comp_scan.c ends here */ diff --git a/contrib/ncurses/ncurses/tinfo/free_ttype.c b/contrib/ncurses/ncurses/tinfo/free_ttype.c index d9d9c0aa52e8..aba1aeb9d82f 100644 --- a/contrib/ncurses/ncurses/tinfo/free_ttype.c +++ b/contrib/ncurses/ncurses/tinfo/free_ttype.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1999 Free Software Foundation, Inc. * + * Copyright (c) 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 * @@ -44,30 +44,29 @@ #include <tic.h> #include <term_entry.h> -MODULE_ID("$Id: free_ttype.c,v 1.3 2000/03/19 02:03:07 tom Exp $") +MODULE_ID("$Id: free_ttype.c,v 1.5 2000/07/08 00:43:58 tom Exp $") void _nc_free_termtype(TERMTYPE *ptr) { - FreeIfNeeded(ptr->str_table); - FreeIfNeeded(ptr->term_names); + FreeIfNeeded(ptr->str_table); + FreeIfNeeded(ptr->term_names); + FreeIfNeeded(ptr->Booleans); + FreeIfNeeded(ptr->Numbers); + FreeIfNeeded(ptr->Strings); #if NCURSES_XNAMES - FreeIfNeeded(ptr->ext_str_table); - FreeIfNeeded(ptr->Booleans); - FreeIfNeeded(ptr->Numbers); - FreeIfNeeded(ptr->Strings); - FreeIfNeeded(ptr->ext_Names); + FreeIfNeeded(ptr->ext_str_table); + FreeIfNeeded(ptr->ext_Names); #endif - memset(ptr, 0, sizeof(TERMTYPE)); + memset(ptr, 0, sizeof(TERMTYPE)); } #if NCURSES_XNAMES bool _nc_user_definable = TRUE; -bool _nc_disable_period = FALSE; /* used by tic -a option */ int use_extended_names(bool flag) { - int oldflag = _nc_user_definable; - _nc_user_definable = flag; - return oldflag; + int oldflag = _nc_user_definable; + _nc_user_definable = flag; + return oldflag; } #endif diff --git a/contrib/ncurses/ncurses/tinfo/home_terminfo.c b/contrib/ncurses/ncurses/tinfo/home_terminfo.c index 7aa4ca112e5a..69b8a96ffcff 100644 --- a/contrib/ncurses/ncurses/tinfo/home_terminfo.c +++ b/contrib/ncurses/ncurses/tinfo/home_terminfo.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998 Free Software Foundation, Inc. * + * Copyright (c) 1998,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 * @@ -27,7 +27,7 @@ ****************************************************************************/ /**************************************************************************** - * Author: Thomas E. Dickey <dickey@clark.net> 1998 * + * Author: Thomas E. Dickey <dickey@clark.net> 1998,2000 * ****************************************************************************/ /* @@ -37,7 +37,7 @@ #include <curses.priv.h> #include <tic.h> -MODULE_ID("$Id: home_terminfo.c,v 1.2 1999/02/27 19:58:46 tom Exp $") +MODULE_ID("$Id: home_terminfo.c,v 1.3 2000/10/04 02:31:53 tom Exp $"); #define my_length (strlen(home) + sizeof(PRIVATE_INFO)) @@ -46,17 +46,20 @@ MODULE_ID("$Id: home_terminfo.c,v 1.2 1999/02/27 19:58:46 tom Exp $") char * _nc_home_terminfo(void) { - char *home; - static char *temp = 0; + char *home; + static char *temp = 0; + if (use_terminfo_vars()) { if (temp == 0) { - if ((home = getenv("HOME")) != 0 - && my_length <= PATH_MAX) { - temp = typeMalloc(char, my_length); - if (temp == 0) - _nc_err_abort("Out of memory"); - (void) sprintf(temp, PRIVATE_INFO, home); - } + if ((home = getenv("HOME")) != 0 + && my_length <= PATH_MAX) { + temp = typeMalloc(char, my_length); + if (temp == 0) + _nc_err_abort("Out of memory"); + (void) sprintf(temp, PRIVATE_INFO, home); + } } return temp; + } + return 0; } diff --git a/contrib/ncurses/ncurses/tinfo/lib_baudrate.c b/contrib/ncurses/ncurses/tinfo/lib_baudrate.c index 4077ba384076..0d7fa27bcc3d 100644 --- a/contrib/ncurses/ncurses/tinfo/lib_baudrate.c +++ b/contrib/ncurses/ncurses/tinfo/lib_baudrate.c @@ -31,17 +31,16 @@ * and: Eric S. Raymond <esr@snark.thyrsus.com> * ****************************************************************************/ - /* * lib_baudrate.c * */ #include <curses.priv.h> -#include <term.h> /* cur_term, pad_char */ -#include <termcap.h> /* ospeed */ +#include <term.h> /* cur_term, pad_char */ +#include <termcap.h> /* ospeed */ -MODULE_ID("$Id: lib_baudrate.c,v 1.15 1999/01/31 03:05:25 tom Exp $") +MODULE_ID("$Id: lib_baudrate.c,v 1.17 2000/10/08 00:59:08 tom Exp $") /* * int @@ -52,117 +51,118 @@ MODULE_ID("$Id: lib_baudrate.c,v 1.15 1999/01/31 03:05:25 tom Exp $") */ struct speed { - speed_t s; - int sp; + int s; /* value for 'ospeed' is an index */ + int sp; /* the actual speed */ }; -static struct speed const speeds[] = { - {B0, 0}, - {B50, 50}, - {B75, 75}, - {B110, 110}, - {B134, 134}, - {B150, 150}, - {B200, 200}, - {B300, 300}, - {B600, 600}, - {B1200, 1200}, - {B1800, 1800}, - {B2400, 2400}, - {B4800, 4800}, - {B9600, 9600}, +static struct speed const speeds[] = +{ + {B0, 0}, + {B50, 50}, + {B75, 75}, + {B110, 110}, + {B134, 134}, + {B150, 150}, + {B200, 200}, + {B300, 300}, + {B600, 600}, + {B1200, 1200}, + {B1800, 1800}, + {B2400, 2400}, + {B4800, 4800}, + {B9600, 9600}, #ifdef B19200 - {B19200, 19200}, + {B19200, 19200}, #else #ifdef EXTA - {EXTA, 19200}, + {EXTA, 19200}, #endif #endif #ifdef B38400 - {B38400, 38400}, + {B38400, 38400}, #else #ifdef EXTB - {EXTB, 38400}, + {EXTB, 38400}, #endif #endif #ifdef B57600 - {B57600, 57600}, + {B57600, 57600}, #endif #ifdef B115200 - {B115200, 115200}, + {B115200, 115200}, #endif #ifdef B230400 - {B230400, 230400}, + {B230400, 230400}, #endif #ifdef B460800 - {B460800, 460800}, + {B460800, 460800}, #endif }; -int _nc_baudrate(int OSpeed) +int +_nc_baudrate(int OSpeed) { - static int last_OSpeed; - static int last_baudrate; - - int result; - unsigned i; - - if (OSpeed == last_OSpeed) { - result = last_baudrate; - } else { - result = ERR; - if (OSpeed >= 0) { - for (i = 0; i < SIZEOF(speeds); i++) { - if (speeds[i].s == (speed_t)OSpeed) { - result = speeds[i].sp; - break; - } - } + static int last_OSpeed; + static int last_baudrate; + + int result; + unsigned i; + + if (OSpeed == last_OSpeed) { + result = last_baudrate; + } else { + result = ERR; + if (OSpeed >= 0) { + for (i = 0; i < SIZEOF(speeds); i++) { + if (speeds[i].s == OSpeed) { + result = speeds[i].sp; + break; } - last_baudrate = result; + } } - return (result); + last_baudrate = result; + } + return (result); } - -int _nc_ospeed(int BaudRate) +int +_nc_ospeed(int BaudRate) { - speed_t result = 1; - unsigned i; - - if (BaudRate >= 0) { - for (i = 0; i < SIZEOF(speeds); i++) { - if (speeds[i].sp == BaudRate) { - result = speeds[i].s; - break; - } - } + int result = 1; + unsigned i; + + if (BaudRate >= 0) { + for (i = 0; i < SIZEOF(speeds); i++) { + if (speeds[i].sp == BaudRate) { + result = speeds[i].s; + break; + } } - return (result); + } + return (result); } int baudrate(void) { -int result; + int result; - T((T_CALLED("baudrate()"))); + T((T_CALLED("baudrate()"))); - /* - * In debugging, allow the environment symbol to override when we're - * redirecting to a file, so we can construct repeatable test-cases - * that take into account costs that depend on baudrate. - */ + /* + * In debugging, allow the environment symbol to override when we're + * redirecting to a file, so we can construct repeatable test-cases + * that take into account costs that depend on baudrate. + */ #ifdef TRACE - if (SP && !isatty(fileno(SP->_ofp)) - && getenv("BAUDRATE") != 0) { - int ret; - if ((ret = _nc_getenv_num("BAUDRATE")) <= 0) - ret = 9600; - ospeed = _nc_ospeed(ret); - returnCode(ret); - } - else + if (SP && !isatty(fileno(SP->_ofp)) + && getenv("BAUDRATE") != 0) { + int ret; + if ((ret = _nc_getenv_num("BAUDRATE")) <= 0) + ret = 9600; + ospeed = _nc_ospeed(ret); + returnCode(ret); + } else #endif #ifdef TERMIOS @@ -170,9 +170,9 @@ int result; #else ospeed = cur_term->Nttyb.sg_ospeed; #endif - result = _nc_baudrate(ospeed); - if (cur_term != 0) - cur_term->_baudrate = result; + result = _nc_baudrate(ospeed); + if (cur_term != 0) + cur_term->_baudrate = result; - returnCode(result); + returnCode(result); } diff --git a/contrib/ncurses/ncurses/tinfo/lib_options.c b/contrib/ncurses/ncurses/tinfo/lib_options.c index b58602af72bb..fc3dc42bca41 100644 --- a/contrib/ncurses/ncurses/tinfo/lib_options.c +++ b/contrib/ncurses/ncurses/tinfo/lib_options.c @@ -42,7 +42,7 @@ #include <term.h> -MODULE_ID("$Id: lib_options.c,v 1.39 2000/03/12 00:19:11 tom Exp $") +MODULE_ID("$Id: lib_options.c,v 1.40 2000/09/02 18:02:05 tom Exp $") int idlok(WINDOW *win, bool flag) @@ -206,7 +206,7 @@ typeahead(int fd) ** */ -#ifdef NCURSES_EXT_FUNCS +#if NCURSES_EXT_FUNCS static int has_key_internal(int keycode, struct tries *tp) { diff --git a/contrib/ncurses/ncurses/tinfo/lib_raw.c b/contrib/ncurses/ncurses/tinfo/lib_raw.c index 6033ed9c10c3..6df95714a9b1 100644 --- a/contrib/ncurses/ncurses/tinfo/lib_raw.c +++ b/contrib/ncurses/ncurses/tinfo/lib_raw.c @@ -48,9 +48,9 @@ #include <curses.priv.h> #include <term.h> /* cur_term */ -MODULE_ID("$Id: lib_raw.c,v 1.7 2000/02/13 01:01:26 tom Exp $") +MODULE_ID("$Id: lib_raw.c,v 1.8 2000/09/02 18:08:48 tom Exp $") -#if defined(SVR4_TERMIO) && !defined(_POSIX_SOURCE) +#if SVR4_TERMIO && !defined(_POSIX_SOURCE) #define _POSIX_SOURCE #endif diff --git a/contrib/ncurses/ncurses/tinfo/lib_setup.c b/contrib/ncurses/ncurses/tinfo/lib_setup.c index 50c330eb5739..1fd0d48f3cc8 100644 --- a/contrib/ncurses/ncurses/tinfo/lib_setup.c +++ b/contrib/ncurses/ncurses/tinfo/lib_setup.c @@ -42,13 +42,13 @@ #include <tic.h> /* for MAX_NAME_SIZE */ #include <term_entry.h> -#if defined(SVR4_TERMIO) && !defined(_POSIX_SOURCE) +#if SVR4_TERMIO && !defined(_POSIX_SOURCE) #define _POSIX_SOURCE #endif #include <term.h> /* lines, columns, cur_term */ -MODULE_ID("$Id: lib_setup.c,v 1.59 2000/02/13 01:01:26 tom Exp $") +MODULE_ID("$Id: lib_setup.c,v 1.60 2000/09/02 18:13:12 tom Exp $") /**************************************************************************** * @@ -245,7 +245,7 @@ grab_entry(const char *const tn, TERMTYPE * const tp) if ((status = _nc_read_entry(tn, filename, tp)) != 1) { -#ifndef PURE_TERMINFO +#if !PURE_TERMINFO /* * Try falling back on the termcap file. * Note: allowing this call links the entire terminfo/termcap diff --git a/contrib/ncurses/ncurses/tinfo/lib_termcap.c b/contrib/ncurses/ncurses/tinfo/lib_termcap.c index c47400132fa8..ecec2865fbae 100644 --- a/contrib/ncurses/ncurses/tinfo/lib_termcap.c +++ b/contrib/ncurses/ncurses/tinfo/lib_termcap.c @@ -39,7 +39,7 @@ #define __INTERNAL_CAPS_VISIBLE #include <term_entry.h> -MODULE_ID("$Id: lib_termcap.c,v 1.36 2000/02/13 01:01:26 tom Exp $") +MODULE_ID("$Id: lib_termcap.c,v 1.37 2000/09/16 20:30:16 tom Exp $") /* some of the code in here was contributed by: @@ -190,19 +190,3 @@ tgetstr(NCURSES_CONST char *id, char **area) } returnPtr(NULL); } - -/* - * char * - * tgoto(string, x, y) - * - * Retained solely for upward compatibility. Note the intentional - * reversing of the last two arguments. - * - */ - -char * -tgoto(const char *string, int x, int y) -{ - T((T_CALLED("tgoto(%s,%d,%d)"), string, x, y)); - returnPtr(tparm((NCURSES_CONST char *) string, y, x)); -} diff --git a/contrib/ncurses/ncurses/tinfo/lib_tgoto.c b/contrib/ncurses/ncurses/tinfo/lib_tgoto.c new file mode 100644 index 000000000000..73557eb7cc25 --- /dev/null +++ b/contrib/ncurses/ncurses/tinfo/lib_tgoto.c @@ -0,0 +1,197 @@ +/**************************************************************************** + * Copyright (c) 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 * + * "Software"), to deal in the Software without restriction, including * + * without limitation the rights to use, copy, modify, merge, publish, * + * distribute, distribute with modifications, sublicense, and/or sell * + * copies of the Software, and to permit persons to whom the Software is * + * furnished to do so, subject to the following conditions: * + * * + * The above copyright notice and this permission notice shall be included * + * in all copies or substantial portions of the Software. * + * * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * + * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * + * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * + * * + * Except as contained in this notice, the name(s) of the above copyright * + * holders shall not be used in advertising or otherwise to promote the * + * sale, use or other dealings in this Software without prior written * + * authorization. * + ****************************************************************************/ + +/**************************************************************************** + * Author: Thomas E. Dickey * + ****************************************************************************/ + +#include <curses.priv.h> + +#include <ctype.h> +#include <termcap.h> + +MODULE_ID("$Id: lib_tgoto.c,v 1.2 2000/09/24 00:19:14 tom Exp $") + +#if !PURE_TERMINFO +static bool +is_termcap(const char *string) +{ + bool result = TRUE; + + while ((*string != '\0') && result) { + if (*string == '%') { + switch (*++string) { + case 'p': + result = FALSE; + break; + case '\0': + string--; + break; + } + } else if (string[0] == '$' && string[1] == '<') { + result = FALSE; + } + string++; + } + return result; +} + +static char * +tgoto_internal(const char *string, int x, int y) +{ + static char *result; + static size_t length; + + int swap_arg; + int param[3]; + size_t used = 0; + size_t need = 10; + int *value = param; + bool need_BC = FALSE; + + if (BC) + need += strlen(BC); + + param[0] = y; + param[1] = x; + param[2] = 0; + + while (*string != 0) { + if ((used + need) > length) { + length += (used + need); + if ((result = _nc_doalloc(result, length)) == 0) { + length = 0; + break; + } + } + if (*string == '%') { + char *fmt = 0; + + switch (*++string) { + case '\0': + string--; + break; + case 'd': + fmt = "%d"; + break; + case '2': + fmt = "%02d"; + *value %= 100; + break; + case '3': + fmt = "%03d"; + *value %= 1000; + break; + case '+': + *value += (*++string & 0xff); + /* FALLTHRU */ + case '.': + /* + * Guard against tputs() seeing a truncated string. The + * termcap documentation refers to a similar fixup for \n + * and \r, but I don't see that it could work -TD + */ + if (*value == 0) { + if (BC != 0) { + *value += 1; + need_BC = TRUE; + } else { + *value = 0200; /* tputs will treat this as \0 */ + } + } + result[used++] = *value++; + break; + case '%': + result[used++] = *string; + break; + case 'r': + swap_arg = param[0]; + param[0] = param[1]; + param[1] = swap_arg; + break; + case 'i': + param[0] += 1; + param[1] += 1; + break; + case '>': + if (*value > string[1]) + *value += string[2]; + string += 2; + break; + case 'n': /* Datamedia 2500 */ + param[0] ^= 0140; + param[1] ^= 0140; + break; + case 'B': /* BCD */ + *value = 16 * (*value / 10) + (*value % 10); + break; + case 'D': /* Reverse coding (Delta Data) */ + *value -= 2 * (*value / 16); + break; + } + if (fmt != 0) { + sprintf(result + used, fmt, *value++); + used += strlen(result + used); + fmt = 0; + } + if (value - param > 2) { + value = param + 2; + *value = 0; + } + } else { + result[used++] = *string; + } + string++; + } + if (need_BC) { + strcpy(result + used, BC); + used += strlen(BC); + } + result[used] = '\0'; + return result; +} +#endif + +/* + * Retained solely for upward compatibility. Note the intentional reversing of + * the last two arguments when invoking tparm(). + */ +char * +tgoto(const char *string, int x, int y) +{ + char *result; + + T((T_CALLED("tgoto(%s, %d, %d)"), _nc_visbuf(string), x, y)); +#if !PURE_TERMINFO + if (is_termcap(string)) + result = tgoto_internal(string, x, y); + else +#endif + result = tparm((NCURSES_CONST char *) string, y, x); + returnPtr(result); +} diff --git a/contrib/ncurses/ncurses/tinfo/lib_tparm.c b/contrib/ncurses/ncurses/tinfo/lib_tparm.c index 71b82916a356..6a8ca1f0419a 100644 --- a/contrib/ncurses/ncurses/tinfo/lib_tparm.c +++ b/contrib/ncurses/ncurses/tinfo/lib_tparm.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998 Free Software Foundation, Inc. * + * Copyright (c) 1998,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> * ****************************************************************************/ - /* * tparm.c * @@ -43,7 +42,7 @@ #include <term.h> #include <tic.h> -MODULE_ID("$Id: lib_tparm.c,v 1.39 1999/06/06 00:04:55 tom Exp $") +MODULE_ID("$Id: lib_tparm.c,v 1.47 2000/10/04 00:57:13 tom Exp $") /* * char * @@ -74,6 +73,8 @@ MODULE_ID("$Id: lib_tparm.c,v 1.39 1999/06/06 00:04:55 tom Exp $") * %s print pop() like %s in printf() * %[[:]flags][width[.precision]][doxXs] * as in printf, flags are [-+#] and space + * The ':' is used to avoid making %+ or %- + * patterns (see below). * * %p[1-9] push ith parm * %P[a-z] set dynamic variable [a-z] to pop() @@ -105,481 +106,636 @@ MODULE_ID("$Id: lib_tparm.c,v 1.39 1999/06/06 00:04:55 tom Exp $") #define STACKSIZE 20 -typedef union { - unsigned int num; - char *str; +typedef struct { + union { + unsigned int num; + char *str; + } data; + bool num_type; } stack_frame; -static stack_frame stack[STACKSIZE]; -static int stack_ptr; +static stack_frame stack[STACKSIZE]; +static int stack_ptr; + #ifdef TRACE static const char *tname; #endif /* TRACE */ -static char *out_buff; +static char *out_buff; static size_t out_size; static size_t out_used; #if NO_LEAKS -void _nc_free_tparm(void) +void +_nc_free_tparm(void) { - if (out_buff != 0) { - FreeAndNull(out_buff); - out_size = 0; - out_used = 0; - } + if (out_buff != 0) { + FreeAndNull(out_buff); + out_size = 0; + out_used = 0; + } } #endif -static void really_get_space(size_t need) +static void +really_get_space(size_t need) { - out_size = need * 2; - out_buff = typeRealloc(char, out_size, out_buff); - if (out_buff == 0) - _nc_err_abort("Out of memory"); + out_size = need * 2; + out_buff = typeRealloc(char, out_size, out_buff); + if (out_buff == 0) + _nc_err_abort("Out of memory"); } -static inline void get_space(size_t need) +static inline void +get_space(size_t need) { - need += out_used; - if (need > out_size) - really_get_space(need); + need += out_used; + if (need > out_size) + really_get_space(need); } -static inline void save_text(const char *fmt, char *s, int len) +static inline void +save_text(const char *fmt, const char *s, int len) { - size_t s_len = strlen(s); - if (len > (int)s_len) - s_len = len; + size_t s_len = strlen(s); + if (len > (int) s_len) + s_len = len; - get_space(s_len + 1); + get_space(s_len + 1); - (void)sprintf(out_buff+out_used, fmt, s); - out_used += strlen(out_buff+out_used); + (void) sprintf(out_buff + out_used, fmt, s); + out_used += strlen(out_buff + out_used); } -static inline void save_number(const char *fmt, int number, int len) +static inline void +save_number(const char *fmt, int number, int len) { - if (len < 30) - len = 30; /* actually log10(MAX_INT)+1 */ + if (len < 30) + len = 30; /* actually log10(MAX_INT)+1 */ - get_space(len + 1); + get_space(len + 1); - (void)sprintf(out_buff+out_used, fmt, number); - out_used += strlen(out_buff+out_used); + (void) sprintf(out_buff + out_used, fmt, number); + out_used += strlen(out_buff + out_used); } -static inline void save_char(int c) +static inline void +save_char(int c) { - if (c == 0) - c = 0200; - get_space(1); - out_buff[out_used++] = c; + if (c == 0) + c = 0200; + get_space(1); + out_buff[out_used++] = c; } -static inline void npush(int x) +static inline void +npush(int x) { - if (stack_ptr < STACKSIZE) { - stack[stack_ptr].num = x; - stack_ptr++; - } + if (stack_ptr < STACKSIZE) { + stack[stack_ptr].num_type = TRUE; + stack[stack_ptr].data.num = x; + stack_ptr++; + } } -static inline int npop(void) +static inline int +npop(void) { - return (stack_ptr > 0 ? stack[--stack_ptr].num : 0); + int result = 0; + if (stack_ptr > 0) { + stack_ptr--; + if (stack[stack_ptr].num_type) + result = stack[stack_ptr].data.num; + } + return result; } -static inline char *spop(void) +static inline void +spush(char *x) { - static char dummy[] = ""; /* avoid const-cast */ - return (stack_ptr > 0 ? stack[--stack_ptr].str : dummy); + if (stack_ptr < STACKSIZE) { + stack[stack_ptr].num_type = FALSE; + stack[stack_ptr].data.str = x; + stack_ptr++; + } } -static inline const char *parse_format(const char *s, char *format, int *len) +static inline char * +spop(void) { - bool done = FALSE; - bool allowminus = FALSE; - bool dot = FALSE; - int prec = 0; - int width = 0; + static char dummy[] = ""; /* avoid const-cast */ + char *result = dummy; + if (stack_ptr > 0) { + stack_ptr--; + if (!stack[stack_ptr].num_type && stack[stack_ptr].data.str != 0) + result = stack[stack_ptr].data.str; + } + return result; +} - *len = 0; - *format++ = '%'; - while (*s != '\0' && !done) { - switch (*s) { - case 'c': /* FALLTHRU */ - case 'd': /* FALLTHRU */ - case 'o': /* FALLTHRU */ - case 'x': /* FALLTHRU */ - case 'X': /* FALLTHRU */ - case 's': - *format++ = *s; - done = TRUE; - break; - case '.': - *format++ = *s++; - dot = TRUE; - break; - case '#': - *format++ = *s++; - break; - case ' ': - *format++ = *s++; - break; - case ':': - s++; - allowminus = TRUE; - break; - case '-': - if (allowminus) { - *format++ = *s++; - } else { - done = TRUE; - } - break; - default: - if (isdigit(*s)) { - if (dot) - prec = (prec * 10) + (*s - '0'); - else - width = (width * 10) + (*s - '0'); - *format++ = *s++; - } else { - done = TRUE; - } - } +static inline const char * +parse_format(const char *s, char *format, int *len) +{ + bool done = FALSE; + bool allowminus = FALSE; + bool dot = FALSE; + bool err = FALSE; + char *fmt = format; + int prec = 0; + int width = 0; + int value = 0; + + *len = 0; + *format++ = '%'; + while (*s != '\0' && !done) { + switch (*s) { + case 'c': /* FALLTHRU */ + case 'd': /* FALLTHRU */ + case 'o': /* FALLTHRU */ + case 'x': /* FALLTHRU */ + case 'X': /* FALLTHRU */ + case 's': + *format++ = *s; + done = TRUE; + break; + case '.': + *format++ = *s++; + if (dot) { + err = TRUE; + } else { + dot = TRUE; + prec = value; + } + value = 0; + break; + case '#': + *format++ = *s++; + break; + case ' ': + *format++ = *s++; + break; + case ':': + s++; + allowminus = TRUE; + break; + case '-': + if (allowminus) { + *format++ = *s++; + } else { + done = TRUE; + } + break; + default: + if (isdigit(*s)) { + value = (value * 10) + (*s - '0'); + if (value > 10000) + err = TRUE; + *format++ = *s++; + } else { + done = TRUE; + } } - *format = '\0'; - /* return maximum string length in print */ - *len = (prec > width) ? prec : width; - return s; + } + + /* + * If we found an error, ignore (and remove) the flags. + */ + if (err) { + prec = width = value = 0; + format = fmt; + *format++ = '%'; + *format++ = *s; + } + + if (dot) + width = value; + else + prec = value; + + *format = '\0'; + /* return maximum string length in print */ + *len = (prec > width) ? prec : width; + return s; } #define isUPPER(c) ((c) >= 'A' && (c) <= 'Z') #define isLOWER(c) ((c) >= 'a' && (c) <= 'z') -static inline char *tparam_internal(const char *string, va_list ap) +static inline char * +tparam_internal(const char *string, va_list ap) { #define NUM_VARS 26 -int param[9]; -int popcount; -int number; -int len; -int level; -int x, y; -int i; -register const char *cp; -static size_t len_fmt; -static char *format; -static int dynamic_var[NUM_VARS]; -static int static_vars[NUM_VARS]; - - out_used = 0; - if (string == NULL) - return NULL; - - /* - * Find the highest parameter-number referred to in the format string. - * Use this value to limit the number of arguments copied from the - * variable-length argument list. - */ - for (cp = string, popcount = number = 0; *cp != '\0'; cp++) { - if (cp[0] == '%' && cp[1] != '\0') { - switch (cp[1]) { - case '%': - cp++; - break; - case 'i': - if (popcount < 2) - popcount = 2; - break; - case 'p': - cp++; - if (cp[1] >= '1' && cp[1] <= '9') { - int c = cp[1] - '0'; - if (c > popcount) - popcount = c; - } - break; - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - case 'd': case 'c': case 's': - ++number; - break; - } + char *p_is_s[9]; + int param[9]; + int lastpop; + int popcount; + int number; + int len; + int level; + int x, y; + int i; + size_t len2; + register const char *cp; + static size_t len_fmt; + static char dummy[] = ""; + static char *format; + static int dynamic_var[NUM_VARS]; + static int static_vars[NUM_VARS]; + + out_used = 0; + if (string == NULL) + return NULL; + + if ((len2 = strlen(string)) > len_fmt) { + len_fmt = len2 + len_fmt + 2; + if ((format = typeRealloc(char, len_fmt, format)) == 0) + return 0; + } + + /* + * Find the highest parameter-number referred to in the format string. + * Use this value to limit the number of arguments copied from the + * variable-length argument list. + */ + + number = 0; + lastpop = -1; + popcount = 0; + memset(p_is_s, 0, sizeof(p_is_s)); + + /* + * Analyze the string to see how many parameters we need from the varargs + * list, and what their types are. We will only accept string parameters + * if they appear as a %l or %s format following an explicit parameter + * reference (e.g., %p2%s). All other parameters are numbers. + * + * 'number' counts coarsely the number of pop's we see in the string, and + * 'popcount' shows the highest parameter number in the string. We would + * like to simply use the latter count, but if we are reading termcap + * strings, there may be cases that we cannot see the explicit parameter + * numbers. + */ + for (cp = string; (cp - string) < (int) len2;) { + if (*cp == '%') { + cp++; + cp = parse_format(cp, format, &len); + switch (*cp) { + default: + break; + + case 'd': /* FALLTHRU */ + case 'o': /* FALLTHRU */ + case 'x': /* FALLTHRU */ + case 'X': /* FALLTHRU */ + case 'c': /* FALLTHRU */ + number++; + lastpop = -1; + break; + + case 'l': + case 's': + if (lastpop > 0) + p_is_s[lastpop - 1] = dummy; + ++number; + break; + + case 'p': + cp++; + i = (*cp - '0'); + if (i >= 0 && i <= 9) { + lastpop = i; + if (lastpop > popcount) + popcount = lastpop; } + break; + + case 'P': + case 'g': + cp++; + break; + + case S_QUOTE: + cp += 2; + lastpop = -1; + break; + + case L_BRACE: + cp++; + while (*cp >= '0' && *cp <= '9') { + cp++; + } + break; + + case '+': + case '-': + case '*': + case '/': + case 'm': + case 'A': + case 'O': + case '&': + case '|': + case '^': + case '=': + case '<': + case '>': + case '!': + case '~': + lastpop = -1; + number += 2; + break; + + case 'i': + lastpop = -1; + if (popcount < 2) + popcount = 2; + break; + } } - if ((size_t)(cp - string) > len_fmt) { - len_fmt = (cp - string) + len_fmt + 2; - if ((format = typeRealloc(char, len_fmt, format)) == 0) - return 0; - } - - if (number > 9) number = 9; - for (i = 0; i < max(popcount, number); i++) { - /* - * FIXME: potential loss here if sizeof(int) != sizeof(char *). - * A few caps (such as plab_norm) have string-valued parms. - */ - param[i] = va_arg(ap, int); - } + if (*cp != '\0') + cp++; + } + if (number > 9) + number = 9; + for (i = 0; i < max(popcount, number); i++) { /* - * This is a termcap compatibility hack. If there are no explicit pop - * operations in the string, load the stack in such a way that - * successive pops will grab successive parameters. That will make - * the expansion of (for example) \E[%d;%dH work correctly in termcap - * style, which means tparam() will expand termcap strings OK. + * A few caps (such as plab_norm) have string-valued parms. + * We'll have to assume that the caller knows the difference, since + * a char* and an int may not be the same size on the stack. */ - stack_ptr = 0; - if (popcount == 0) { - popcount = number; - for (i = number - 1; i >= 0; i--) - npush(param[i]); + if (p_is_s[i] != 0) { + p_is_s[i] = va_arg(ap, char *); + } else { + param[i] = va_arg(ap, int); } - + } + + /* + * This is a termcap compatibility hack. If there are no explicit pop + * operations in the string, load the stack in such a way that + * successive pops will grab successive parameters. That will make + * the expansion of (for example) \E[%d;%dH work correctly in termcap + * style, which means tparam() will expand termcap strings OK. + */ + stack_ptr = 0; + if (popcount == 0) { + popcount = number; + for (i = number - 1; i >= 0; i--) + npush(param[i]); + } #ifdef TRACE - if (_nc_tracing & TRACE_CALLS) { - for (i = 0; i < popcount; i++) - save_number(", %d", param[i], 0); - _tracef(T_CALLED("%s(%s%s)"), tname, _nc_visbuf(string), out_buff); - out_used = 0; + if (_nc_tracing & TRACE_CALLS) { + for (i = 0; i < popcount; i++) { + if (p_is_s[i] != 0) + save_text(", %s", _nc_visbuf(p_is_s[i]), 0); + else + save_number(", %d", param[i], 0); } + _tracef(T_CALLED("%s(%s%s)"), tname, _nc_visbuf(string), out_buff); + out_used = 0; + } #endif /* TRACE */ - while (*string) { - if (*string != '%') { - save_char(*string); - } else { - string++; - string = parse_format(string, format, &len); - switch (*string) { - default: - break; - case '%': - save_char('%'); - break; - - case 'd': /* FALLTHRU */ - case 'o': /* FALLTHRU */ - case 'x': /* FALLTHRU */ - case 'X': /* FALLTHRU */ - case 'c': - save_number(format, npop(), len); - break; - - case 'l': - save_number("%d", strlen(spop()), 0); - break; - - case 's': - save_text(format, spop(), len); - break; - - case 'p': - string++; - if (*string >= '1' && *string <= '9') - npush(param[*string - '1']); - break; - - case 'P': - string++; - if (isUPPER(*string)) { - i = (*string - 'A'); - static_vars[i] = npop(); - } else if (isLOWER(*string)) { - i = (*string - 'a'); - dynamic_var[i] = npop(); - } - break; - - case 'g': - string++; - if (isUPPER(*string)) { - i = (*string - 'A'); - npush(static_vars[i]); - } else if (isLOWER(*string)) { - i = (*string - 'a'); - npush(dynamic_var[i]); - } - break; - - case S_QUOTE: - string++; - npush(*string); - string++; - break; - - case L_BRACE: - number = 0; - string++; - while (*string >= '0' && *string <= '9') { - number = number * 10 + *string - '0'; - string++; - } - npush(number); - break; - - case '+': - npush(npop() + npop()); - break; - - case '-': - y = npop(); - x = npop(); - npush(x - y); - break; - - case '*': - npush(npop() * npop()); - break; - - case '/': - y = npop(); - x = npop(); - npush(y ? (x / y) : 0); - break; - - case 'm': - y = npop(); - x = npop(); - npush(y ? (x % y) : 0); - break; - - case 'A': - npush(npop() && npop()); - break; - - case 'O': - npush(npop() || npop()); - break; - - case '&': - npush(npop() & npop()); - break; - - case '|': - npush(npop() | npop()); - break; - - case '^': - npush(npop() ^ npop()); - break; - - case '=': - y = npop(); - x = npop(); - npush(x == y); - break; - - case '<': - y = npop(); - x = npop(); - npush(x < y); - break; + while (*string) { + if (*string != '%') { + save_char(*string); + } else { + string++; + string = parse_format(string, format, &len); + switch (*string) { + default: + break; + case '%': + save_char('%'); + break; + + case 'd': /* FALLTHRU */ + case 'o': /* FALLTHRU */ + case 'x': /* FALLTHRU */ + case 'X': /* FALLTHRU */ + case 'c': /* FALLTHRU */ + save_number(format, npop(), len); + break; + + case 'l': + save_number("%d", strlen(spop()), 0); + break; + + case 's': + save_text(format, spop(), len); + break; + + case 'p': + string++; + i = (*string - '1'); + if (i >= 0 && i < 9) { + if (p_is_s[i]) + spush(p_is_s[i]); + else + npush(param[i]); + } + break; - case '>': - y = npop(); - x = npop(); - npush(x > y); - break; + case 'P': + string++; + if (isUPPER(*string)) { + i = (*string - 'A'); + static_vars[i] = npop(); + } else if (isLOWER(*string)) { + i = (*string - 'a'); + dynamic_var[i] = npop(); + } + break; - case '!': - npush(! npop()); - break; + case 'g': + string++; + if (isUPPER(*string)) { + i = (*string - 'A'); + npush(static_vars[i]); + } else if (isLOWER(*string)) { + i = (*string - 'a'); + npush(dynamic_var[i]); + } + break; - case '~': - npush(~ npop()); - break; + case S_QUOTE: + string++; + npush(*string); + string++; + break; - case 'i': - param[0]++; - param[1]++; + case L_BRACE: + number = 0; + string++; + while (*string >= '0' && *string <= '9') { + number = number * 10 + *string - '0'; + string++; + } + npush(number); + break; + + case '+': + npush(npop() + npop()); + break; + + case '-': + y = npop(); + x = npop(); + npush(x - y); + break; + + case '*': + npush(npop() * npop()); + break; + + case '/': + y = npop(); + x = npop(); + npush(y ? (x / y) : 0); + break; + + case 'm': + y = npop(); + x = npop(); + npush(y ? (x % y) : 0); + break; + + case 'A': + npush(npop() && npop()); + break; + + case 'O': + npush(npop() || npop()); + break; + + case '&': + npush(npop() & npop()); + break; + + case '|': + npush(npop() | npop()); + break; + + case '^': + npush(npop() ^ npop()); + break; + + case '=': + y = npop(); + x = npop(); + npush(x == y); + break; + + case '<': + y = npop(); + x = npop(); + npush(x < y); + break; + + case '>': + y = npop(); + x = npop(); + npush(x > y); + break; + + case '!': + npush(!npop()); + break; + + case '~': + npush(~npop()); + break; + + case 'i': + if (p_is_s[0] == 0) + param[0]++; + if (p_is_s[1] == 0) + param[1]++; + break; + + case '?': + break; + + case 't': + x = npop(); + if (!x) { + /* scan forward for %e or %; at level zero */ + string++; + level = 0; + while (*string) { + if (*string == '%') { + string++; + if (*string == '?') + level++; + else if (*string == ';') { + if (level > 0) + level--; + else + break; + } else if (*string == 'e' && level == 0) break; + } - case '?': - break; + if (*string) + string++; + } + } + break; - case 't': - x = npop(); - if (!x) { - /* scan forward for %e or %; at level zero */ - string++; - level = 0; - while (*string) { - if (*string == '%') { - string++; - if (*string == '?') - level++; - else if (*string == ';') { - if (level > 0) - level--; - else - break; - } - else if (*string == 'e' && level == 0) - break; - } - - if (*string) - string++; - } - } + case 'e': + /* scan forward for a %; at level zero */ + string++; + level = 0; + while (*string) { + if (*string == '%') { + string++; + if (*string == '?') + level++; + else if (*string == ';') { + if (level > 0) + level--; + else break; + } + } - case 'e': - /* scan forward for a %; at level zero */ - string++; - level = 0; - while (*string) { - if (*string == '%') { - string++; - if (*string == '?') - level++; - else if (*string == ';') { - if (level > 0) - level--; - else - break; - } - } - - if (*string) - string++; - } - break; + if (*string) + string++; + } + break; - case ';': - break; + case ';': + break; - } /* endswitch (*string) */ - } /* endelse (*string == '%') */ + } /* endswitch (*string) */ + } /* endelse (*string == '%') */ - if (*string == '\0') - break; + if (*string == '\0') + break; - string++; - } /* endwhile (*string) */ + string++; + } /* endwhile (*string) */ - if (out_buff == 0 && (out_buff = typeCalloc(char,1)) == NULL) - return(NULL); - out_buff[out_used] = '\0'; + if (out_buff == 0 && (out_buff = typeCalloc(char, 1)) == NULL) + return (NULL); + out_buff[out_used] = '\0'; - T((T_RETURN("%s"), _nc_visbuf(out_buff))); - return(out_buff); + T((T_RETURN("%s"), _nc_visbuf(out_buff))); + return (out_buff); } -char *tparm(NCURSES_CONST char *string, ...) +char * +tparm(NCURSES_CONST char *string,...) { -va_list ap; -char *result; + va_list ap; + char *result; - va_start(ap, string); + va_start(ap, string); #ifdef TRACE - tname = "tparm"; + tname = "tparm"; #endif /* TRACE */ - result = tparam_internal(string, ap); - va_end(ap); - return result; + result = tparam_internal(string, ap); + va_end(ap); + return result; } diff --git a/contrib/ncurses/ncurses/tinfo/lib_tputs.c b/contrib/ncurses/ncurses/tinfo/lib_tputs.c index f17d8382e921..93eebf88691f 100644 --- a/contrib/ncurses/ncurses/tinfo/lib_tputs.c +++ b/contrib/ncurses/ncurses/tinfo/lib_tputs.c @@ -45,10 +45,10 @@ #include <termcap.h> /* ospeed */ #include <tic.h> -MODULE_ID("$Id: lib_tputs.c,v 1.47 2000/05/27 23:08:41 tom Exp $") +MODULE_ID("$Id: lib_tputs.c,v 1.51 2000/10/08 00:22:24 tom Exp $") char PC = 0; /* used by termcap library */ -speed_t ospeed = 0; /* used by termcap library */ +short ospeed = 0; /* used by termcap library */ int _nc_nulls_sent = 0; /* used by 'tack' program */ @@ -78,7 +78,7 @@ delay_output(int ms) void _nc_flush(void) { - (void)fflush(NC_OUTPUT); + (void) fflush(NC_OUTPUT); } int @@ -102,7 +102,7 @@ _nc_outch(int ch) return OK; } -#ifdef USE_WIDEC_SUPPORT +#if USE_WIDEC_SUPPORT /* * Reference: The Unicode Standard 2.0 * @@ -120,20 +120,20 @@ _nc_utf8_outch(int ch) int result[7], *ptr; int count = 0; - if (ch < 0x80) + if ((unsigned int) ch < 0x80) count = 1; - else if (ch < 0x800) + else if ((unsigned int) ch < 0x800) count = 2; - else if (ch < 0x10000) + else if ((unsigned int) ch < 0x10000) count = 3; - else if (ch < 0x200000) + else if ((unsigned int) ch < 0x200000) count = 4; - else if (ch < 0x4000000) + else if ((unsigned int) ch < 0x4000000) count = 5; - else if (ch <= 0x7FFFFFFF) + else if ((unsigned int) ch <= 0x7FFFFFFF) count = 6; else { - count = 2; + count = 3; ch = 0xFFFD; } ptr = result + count; @@ -141,20 +141,26 @@ _nc_utf8_outch(int ch) case 6: *--ptr = (ch | otherMark) & byteMask; ch >>= 6; + /* FALLTHRU */ case 5: *--ptr = (ch | otherMark) & byteMask; ch >>= 6; + /* FALLTHRU */ case 4: *--ptr = (ch | otherMark) & byteMask; ch >>= 6; + /* FALLTHRU */ case 3: *--ptr = (ch | otherMark) & byteMask; ch >>= 6; + /* FALLTHRU */ case 2: *--ptr = (ch | otherMark) & byteMask; ch >>= 6; + /* FALLTHRU */ case 1: *--ptr = (ch | firstMark[count]); + break; } while (count--) _nc_outch(*ptr++); @@ -174,7 +180,7 @@ tputs(const char *string, int affcnt, int (*outc) (int)) bool always_delay; bool normal_delay; int number; -#ifdef BSD_TPUTS +#if BSD_TPUTS int trailpad; #endif /* BSD_TPUTS */ @@ -188,7 +194,7 @@ tputs(const char *string, int affcnt, int (*outc) (int)) (void) sprintf(addrbuf, "%p", outc); if (_nc_tputs_trace) { _tracef("tputs(%s = %s, %d, %s) called", _nc_tputs_trace, - _nc_visbuf(string), affcnt, addrbuf); + _nc_visbuf(string), affcnt, addrbuf); } else { _tracef("tputs(%s, %d, %s) called", _nc_visbuf(string), affcnt, addrbuf); } @@ -207,13 +213,13 @@ tputs(const char *string, int affcnt, int (*outc) (int)) normal_delay = !xon_xoff && padding_baud_rate -#ifdef NCURSES_NO_PADDING +#if NCURSES_NO_PADDING && (SP == 0 || !(SP->_no_padding)) #endif && (_nc_baudrate(ospeed) >= padding_baud_rate); } -#ifdef BSD_TPUTS +#if BSD_TPUTS /* * This ugly kluge deals with the fact that some ancient BSD programs * (like nethack) actually do the likes of tputs("50") to get delays. @@ -304,7 +310,7 @@ tputs(const char *string, int affcnt, int (*outc) (int)) string++; } -#ifdef BSD_TPUTS +#if BSD_TPUTS /* * Emit any BSD-style prefix padding that we've accumulated now. */ diff --git a/contrib/ncurses/ncurses/tinfo/parse_entry.c b/contrib/ncurses/ncurses/tinfo/parse_entry.c index 1aff562d0dd6..24bf3c37f584 100644 --- a/contrib/ncurses/ncurses/tinfo/parse_entry.c +++ b/contrib/ncurses/ncurses/tinfo/parse_entry.c @@ -47,7 +47,7 @@ #define __INTERNAL_CAPS_VISIBLE #include <term_entry.h> -MODULE_ID("$Id: parse_entry.c,v 1.44 2000/04/30 00:17:42 tom Exp $") +MODULE_ID("$Id: parse_entry.c,v 1.48 2000/10/03 09:38:48 tom Exp $") #ifdef LINT static short const parametrized[] = @@ -200,7 +200,7 @@ _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]; + char *ptr, *base; token_type = _nc_get_token(); @@ -235,22 +235,22 @@ _nc_parse_entry(struct entry *entryp, int literal, bool silent) _nc_set_type(_nc_first_name(entryp->tterm.term_names)); /* 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) - *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) - if (strlen(ptr) > MAX_ALIAS) - _nc_warning("alias `%s' may be too long", ptr); + for (base = entryp->tterm.term_names; (ptr = strchr(base, '|')) != 0; + base = ptr + 1) { + if (ptr - base > MAX_ALIAS) { + _nc_warning("%s `%.*s' may be too long", + (base == entryp->tterm.term_names) + ? "primary name" + : "alias", + ptr - base, base); + } + } 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].name = _nc_save_str(_nc_curr_token.tk_valstring); @@ -259,7 +259,7 @@ _nc_parse_entry(struct entry *entryp, int literal, bool silent) } 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 @@ -277,14 +277,14 @@ _nc_parse_entry(struct entry *entryp, int literal, bool silent) 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); + ap->from, ap->source, ap->to); break; } } else { /* if (_nc_syntax == SYN_TERMINFO) */ @@ -292,14 +292,14 @@ _nc_parse_entry(struct entry *entryp, int literal, bool silent) 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); + ap->from, ap->source, ap->to); break; } @@ -316,7 +316,8 @@ _nc_parse_entry(struct entry *entryp, int literal, bool silent) if (entry_ptr == NOTFOUND && _nc_user_definable && (entry_ptr = _nc_extend_names(entryp, - _nc_curr_token.tk_name, token_type)) != 0) { + _nc_curr_token.tk_name, + token_type)) != 0) { if (_nc_tracing >= DEBUG_LEVEL(1)) _nc_warning("extended capability '%s'", _nc_curr_token.tk_name); } @@ -326,7 +327,7 @@ _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; } @@ -345,12 +346,14 @@ _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)) 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) @@ -374,7 +377,7 @@ _nc_parse_entry(struct entry *entryp, int literal, bool silent) 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; } @@ -411,8 +414,8 @@ _nc_parse_entry(struct entry *entryp, int literal, bool silent) ptr = _nc_curr_token.tk_valstring; 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; @@ -479,14 +482,14 @@ _nc_capcmp(const char *s, const char *t) if (s[0] == '$' && s[1] == '<') { for (s += 2;; s++) if (!(isdigit(*s) || *s == '.' || *s == '*' || *s == '/' || - *s == '>')) + *s == '>')) break; } if (t[0] == '$' && t[1] == '<') { for (t += 2;; t++) if (!(isdigit(*t) || *t == '.' || *t == '*' || *t == '/' || - *t == '>')) + *t == '>')) break; } @@ -503,6 +506,26 @@ _nc_capcmp(const char *s, const char *t) } } +static void +append_acs0(string_desc *dst, int code, int src) +{ + if (src != 0) { + char temp[3]; + temp[0] = code; + temp[1] = src; + temp[2] = 0; + _nc_safe_strcat(dst, temp); + } +} + +static void +append_acs(string_desc *dst, int code, char *src) +{ + if (src != 0 && strlen(src) == 1) { + append_acs0(dst, code, *src); + } +} + /* * The ko capability, if present, consists of a comma-separated capability * list. For each capability, we may assume there is a keycap that sends the @@ -563,11 +586,11 @@ static const char C_HT[] = "\t"; #undef CUR #define CUR tp-> -static -void +static void postprocess_termcap(TERMTYPE * tp, bool has_base) { char buf[MAX_LINE * 2 + 2]; + string_desc result; /* * TERMCAP DEFAULTS AND OBSOLETE-CAPABILITY TRANSLATIONS @@ -632,17 +655,15 @@ 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); - buf[MAX_LINE] = '\0'; - newline = _nc_save_str(buf); + _nc_str_init(&result, buf, sizeof(buf)); + if (_nc_safe_strcat(&result, carriage_return) + && _nc_safe_strcat(&result, scroll_forward)) + 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); - buf[MAX_LINE] = '\0'; - newline = _nc_save_str(buf); + _nc_str_init(&result, buf, sizeof(buf)); + if (_nc_safe_strcat(&result, carriage_return) + && _nc_safe_strcat(&result, cursor_down)) + newline = _nc_save_str(buf); } } } @@ -695,7 +716,7 @@ postprocess_termcap(TERMTYPE * tp, bool has_base) else { if (tab && _nc_capcmp(tab, C_HT)) _nc_warning("hardware tabs with a non-^I tab string %s", - _nc_visbuf(tab)); + _nc_visbuf(tab)); else { if (WANTED(tab)) tab = _nc_save_str(C_HT); @@ -708,7 +729,8 @@ postprocess_termcap(TERMTYPE * tp, bool has_base) * isn't from mytinfo... */ if (PRESENT(other_non_function_keys)) { - char *dp, *cp = strtok(other_non_function_keys, ","); + char *base = other_non_function_keys; + char *bp, *cp, *dp; struct name_table_entry const *from_ptr; struct name_table_entry const *to_ptr; assoc const *ap; @@ -717,15 +739,21 @@ postprocess_termcap(TERMTYPE * tp, bool has_base) /* we're going to use this for a special case later */ dp = strchr(other_non_function_keys, 'i'); - foundim = dp && dp[1] == 'm'; + foundim = (dp != 0) && (dp[1] == 'm'); /* look at each comma-separated capability in the ko string... */ - do { + for (base = other_non_function_keys; + (cp = strchr(base, ',')) != 0; + base = cp + 1) { + size_t len = cp - base; + for (ap = ko_xlate; ap->from; ap++) - if (strcmp(ap->from, cp) == 0) + if (len == strlen(ap->from) + && strncmp(ap->from, base, len) == 0) break; if (!ap->to) { - _nc_warning("unknown capability `%s' in ko string", cp); + _nc_warning("unknown capability `%.*s' in ko string", + (int) len, base); continue; } else if (ap->to == CANCELLED_STRING) /* ignore it */ continue; @@ -748,11 +776,11 @@ postprocess_termcap(TERMTYPE * tp, bool has_base) * string; that's just an inefficiency. */ if (strcmp( - tp->Strings[from_ptr->nte_index], - tp->Strings[to_ptr->nte_index]) != 0) + 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; } @@ -760,22 +788,18 @@ postprocess_termcap(TERMTYPE * tp, bool has_base) * The magic moment -- copy the mapped key string over, * stripping out padding. */ - dp = buf2; - for (cp = tp->Strings[from_ptr->nte_index]; *cp; cp++) { - if (cp[0] == '$' && cp[1] == '<') { - while (*cp && *cp != '>') - if (!*cp) - break; - else - ++cp; + for (dp = buf2, bp = tp->Strings[from_ptr->nte_index]; *bp; bp++) { + if (bp[0] == '$' && bp[1] == '<') { + while (*bp && *bp != '>') { + ++bp; + } } else - *dp++ = *cp; + *dp++ = *bp; } *dp++ = '\0'; tp->Strings[to_ptr->nte_index] = _nc_save_str(buf2); - } while - ((cp = strtok((char *) 0, ",")) != 0); + } /* * Note: ko=im and ko=ic both want to grab the `Insert' @@ -812,74 +836,36 @@ postprocess_termcap(TERMTYPE * tp, bool has_base) PRESENT(acs_hline) || PRESENT(acs_vline) || PRESENT(acs_plus)) { - char buf2[MAX_TERMCAP_LENGTH], *bp = buf2; - - if (acs_chars) { - (void) strcpy(bp, acs_chars); - bp += strlen(bp); - } - - if (acs_ulcorner && acs_ulcorner[1] == '\0') { - *bp++ = 'l'; - *bp++ = *acs_ulcorner; - } - if (acs_llcorner && acs_llcorner[1] == '\0') { - *bp++ = 'm'; - *bp++ = *acs_llcorner; - } - if (acs_urcorner && acs_urcorner[1] == '\0') { - *bp++ = 'k'; - *bp++ = *acs_urcorner; - } - if (acs_lrcorner && acs_lrcorner[1] == '\0') { - *bp++ = 'j'; - *bp++ = *acs_lrcorner; - } - if (acs_ltee && acs_ltee[1] == '\0') { - *bp++ = 't'; - *bp++ = *acs_ltee; - } - if (acs_rtee && acs_rtee[1] == '\0') { - *bp++ = 'u'; - *bp++ = *acs_rtee; - } - if (acs_btee && acs_btee[1] == '\0') { - *bp++ = 'v'; - *bp++ = *acs_btee; - } - if (acs_ttee && acs_ttee[1] == '\0') { - *bp++ = 'w'; - *bp++ = *acs_ttee; - } - if (acs_hline && acs_hline[1] == '\0') { - *bp++ = 'q'; - *bp++ = *acs_hline; - } - if (acs_vline && acs_vline[1] == '\0') { - *bp++ = 'x'; - *bp++ = *acs_vline; - } - if (acs_plus) { - *bp++ = 'n'; - strcpy(bp, acs_plus); - bp = buf2 + strlen(buf2); - } - - if (bp != buf2) { - *bp++ = '\0'; + char buf2[MAX_TERMCAP_LENGTH]; + + _nc_str_init(&result, buf2, sizeof(buf2)); + _nc_safe_strcat(&result, acs_chars); + + append_acs (&result, 'j', acs_lrcorner); + append_acs (&result, 'k', acs_urcorner); + append_acs (&result, 'l', acs_ulcorner); + append_acs (&result, 'm', acs_llcorner); + append_acs (&result, 'n', acs_plus); + append_acs (&result, 'q', acs_hline); + append_acs (&result, 't', acs_ltee); + append_acs (&result, 'u', acs_rtee); + append_acs (&result, 'v', acs_btee); + append_acs (&result, 'w', acs_ttee); + append_acs (&result, 'x', acs_vline); + + if (buf2[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) { + && enter_alt_charset_mode != 0 + && exit_alt_charset_mode != 0) { acs_chars = _nc_save_str("``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~"); } } -static -void +static void postprocess_terminfo(TERMTYPE * tp) { /* @@ -891,60 +877,25 @@ postprocess_terminfo(TERMTYPE * tp) * Translate AIX forms characters. */ if (PRESENT(box_chars_1)) { - char buf2[MAX_TERMCAP_LENGTH], *bp = buf2; - - if (acs_chars) { - (void) strcpy(bp, acs_chars); - bp += strlen(bp); - } - - if (box_chars_1[0]) { /* ACS_ULCORNER */ - *bp++ = 'l'; - *bp++ = box_chars_1[0]; - } - if (box_chars_1[1]) { /* ACS_HLINE */ - *bp++ = 'q'; - *bp++ = box_chars_1[1]; - } - if (box_chars_1[2]) { /* ACS_URCORNER */ - *bp++ = 'k'; - *bp++ = box_chars_1[2]; - } - if (box_chars_1[3]) { /* ACS_VLINE */ - *bp++ = 'x'; - *bp++ = box_chars_1[3]; - } - if (box_chars_1[4]) { /* ACS_LRCORNER */ - *bp++ = 'j'; - *bp++ = box_chars_1[4]; - } - if (box_chars_1[5]) { /* ACS_LLCORNER */ - *bp++ = 'm'; - *bp++ = box_chars_1[5]; - } - if (box_chars_1[6]) { /* ACS_TTEE */ - *bp++ = 'w'; - *bp++ = box_chars_1[6]; - } - if (box_chars_1[7]) { /* ACS_RTEE */ - *bp++ = 'u'; - *bp++ = box_chars_1[7]; - } - if (box_chars_1[8]) { /* ACS_BTEE */ - *bp++ = 'v'; - *bp++ = box_chars_1[8]; - } - if (box_chars_1[9]) { /* ACS_LTEE */ - *bp++ = 't'; - *bp++ = box_chars_1[9]; - } - if (box_chars_1[10]) { /* ACS_PLUS */ - *bp++ = 'n'; - *bp++ = box_chars_1[10]; - } - - if (bp != buf2) { - *bp++ = '\0'; + char buf2[MAX_TERMCAP_LENGTH]; + string_desc result; + + _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 */ + + if (buf2[0]) { acs_chars = _nc_save_str(buf2); _nc_warning("acsc string synthesized from AIX capabilities"); box_chars_1 = ABSENT_STRING; @@ -963,8 +914,7 @@ postprocess_terminfo(TERMTYPE * tp) * up in _nc_info_table, which is organized so that the nte_index fields are * sorted, but the nte_type fields are not necessarily grouped together. */ -static -struct name_table_entry const * +static struct name_table_entry const * lookup_fullname(const char *find) { int state = -1; @@ -991,7 +941,7 @@ lookup_fullname(const char *find) if (!strcmp(names[count], find)) { struct name_table_entry const *entry_ptr = _nc_get_table(FALSE); while (entry_ptr->nte_type != state - || entry_ptr->nte_index != count) + || entry_ptr->nte_index != count) entry_ptr++; return entry_ptr; } diff --git a/contrib/ncurses/ncurses/tinfo/read_entry.c b/contrib/ncurses/ncurses/tinfo/read_entry.c index 85dc3e0bf6e9..deef49859a3e 100644 --- a/contrib/ncurses/ncurses/tinfo/read_entry.c +++ b/contrib/ncurses/ncurses/tinfo/read_entry.c @@ -41,7 +41,7 @@ #include <tic.h> #include <term_entry.h> -MODULE_ID("$Id: read_entry.c,v 1.67 2000/03/11 12:35:45 tom Exp $") +MODULE_ID("$Id: read_entry.c,v 1.69 2000/10/10 00:57:40 Todd.Miller Exp $") #if !HAVE_TELL #define tell(fd) 0 /* lseek() is POSIX, but not tell() - odd... */ @@ -79,7 +79,7 @@ _nc_tic_dir(const char *path) if (path != 0) { result = path; have_tic_directory = TRUE; - } else if (!have_tic_directory) { + } else if (!have_tic_directory && use_terminfo_vars()) { char *envp; if ((envp = getenv("TERMINFO")) != 0) return _nc_tic_dir(envp); @@ -176,9 +176,9 @@ read_termtype(int fd, TERMTYPE * ptr) str_size = LOW_MSB(buf + 10); TR(TRACE_DATABASE, - ("TERMTYPE name_size=%d, bool=%d/%d, num=%d/%d str=%d/%d(%d)", - name_size, bool_count, BOOLCOUNT, num_count, NUMCOUNT, - str_count, STRCOUNT, str_size)); + ("TERMTYPE name_size=%d, bool=%d/%d, num=%d/%d str=%d/%d(%d)", + name_size, bool_count, BOOLCOUNT, num_count, NUMCOUNT, + str_count, STRCOUNT, str_size)); if (name_size < 0 || bool_count < 0 || num_count < 0 @@ -281,19 +281,20 @@ read_termtype(int fd, TERMTYPE * ptr) ptr->Strings = typeRealloc(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)); + ext_bool_count, ext_num_count, ext_str_count, + ext_str_size, ext_str_limit)); TR(TRACE_DATABASE, ("READ %d extended-booleans @%d", - ext_bool_count, tell(fd))); + ext_bool_count, tell(fd))); if ((ptr->ext_Booleans = ext_bool_count) != 0) { if (read(fd, ptr->Booleans + BOOLCOUNT, (unsigned) - ext_bool_count) != ext_bool_count) + ext_bool_count) != ext_bool_count) return (0); } even_boundary(ext_bool_count); TR(TRACE_DATABASE, ("READ %d extended-numbers @%d", - ext_num_count, tell(fd))); + ext_num_count, tell(fd))); if ((ptr->ext_Numbers = ext_num_count) != 0) { if (!read_shorts(fd, buf, ext_num_count)) return (0); @@ -307,7 +308,7 @@ read_termtype(int fd, TERMTYPE * ptr) return (0); TR(TRACE_DATABASE, ("READ %d bytes of extended-strings @%d", - ext_str_limit, tell(fd))); + ext_str_limit, tell(fd))); if (ext_str_limit) { if ((ptr->ext_str_table = typeMalloc(char, ext_str_limit)) == 0) @@ -319,20 +320,20 @@ read_termtype(int fd, TERMTYPE * ptr) if ((ptr->ext_Strings = ext_str_count) != 0) { TR(TRACE_DATABASE, - ("Before computing extended-string capabilities str_count=%d, ext_str_count=%d", - str_count, ext_str_count)); + ("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); + ext_str_limit, ptr->ext_str_table); for (i = ext_str_count - 1; i >= 0; i--) { TR(TRACE_DATABASE, ("MOVE from [%d:%d] %s", - i, i + str_count, - _nc_visbuf(ptr->Strings[i + str_count]))); + 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])) base += (strlen(ptr->Strings[i + STRCOUNT]) + 1); TR(TRACE_DATABASE, ("... to [%d] %s", - i + STRCOUNT, - _nc_visbuf(ptr->Strings[i + STRCOUNT]))); + i + STRCOUNT, + _nc_visbuf(ptr->Strings[i + STRCOUNT]))); } } @@ -340,23 +341,23 @@ read_termtype(int fd, TERMTYPE * ptr) if ((ptr->ext_Names = typeCalloc(char *, need)) == 0) return (0); TR(TRACE_DATABASE, - ("ext_NAMES starting @%d in extended_strings, first = %s", - base, _nc_visbuf(ptr->ext_str_table + base))); + ("ext_NAMES starting @%d in extended_strings, first = %s", + base, _nc_visbuf(ptr->ext_str_table + base))); convert_strings(buf + (2 * ext_str_count), ptr->ext_Names, need, - ext_str_limit, ptr->ext_str_table + base); + ext_str_limit, ptr->ext_str_table + base); } T(("...done reading terminfo bool %d(%d) num %d(%d) str %d(%d)", - ptr->num_Booleans, ptr->ext_Booleans, - ptr->num_Numbers, ptr->ext_Numbers, - ptr->num_Strings, ptr->ext_Strings)); + ptr->num_Booleans, ptr->ext_Booleans, + ptr->num_Numbers, ptr->ext_Numbers, + ptr->num_Strings, ptr->ext_Strings)); TR(TRACE_DATABASE, ("extend: num_Booleans:%d", ptr->num_Booleans)); } else #endif /* NCURSES_XNAMES */ { T(("...done reading terminfo bool %d num %d str %d", - bool_count, num_count, str_count)); + bool_count, num_count, str_count)); #if NCURSES_XNAMES TR(TRACE_DATABASE, ("normal: num_Booleans:%d", ptr->num_Booleans)); #endif @@ -398,7 +399,7 @@ _nc_read_file_entry(const char *const filename, TERMTYPE * ptr) */ static int _nc_read_tic_entry(char *const filename, - const char *const dir, const char *ttn, TERMTYPE * const tp) + const char *const dir, const char *ttn, TERMTYPE * const tp) { /* maximum safe length of terminfo root directory name */ #define MAX_TPATH (PATH_MAX - MAX_ALIAS - 6) @@ -415,7 +416,7 @@ _nc_read_tic_entry(char *const filename, */ static int _nc_read_terminfo_dirs(const char *dirs, char *const filename, const char *const - ttn, TERMTYPE * const tp) + ttn, TERMTYPE * const tp) { char *list, *a; const char *b; @@ -471,19 +472,22 @@ _nc_read_entry(const char *const tn, char *const filename, TERMTYPE * const tp) && _nc_read_tic_entry(filename, _nc_tic_dir(0), ttn, tp) == 1) return 1; - if ((envp = getenv("TERMINFO")) != 0 - && _nc_read_tic_entry(filename, _nc_tic_dir(envp), ttn, tp) == 1) - return 1; + if (use_terminfo_vars()) { + if ((envp = getenv("TERMINFO")) != 0 + && _nc_read_tic_entry(filename, _nc_tic_dir(envp), ttn, tp) == 1) + return 1; - if ((envp = _nc_home_terminfo()) != 0) { - if (_nc_read_tic_entry(filename, envp, ttn, tp) == 1) { - return (1); + /* this is an ncurses extension */ + if ((envp = _nc_home_terminfo()) != 0) { + if (_nc_read_tic_entry(filename, envp, ttn, tp) == 1) { + return (1); + } } - } - /* this is an ncurses extension */ - if ((envp = getenv("TERMINFO_DIRS")) != 0) - return _nc_read_terminfo_dirs(envp, filename, ttn, tp); + /* this is an ncurses extension */ + if ((envp = getenv("TERMINFO_DIRS")) != 0) + return _nc_read_terminfo_dirs(envp, filename, ttn, tp); + } /* Try the system directory. Note that the TERMINFO_DIRS value, if * defined by the configure script, begins with a ":", which will be diff --git a/contrib/ncurses/ncurses/tinfo/read_termcap.c b/contrib/ncurses/ncurses/tinfo/read_termcap.c index 26e72d403263..f74c5a1eb760 100644 --- a/contrib/ncurses/ncurses/tinfo/read_termcap.c +++ b/contrib/ncurses/ncurses/tinfo/read_termcap.c @@ -55,9 +55,9 @@ #include <tic.h> #include <term_entry.h> -MODULE_ID("$Id: read_termcap.c,v 1.47 2000/04/15 16:53:19 Todd.C.Miller Exp $") +MODULE_ID("$Id: read_termcap.c,v 1.50 2000/10/10 00:56:46 Todd.Miller Exp $") -#ifndef PURE_TERMINFO +#if !PURE_TERMINFO #ifdef __EMX__ #define is_pathname(s) ((((s) != 0) && ((s)[0] == '/')) \ @@ -81,7 +81,8 @@ MODULE_ID("$Id: read_termcap.c,v 1.47 2000/04/15 16:53:19 Todd.C.Miller Exp $") #define _nc_cgetset cgetset #else static int _nc_cgetmatch(char *, const char *); -static int _nc_getent(char **, unsigned *, int *, int, char **, int, const char *, int, char *); +static int _nc_getent(char **, unsigned *, int *, int, char **, int, const char + *, int, char *); static int _nc_nfcmp(const char *, char *); /*- @@ -257,15 +258,15 @@ _nc_cgetent(char **buf, int *oline, char **db_array, const char *name) #define DOALLOC(size) typeRealloc(char, size, record) static int _nc_getent( - char **cap, /* termcap-content */ - unsigned *len, /* length, needed for recursion */ - int *beginning, /* line-number at match */ - int in_array, /* index in 'db_array[] */ - char **db_array, /* list of files to search */ - int fd, - const char *name, - int depth, - char *nfield) + char **cap, /* termcap-content */ + unsigned *len, /* length, needed for recursion */ + int *beginning, /* line-number at match */ + int in_array, /* index in 'db_array[] */ + char **db_array, /* list of files to search */ + int fd, + const char *name, + int depth, + char *nfield) { register char *r_end, *rp; int myfd = FALSE; @@ -318,7 +319,7 @@ _nc_getent( if (fd >= 0) { (void) lseek(fd, (off_t) 0, SEEK_SET); } else if ((_nc_access(db_array[current], R_OK) < 0) - || (fd = open(db_array[current], O_RDONLY, 0)) < 0) { + || (fd = open(db_array[current], O_RDONLY, 0)) < 0) { /* No error on unfound file. */ if (errno == ENOENT) continue; @@ -481,7 +482,7 @@ _nc_getent( tcend = s; iret = _nc_getent(&icap, &ilen, &oline, current, db_array, fd, - tc, depth + 1, 0); + tc, depth + 1, 0); newicap = icap; /* Put into a register. */ newilen = ilen; if (iret != TC_SUCCESS) { @@ -777,12 +778,13 @@ _nc_tgetent(char *bp, char **sourcename, int *lineno, const char *name) char *pathvec[PVECSIZ]; /* to point to names in pathbuf */ char **pvec; /* holds usable tail of path vector */ char *termpath; + string_desc desc; fname = pathvec; pvec = pathvec; tbuf = bp; p = pathbuf; - cp = getenv("TERMCAP"); + cp = use_terminfo_vars() ? getenv("TERMCAP") : NULL; /* * TERMCAP can have one of two things in it. It can be the name of a file @@ -793,22 +795,29 @@ _nc_tgetent(char *bp, char **sourcename, int *lineno, const char *name) * instead. The path is found in the TERMPATH variable, or becomes * "$HOME/.termcap /etc/termcap" if no TERMPATH exists. */ - if (!is_pathname(cp)) { /* no TERMCAP or it holds an entry */ + _nc_str_init(&desc, pathbuf, sizeof(pathbuf)); + if (cp == NULL) { + _nc_safe_strcpy(&desc, "/etc/termcap /usr/share/misc/termcap"); + } else if (!is_pathname(cp)) { /* TERMCAP holds an entry */ if ((termpath = getenv("TERMPATH")) != 0) { - strncpy(pathbuf, termpath, PBUFSIZ - 1); + _nc_safe_strcat(&desc, termpath); } else { - if ((home = getenv("HOME")) != 0 && - strlen(home) < PBUFSIZ) { /* setup path */ - p += strlen(home); /* path, looking in */ - strcpy(pathbuf, home); /* $HOME first */ - *p++ = '/'; - } /* if no $HOME look in current directory */ -#define MY_PATH_DEF ".termcap /etc/termcap /usr/share/misc/termcap" - strncpy(p, MY_PATH_DEF, (size_t) (PBUFSIZ - (p - pathbuf) - 1)); + char temp[PBUFSIZ]; + temp[0] = 0; + if ((home = getenv("HOME")) != 0 && *home != '\0' + && strchr(home, ' ') == 0 + && strlen(home) < sizeof(temp) - 10) { /* setup path */ + sprintf(temp, "%s/", home); /* $HOME first */ + } + /* if no $HOME look in current directory */ + strcat(temp, ".termcap"); + _nc_safe_strcat(&desc, temp); + _nc_safe_strcat(&desc, " /etc/termcap"); + _nc_safe_strcat(&desc, " /usr/share/misc/termcap"); } - } else /* user-defined name in TERMCAP */ - strncpy(pathbuf, cp, PBUFSIZ - 1); /* still can be tokenized */ - pathbuf[PBUFSIZ - 1] = '\0'; + } else { /* user-defined name in TERMCAP */ + _nc_safe_strcat(&desc, cp); /* still can be tokenized */ + } *fname++ = pathbuf; /* tokenize path into vector of names */ while (*++p) { @@ -921,7 +930,7 @@ _nc_read_termcap_entry(const char *const tn, TERMTYPE * const tp) static char *source; static int lineno; - if ((p = getenv("TERMCAP")) != 0 + if (use_terminfo_vars() && (p = getenv("TERMCAP")) != 0 && !is_pathname(p) && _nc_name_match(p, tn, "|:")) { /* TERMCAP holds a termcap entry */ strncpy(tc, p, sizeof(tc) - 1); @@ -971,7 +980,7 @@ _nc_read_termcap_entry(const char *const tn, TERMTYPE * const tp) char pathbuf[PATH_MAX]; termpaths[filecount] = 0; - if ((tc = getenv("TERMCAP")) != 0) { + if (use_terminfo_vars() && (tc = getenv("TERMCAP")) != 0) { if (is_pathname(tc)) { /* interpret as a filename */ ADD_TC(tc, 0); } else if (_nc_name_match(tc, tn, "|:")) { /* treat as a capability file */ @@ -1004,7 +1013,7 @@ _nc_read_termcap_entry(const char *const tn, TERMTYPE * const tp) #define PRIVATE_CAP "%s/.termcap" - if ((h = getenv("HOME")) != NULL + if ((h = getenv("HOME")) != NULL && *h != '\0' && (strlen(h) + sizeof(PRIVATE_CAP)) < PATH_MAX) { /* user's .termcap, if any, should override it */ (void) strcpy(envhome, h); diff --git a/contrib/ncurses/ncurses/tinfo/strings.c b/contrib/ncurses/ncurses/tinfo/strings.c new file mode 100644 index 000000000000..8198ec4050ad --- /dev/null +++ b/contrib/ncurses/ncurses/tinfo/strings.c @@ -0,0 +1,139 @@ +/**************************************************************************** + * Copyright (c) 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 * + * "Software"), to deal in the Software without restriction, including * + * without limitation the rights to use, copy, modify, merge, publish, * + * distribute, distribute with modifications, sublicense, and/or sell * + * copies of the Software, and to permit persons to whom the Software is * + * furnished to do so, subject to the following conditions: * + * * + * The above copyright notice and this permission notice shall be included * + * in all copies or substantial portions of the Software. * + * * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * + * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * + * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * + * * + * Except as contained in this notice, the name(s) of the above copyright * + * holders shall not be used in advertising or otherwise to promote the * + * sale, use or other dealings in this Software without prior written * + * authorization. * + ****************************************************************************/ + +/**************************************************************************** + * Author: Thomas E. Dickey * + ****************************************************************************/ + +/* +** lib_mvcur.c +**/ + +#include <curses.priv.h> + +MODULE_ID("$Id") + +/**************************************************************************** + * Useful string functions (especially for mvcur) + ****************************************************************************/ + +#if !HAVE_STRSTR +char * +_nc_strstr(const char *haystack, const char *needle) +{ + size_t len1 = strlen(haystack); + size_t len2 = strlen(needle); + char *result = 0; + + while ((len1 != 0) && (len1-- >= len2)) { + if (!strncmp(haystack, needle, len2)) { + result = haystack; + break; + } + haystack++; + } + return result; +} +#endif + +/* + * Initialize the descriptor so we can append to it. + */ +string_desc * +_nc_str_init(string_desc * dst, char *src, size_t len) +{ + if (dst != 0) { + dst->s_head = src; + dst->s_tail = src; + dst->s_size = len - 1; + if (src != 0) + *src = 0; + } + return dst; +} + +/* + * Initialize the descriptor for only tracking the amount of memory used. + */ +string_desc * +_nc_str_null(string_desc * dst, size_t len) +{ + return _nc_str_init(dst, 0, len); +} + +/* + * Copy a descriptor + */ +string_desc * +_nc_str_copy(string_desc * dst, string_desc * src) +{ + *dst = *src; + return dst; +} + +/* + * Replaces strcat into a fixed buffer, returning false on failure. + */ +bool +_nc_safe_strcat(string_desc * dst, const char *src) +{ + if (src != 0) { + size_t len = strlen(src); + + if (len < dst->s_size) { + if (dst->s_tail != 0) { + strcpy(dst->s_tail, src); + dst->s_tail += len; + } + dst->s_size -= len; + return TRUE; + } + } + return FALSE; +} + +/* + * Replaces strcpy into a fixed buffer, returning false on failure. + */ +bool +_nc_safe_strcpy(string_desc * dst, const char *src) +{ + if (src != 0) { + size_t len = strlen(src); + + if (len < dst->s_size) { + if (dst->s_head != 0) { + strcpy(dst->s_head, src); + dst->s_tail = dst->s_head + len; + } + dst->s_size -= len; + return TRUE; + } + } + return FALSE; +} diff --git a/contrib/ncurses/ncurses/tinfo/write_entry.c b/contrib/ncurses/ncurses/tinfo/write_entry.c index 12aedd6e565c..af4b4fda2a3a 100644 --- a/contrib/ncurses/ncurses/tinfo/write_entry.c +++ b/contrib/ncurses/ncurses/tinfo/write_entry.c @@ -52,7 +52,7 @@ #define TRACE_OUT(p) /*nothing */ #endif -MODULE_ID("$Id: write_entry.c,v 1.52 2000/03/11 12:23:42 tom Exp $") +MODULE_ID("$Id: write_entry.c,v 1.53 2000/10/04 02:32:14 tom Exp $") static int total_written; @@ -116,10 +116,12 @@ _nc_set_writedir(char *dir) const char *destination; char actual[PATH_MAX]; + if (dir == 0 + && use_terminfo_vars()) + dir = getenv("TERMINFO"); + if (dir != 0) (void) _nc_tic_dir(dir); - else if (getenv("TERMINFO") != NULL) - (void) _nc_tic_dir(getenv("TERMINFO")); destination = _nc_tic_dir(0); if (make_directory(destination) < 0) { |