_nc_setenv_num(const char *name, int value)
{
if (name != 0 && value >= 0) {
char buffer[128];
#if HAVE_SETENV
_nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer)) "%d", value);
setenv(name, buffer, 1);
#elif HAVE_PUTENV
char *s;
_nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer)) "%s=%d", name, value);
if ((s = strdup(buffer)) != 0)
putenv(s);
#endif
}
}
static int
make_db_path(char *dst, const char *src, size_t limit)
{
int rc = -1;
const char *top = _nc_tic_dir(0);
if (src == top || _nc_is_abs_path(src)) {
if (strlen(src) + 1 <= limit) {
_nc_STRCPY(dst, src, limit);
rc = 0;
}
} else {
if (strlen(top) + strlen(src) + 2 <= limit) {
_nc_SPRINTF(dst, _nc_SLIMIT(limit) "%s/%s", top, src);
rc = 0;
}
}
#if USE_HASHED_DB
if (rc == 0) {
static const char suffix[] = DBM_SUFFIX;
size_t have = strlen(dst);
size_t need = strlen(suffix);
if (have > need && strcmp(dst + (int) (have - need), suffix)) {
if (have + need <= limit) {
_nc_STRCAT(dst, suffix, limit);
} else {
rc = -1;
}
} else if (_nc_is_dir_path(dst)) {
rc = -1;
}
}
#endif
return rc;
}
/*
* Check for an expression that corresponds to "%B" (BCD):
* (parameter / 10) * 16 + (parameter % 10)
*/
static int
bcd_expression(const char *str)
{
/* leave this non-const for HPUX */
static char fmt[] = "%%p%c%%{10}%%/%%{16}%%*%%p%c%%{10}%%m%%+";
int len = 0;
char ch1, ch2;
if (sscanf(str, fmt, &ch1, &ch2) == 2
&& isdigit(UChar(ch1))
&& isdigit(UChar(ch2))
&& (ch1 == ch2)) {
len = 28;
#ifndef NDEBUG
{
char buffer[80];
int tst;
_nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer)) fmt, ch1, ch2);
tst = strlen(buffer) - 1;
assert(len == tst);
}
#endif
}
return len;
}
/*
* Convert a character to visible form.
*/
static char *
visichar(int ch)
{
static char temp[10];
ch = UChar(ch);
assert(ch >= 0 && ch < 256);
if (ch == '\\') {
_nc_STRCPY(temp, "\\\\", sizeof(temp));
} else if (ch == '\033') {
_nc_STRCPY(temp, "\\E", sizeof(temp));
} else if (ch < ' ') {
_nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp)) "\\%03o", ch);
} else if (ch >= 127) {
_nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp)) "\\%03o", ch);
} else {
_nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp)) "%c", ch);
}
return temp;
}
static char *
save_tc_char(char *bufptr, int c1)
{
if (is7bits(c1) && isprint(c1)) {
if (c1 == ':' || c1 == '\\')
bufptr = save_char(bufptr, '\\');
bufptr = save_char(bufptr, c1);
} else {
char temp[80];
if (c1 == (c1 & 0x1f)) { /* iscntrl() returns T on 255 */
_nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
"%.20s", unctrl((chtype) c1));
} else {
_nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
"\\%03o", c1);
}
bufptr = save_string(bufptr, temp);
}
return bufptr;
}
static void
dump_string(char *val, char *buf)
/* display the value of a string capability */
{
if (val == ABSENT_STRING)
_nc_STRCPY(buf, s_absent, MAX_STRING);
else if (val == CANCELLED_STRING)
_nc_STRCPY(buf, s_cancel, MAX_STRING);
else {
_nc_SPRINTF(buf, _nc_SLIMIT(MAX_STRING)
"'%.*s'", MAX_STRING - 3, TIC_EXPAND(val));
}
}
static void
dump_numeric(int val, char *buf)
/* display the value of a boolean capability */
{
switch (val) {
case ABSENT_NUMERIC:
_nc_STRCPY(buf, s_absent, MAX_STRING);
break;
case CANCELLED_NUMERIC:
_nc_STRCPY(buf, s_cancel, MAX_STRING);
break;
default:
_nc_SPRINTF(buf, _nc_SLIMIT(MAX_STRING) "%d", val);
break;
}
}
static char *
color_of(int c)
{
if (c != my_cached) {
my_cached = c;
my_select = !my_select;
if (isDefaultColor(c))
_nc_STRCPY(my_buffer[my_select], "default",
COLOR_BUF_SIZE(my_select));
else
_nc_SPRINTF(my_buffer[my_select],
_nc_SLIMIT(COLOR_BUF_SIZE(my_select))
"color%d", c);
}
return my_buffer[my_select];
}
static const char *
_nc_viswbuf2n(int bufnum, const wchar_t *buf, int len)
{
const char *vbuf;
char *tp;
int count;
if (buf == 0)
return ("(null)");
if (len < 0)
len = (int) wcslen(buf);
count = len;
#ifdef TRACE
vbuf = tp = _nc_trace_buf(bufnum, WideLen(len));
#else
{
static char *mybuf[NUM_VISBUFS];
mybuf[bufnum] = typeRealloc(char, WideLen(len), mybuf[bufnum]);
vbuf = tp = mybuf[bufnum];
}
#endif
if (tp != 0) {
wchar_t c;
*tp++ = D_QUOTE;
while ((--count >= 0) && (c = *buf++) != '\0') {
char temp[CCHARW_MAX + 80];
int j = wctomb(temp, c), k;
if (j <= 0) {
_nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
"\\u%08X", (unsigned) c);
j = (int) strlen(temp);
}
for (k = 0; k < j; ++k) {
tp = VisChar(tp, UChar(temp[k]), WideLen(len));
}
}
*tp++ = D_QUOTE;
*tp = '\0';
} else {
vbuf = ("(_nc_viswbuf2n failed)");
}
return (vbuf);
}
_nc_home_terminfo(void)
{
char *result = 0;
#if USE_HOME_TERMINFO
char *home;
if (use_terminfo_vars()) {
if (MyBuffer == 0) {
if ((home = getenv("HOME")) != 0) {
size_t want = (strlen(home) + sizeof(PRIVATE_INFO));
MyBuffer = typeMalloc(char, want);
if (MyBuffer == 0)
_nc_err_abort(MSG_NO_MEMORY);
_nc_SPRINTF(MyBuffer, _nc_SLIMIT(want) PRIVATE_INFO, home);
}
}
result = MyBuffer;
}
_nc_home_terminfo(void)
{
char *result = 0;
#if USE_HOME_TERMINFO
char *home;
if (use_terminfo_vars()) {
if (MyBuffer == 0) {
if ((home = getenv("HOME")) != 0) {
size_t want = (strlen(home) + sizeof(PRIVATE_INFO));
TYPE_MALLOC(char, want, MyBuffer);
_nc_SPRINTF(MyBuffer, _nc_SLIMIT(want) PRIVATE_INFO, home);
}
}
result = MyBuffer;
}
#endif
return result;
}
static bool
check_existence(const char *name, struct stat *sb)
{
bool result = FALSE;
if (stat(name, sb) == 0
&& (S_ISDIR(sb->st_mode) || S_ISREG(sb->st_mode))) {
result = TRUE;
}
#if USE_HASHED_DB
else if (strlen(name) < PATH_MAX - sizeof(DBM_SUFFIX)) {
char temp[PATH_MAX];
_nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp)) "%s%s", name, DBM_SUFFIX);
if (stat(temp, sb) == 0 && S_ISREG(sb->st_mode)) {
result = TRUE;
}
}
#endif
return result;
}
static char *
_nc_vischar(char *tp, unsigned c LIMIT_ARG)
{
if (c == '"' || c == '\\') {
*tp++ = '\\';
*tp++ = (char) c;
} else if (is7bits((int) c) && (isgraph((int) c) || c == ' ')) {
*tp++ = (char) c;
} else if (c == '\n') {
*tp++ = '\\';
*tp++ = 'n';
} else if (c == '\r') {
*tp++ = '\\';
*tp++ = 'r';
} else if (c == '\b') {
*tp++ = '\\';
*tp++ = 'b';
} else if (c == '\t') {
*tp++ = '\\';
*tp++ = 't';
} else if (c == '\033') {
*tp++ = '\\';
*tp++ = 'e';
} else if (UChar(c) == 0x7f) {
*tp++ = '\\';
*tp++ = '^';
*tp++ = '?';
} else if (is7bits(c) && iscntrl(UChar(c))) {
*tp++ = '\\';
*tp++ = '^';
*tp++ = (char) ('@' + c);
} else {
_nc_SPRINTF(tp, _nc_SLIMIT(limit)
"\\%03lo", (unsigned long) ChCharOf(c));
tp += strlen(tp);
}
*tp = 0;
return tp;
}
/*
* Check for access rights to destination directories
* Create any directories which don't exist.
*
* Note: there's no reason to return the result of make_db_root(), since
* this function is called only in instances where that has to succeed.
*/
static void
check_writeable(int code)
{
static const char dirnames[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
static bool verified[sizeof(dirnames)];
char dir[sizeof(LEAF_FMT)];
char *s = 0;
if (code == 0 || (s = (strchr) (dirnames, code)) == 0)
_nc_err_abort("Illegal terminfo subdirectory \"" LEAF_FMT "\"", code);
if (verified[s - dirnames])
return;
_nc_SPRINTF(dir, _nc_SLIMIT(sizeof(dir)) LEAF_FMT, code);
if (make_db_root(dir) < 0) {
_nc_err_abort("%s/%s: permission denied", _nc_tic_dir(0), dir);
}
verified[s - dirnames] = TRUE;
}
int
main(int argc, char **argv)
{
struct name_table_entry *name_table = typeCalloc(struct
name_table_entry, CAPTABSIZE);
HashValue *hash_table = typeCalloc(HashValue, HASHTABSIZE);
const char *root_name = "";
int column = 0;
int bigstring = 0;
int n;
char buffer[BUFSIZ];
static const char *typenames[] =
{"BOOLEAN", "NUMBER", "STRING"};
short BoolCount = 0;
short NumCount = 0;
short StrCount = 0;
/* The first argument is the column-number (starting with 0).
* The second is the root name of the tables to generate.
*/
if (argc <= 3
|| (column = atoi(argv[1])) <= 0
|| (column >= MAX_COLUMNS)
|| *(root_name = argv[2]) == 0
|| (bigstring = atoi(argv[3])) < 0
|| name_table == 0
|| hash_table == 0) {
fprintf(stderr, "usage: make_hash column root_name bigstring\n");
exit(EXIT_FAILURE);
}
/*
* Read the table into our arrays.
*/
for (n = 0; (n < CAPTABSIZE) && fgets(buffer, BUFSIZ, stdin);) {
char **list, *nlp = strchr(buffer, '\n');
if (nlp)
*nlp = '\0';
list = parse_columns(buffer);
if (list == 0) /* blank or comment */
continue;
if (column > count_columns(list)) {
fprintf(stderr, "expected %d columns, have %d:\n%s\n",
column,
count_columns(list),
buffer);
exit(EXIT_FAILURE);
}
name_table[n].nte_link = -1; /* end-of-hash */
name_table[n].nte_name = strmalloc(list[column]);
if (!strcmp(list[2], "bool")) {
name_table[n].nte_type = BOOLEAN;
name_table[n].nte_index = BoolCount++;
} else if (!strcmp(list[2], "num")) {
name_table[n].nte_type = NUMBER;
name_table[n].nte_index = NumCount++;
} else if (!strcmp(list[2], "str")) {
name_table[n].nte_type = STRING;
name_table[n].nte_index = StrCount++;
} else {
fprintf(stderr, "Unknown type: %s\n", list[2]);
exit(EXIT_FAILURE);
}
n++;
}
_nc_make_hash_table(name_table, hash_table);
/*
* Write the compiled tables to standard output
*/
if (bigstring) {
int len = 0;
int nxt;
printf("static const char %s_names_text[] = \\\n", root_name);
for (n = 0; n < CAPTABSIZE; n++) {
nxt = (int) strlen(name_table[n].nte_name) + 5;
if (nxt + len > 72) {
printf("\\\n");
len = 0;
}
printf("\"%s\\0\" ", name_table[n].nte_name);
len += nxt;
}
printf(";\n\n");
len = 0;
printf("static name_table_data const %s_names_data[] =\n",
root_name);
printf("{\n");
for (n = 0; n < CAPTABSIZE; n++) {
printf("\t{ %15d,\t%10s,\t%3d, %3d }%c\n",
len,
typenames[name_table[n].nte_type],
name_table[n].nte_index,
name_table[n].nte_link,
n < CAPTABSIZE - 1 ? ',' : ' ');
len += (int) strlen(name_table[n].nte_name) + 1;
}
printf("};\n\n");
printf("static struct name_table_entry *_nc_%s_table = 0;\n\n", root_name);
} else {
printf("static struct name_table_entry const _nc_%s_table[] =\n",
root_name);
printf("{\n");
for (n = 0; n < CAPTABSIZE; n++) {
_nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer)) "\"%s\"",
name_table[n].nte_name);
printf("\t{ %15s,\t%10s,\t%3d, %3d }%c\n",
buffer,
typenames[name_table[n].nte_type],
name_table[n].nte_index,
name_table[n].nte_link,
n < CAPTABSIZE - 1 ? ',' : ' ');
}
printf("};\n\n");
}
printf("static const HashValue _nc_%s_hash_table[%d] =\n",
root_name,
HASHTABSIZE + 1);
printf("{\n");
for (n = 0; n < HASHTABSIZE; n++) {
printf("\t%3d,\n", hash_table[n]);
}
printf("\t0\t/* base-of-table */\n");
printf("};\n\n");
printf("#if (BOOLCOUNT!=%d)||(NUMCOUNT!=%d)||(STRCOUNT!=%d)\n",
BoolCount, NumCount, StrCount);
printf("#error\t--> term.h and comp_captab.c disagree about the <--\n");
printf("#error\t--> numbers of booleans, numbers and/or strings <--\n");
printf("#endif\n\n");
free(hash_table);
return EXIT_SUCCESS;
}
_nc_varargs(const char *fmt, va_list ap)
{
static char dummy[] = "";
char buffer[BUFSIZ];
const char *param;
int n;
if (fmt == 0 || *fmt == '\0')
return dummy;
if (MyLength == 0)
MyBuffer = typeMalloc(char, MyLength = BUFSIZ);
if (MyBuffer == 0)
return dummy;
*MyBuffer = '\0';
while (*fmt != '\0') {
if (*fmt == '%') {
char *pval = 0; /* avoid const-cast */
const char *sval = "";
double fval = 0.0;
int done = FALSE;
int ival = 0;
int type = 0;
ARGTYPE parm[MAX_PARMS];
int parms = 0;
ARGTYPE used = atUnknown;
while (*++fmt != '\0' && !done) {
if (*fmt == '*') {
VA_INT(int);
if (parms < MAX_PARMS)
parm[parms++] = atInteger;
} else if (isalpha(UChar(*fmt))) {
done = TRUE;
switch (*fmt) {
case 'Z': /* FALLTHRU */
case 'h': /* FALLTHRU */
case 'l': /* FALLTHRU */
done = FALSE;
type = *fmt;
break;
case 'i': /* FALLTHRU */
case 'd': /* FALLTHRU */
case 'u': /* FALLTHRU */
case 'x': /* FALLTHRU */
case 'X': /* FALLTHRU */
if (type == 'l')
VA_INT(long);
else if (type == 'Z')
VA_INT(size_t);
else
VA_INT(int);
used = atInteger;
break;
case 'f': /* FALLTHRU */
case 'e': /* FALLTHRU */
case 'E': /* FALLTHRU */
case 'g': /* FALLTHRU */
case 'G': /* FALLTHRU */
VA_FLT(double);
used = atFloat;
break;
case 'c':
VA_INT(int);
used = atInteger;
break;
case 's':
VA_STR(const char *);
used = atString;
break;
case 'p':
VA_PTR(void *);
used = atPoint;
break;
case 'n':
VA_PTR(int *);
used = atPoint;
break;
default:
break;
}
} else if (*fmt == '%') {
done = TRUE;
}
if (used != atUnknown && parms < MAX_PARMS) {
parm[parms++] = used;
for (n = 0; n < parms; ++n) {
used = parm[n];
param = buffer;
switch (used) {
case atInteger:
_nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer))
"%d", ival);
break;
case atFloat:
_nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer))
"%f", fval);
break;
case atPoint:
_nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer))
"%p", pval);
break;
case atString:
param = _nc_visbuf2(1, sval);
break;
case atUnknown:
default:
_nc_STRCPY(buffer, "?", sizeof(buffer));
break;
}
MyLength += strlen(param) + 2;
MyBuffer = typeRealloc(char, MyLength, MyBuffer);
_nc_SPRINTF(MyBuffer + strlen(MyBuffer),
_nc_SLIMIT(MyLength - strlen(MyBuffer))
", %s", param);
}
}
used = atUnknown;
}
} else {
safe_keyname (SCREEN *sp, int c)
{
int i;
char name[20];
char *p;
NCURSES_CONST char *result = 0;
if (c == -1) {
result = "-1";
} else {
for (i = 0; _nc_key_names[i].offset != -1; i++) {
if (_nc_key_names[i].code == c) {
result = (NCURSES_CONST char *)key_names + _nc_key_names[i].offset;
break;
}
}
if (result == 0 && (c >= 0 && c < SIZEOF_TABLE)) {
if (MyTable == 0)
MyTable = typeCalloc(char *, SIZEOF_TABLE);
if (MyTable != 0) {
int m_prefix = (sp == 0 || sp->_use_meta);
/* if sense of meta() changed, discard cached data */
if (MyInit != (m_prefix + 1)) {
MyInit = m_prefix + 1;
for (i = 0; i < SIZEOF_TABLE; ++i) {
if (MyTable[i]) {
FreeAndNull(MyTable[i]);
}
}
}
/* create and cache result as needed */
if (MyTable[c] == 0) {
int cc = c;
p = name;
#define P_LIMIT (sizeof(name) - (size_t) (p - name))
if (cc >= 128 && m_prefix) {
_nc_STRCPY(p, "M-", P_LIMIT);
p += 2;
cc -= 128;
}
if (cc < 32)
_nc_SPRINTF(p, _nc_SLIMIT(P_LIMIT) "^%c", cc + '@');
else if (cc == 127)
_nc_STRCPY(p, "^?", P_LIMIT);
else
_nc_SPRINTF(p, _nc_SLIMIT(P_LIMIT) "%c", cc);
MyTable[c] = strdup(name);
}
result = MyTable[c];
}
#if NCURSES_EXT_FUNCS && NCURSES_XNAMES
} else if (result == 0 && HasTerminal(sp)) {
int j, k;
char * bound;
TERMTYPE *tp = &(TerminalOf(sp)->type);
unsigned save_trace = _nc_tracing;
_nc_tracing = 0; /* prevent recursion via keybound() */
for (j = 0; (bound = NCURSES_SP_NAME(keybound)(NCURSES_SP_ARGx c, j)) != 0; ++j) {
for(k = STRCOUNT; k < (int) NUM_STRINGS(tp); k++) {
if (tp->Strings[k] != 0 && !strcmp(bound, tp->Strings[k])) {
result = ExtStrname(tp, k, strnames);
break;
}
}
free(bound);
if (result != 0)
break;
}
_nc_tracing = save_trace;
#endif
}
}
mouse_server(unsigned long param)
#endif
{
SCREEN *sp = (SCREEN *) param;
unsigned short fWait = MOU_WAIT;
/* NOPTRRECT mourt = { 0,0,24,79 }; */
MOUEVENTINFO mouev;
HMOU hmou;
unsigned short mask = MOUSE_BN1_DOWN | MOUSE_BN2_DOWN | MOUSE_BN3_DOWN;
int nbuttons = 3;
int oldstate = 0;
char err[80];
unsigned long rc;
/* open the handle for the mouse */
if (MouOpen(NULL, &hmou) == 0) {
rc = MouSetEventMask(&mask, hmou);
if (rc) { /* retry with 2 buttons */
mask = MOUSE_BN1_DOWN | MOUSE_BN2_DOWN;
rc = MouSetEventMask(&mask, hmou);
nbuttons = 2;
}
if (rc == 0 && MouDrawPtr(hmou) == 0) {
for (;;) {
/* sit and wait on the event queue */
rc = MouReadEventQue(&mouev, &fWait, hmou);
if (rc) {
_nc_SPRINTF(err, _nc_SLIMIT(sizeof(err))
"Error reading mouse queue, rc=%lu.\r\n", rc);
break;
}
if (!sp->_emxmouse_activated)
goto finish;
/*
* OS/2 numbers a 3-button mouse inconsistently from other
* platforms:
* 1 = left
* 2 = right
* 3 = middle.
*/
if ((mouev.fs ^ oldstate) & MOUSE_BN1_DOWN)
write_event(sp, mouev.fs & MOUSE_BN1_DOWN,
sp->_emxmouse_buttons[1], mouev.col, mouev.row);
if ((mouev.fs ^ oldstate) & MOUSE_BN2_DOWN)
write_event(sp, mouev.fs & MOUSE_BN2_DOWN,
sp->_emxmouse_buttons[3], mouev.col, mouev.row);
if ((mouev.fs ^ oldstate) & MOUSE_BN3_DOWN)
write_event(sp, mouev.fs & MOUSE_BN3_DOWN,
sp->_emxmouse_buttons[2], mouev.col, mouev.row);
finish:
oldstate = mouev.fs;
}
} else {
_nc_SPRINTF(err, _nc_SLIMIT(sizeof(err))
"Error setting event mask, buttons=%d, rc=%lu.\r\n",
nbuttons, rc);
}
DosWrite(2, err, strlen(err), &rc);
MouClose(hmou);
}
DosExit(EXIT_THREAD, 0L);
}
_traceattr2(int bufnum, chtype newmode)
{
#define DATA(name) { name, { #name } }
static const struct {
unsigned int val;
const char name[14];
} names[] =
{
DATA(A_STANDOUT),
DATA(A_UNDERLINE),
DATA(A_REVERSE),
DATA(A_BLINK),
DATA(A_DIM),
DATA(A_BOLD),
DATA(A_ALTCHARSET),
DATA(A_INVIS),
DATA(A_PROTECT),
DATA(A_CHARTEXT),
DATA(A_NORMAL),
DATA(A_COLOR),
#if USE_ITALIC
DATA(A_ITALIC),
#endif
}
#ifndef USE_TERMLIB
,
colors[] =
{
DATA(COLOR_BLACK),
DATA(COLOR_RED),
DATA(COLOR_GREEN),
DATA(COLOR_YELLOW),
DATA(COLOR_BLUE),
DATA(COLOR_MAGENTA),
DATA(COLOR_CYAN),
DATA(COLOR_WHITE),
}
#endif /* !USE_TERMLIB */
;
#undef DATA
char *result = _nc_trace_buf(bufnum, (size_t) BUFSIZ);
if (result != 0) {
size_t n;
unsigned save_nc_tracing = _nc_tracing;
_nc_tracing = 0;
_nc_STRCPY(result, l_brace, TRACE_BUF_SIZE(bufnum));
for (n = 0; n < SIZEOF(names); n++) {
if ((newmode & names[n].val) != 0) {
if (result[1] != '\0')
(void) _nc_trace_bufcat(bufnum, "|");
result = _nc_trace_bufcat(bufnum, names[n].name);
if (names[n].val == A_COLOR) {
char temp[80];
short pairnum = (short) PairNumber(newmode);
#ifdef USE_TERMLIB
/* pair_content lives in libncurses */
_nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
"{%d}", pairnum);
#else
NCURSES_COLOR_T fg, bg;
if (pair_content(pairnum, &fg, &bg) == OK) {
_nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
"{%d = {%s, %s}}",
pairnum,
COLOR_OF(fg),
COLOR_OF(bg));
} else {
_nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
"{%d}", pairnum);
}
#endif
result = _nc_trace_bufcat(bufnum, temp);
}
}
}
if (ChAttrOf(newmode) == A_NORMAL) {
if (result != 0 && result[1] != '\0')
(void) _nc_trace_bufcat(bufnum, "|");
(void) _nc_trace_bufcat(bufnum, "A_NORMAL");
}
_nc_tracing = save_nc_tracing;
result = _nc_trace_bufcat(bufnum, r_brace);
}
return result;
}
/*---------------------------------------------------------------------------
| Facility : libnform
| Function : static bool Check_This_Field(FIELD * field,
| const void * argp)
|
| Description : Validate buffer content to be a valid numeric value
|
| Return Values : TRUE - field is valid
| FALSE - field is invalid
+--------------------------------------------------------------------------*/
static bool
Check_This_Field(FIELD *field, const void *argp)
{
const thisARG *argn = (const thisARG *)argp;
double low = argn->low;
double high = argn->high;
int prec = argn->precision;
unsigned char *bp = (unsigned char *)field_buffer(field, 0);
char *s = (char *)bp;
double val = 0.0;
struct lconv *L = argn->L;
char buf[64];
bool result = FALSE;
while (*bp && *bp == ' ')
bp++;
if (*bp)
{
if (*bp == '-' || *bp == '+')
bp++;
#if USE_WIDEC_SUPPORT
if (*bp)
{
bool blank = FALSE;
int state = 0;
int len;
int n;
wchar_t *list = _nc_Widen_String((char *)bp, &len);
if (list != 0)
{
result = TRUE;
for (n = 0; n < len; ++n)
{
if (blank)
{
if (list[n] != ' ')
{
result = FALSE;
break;
}
}
else if (list[n] == ' ')
{
blank = TRUE;
}
else if (isDecimalPoint(list[n]))
{
if (++state > 1)
{
result = FALSE;
break;
}
}
else if (!isDigit(list[n]))
{
result = FALSE;
break;
}
}
free(list);
}
}
#else
while (*bp)
{
if (!isdigit(UChar(*bp)))
break;
bp++;
}
if (isDecimalPoint(*bp))
{
bp++;
while (*bp)
{
if (!isdigit(UChar(*bp)))
break;
bp++;
}
}
while (*bp && *bp == ' ')
bp++;
result = (*bp == '\0');
#endif
if (result)
{
val = atof(s);
if (low < high)
{
if (val < low || val > high)
result = FALSE;
}
if (result)
{
_nc_SPRINTF(buf, _nc_SLIMIT(sizeof(buf))
"%.*f", (prec > 0 ? prec : 0), val);
set_field_buffer(field, 0, buf);
}
}
}
return (result);
}
_nc_write_entry(TERMTYPE *const tp)
{
#if USE_HASHED_DB
char buffer[MAX_ENTRY_SIZE + 1];
unsigned limit = sizeof(buffer);
unsigned offset = 0;
#else /* !USE_HASHED_DB */
struct stat statbuf;
char filename[PATH_MAX];
char linkname[PATH_MAX];
#if USE_SYMLINKS
char symlinkname[PATH_MAX];
#if !HAVE_LINK
#undef HAVE_LINK
#define HAVE_LINK 1
#endif
#endif /* USE_SYMLINKS */
static int call_count;
static time_t start_time; /* time at start of writes */
#endif /* USE_HASHED_DB */
char name_list[MAX_TERMINFO_LENGTH];
char *first_name, *other_names;
char *ptr;
char *term_names = tp->term_names;
size_t name_size = strlen(term_names);
if (name_size == 0) {
_nc_syserr_abort("no terminal name found.");
} else if (name_size >= sizeof(name_list) - 1) {
_nc_syserr_abort("terminal name too long: %s", term_names);
}
_nc_STRCPY(name_list, term_names, sizeof(name_list));
DEBUG(7, ("Name list = '%s'", name_list));
first_name = name_list;
ptr = &name_list[name_size - 1];
other_names = ptr + 1;
while (ptr > name_list && *ptr != '|')
ptr--;
if (ptr != name_list) {
*ptr = '\0';
for (ptr = name_list; *ptr != '\0' && *ptr != '|'; ptr++)
continue;
if (*ptr == '\0')
other_names = ptr;
else {
*ptr = '\0';
other_names = ptr + 1;
}
}
DEBUG(7, ("First name = '%s'", first_name));
DEBUG(7, ("Other names = '%s'", other_names));
_nc_set_type(first_name);
#if USE_HASHED_DB
if (write_object(tp, buffer + 1, &offset, limit - 1) != ERR) {
DB *capdb = _nc_db_open(_nc_tic_dir(0), TRUE);
DBT key, data;
if (capdb != 0) {
buffer[0] = 0;
memset(&key, 0, sizeof(key));
key.data = term_names;
key.size = name_size;
memset(&data, 0, sizeof(data));
data.data = buffer;
data.size = offset + 1;
_nc_db_put(capdb, &key, &data);
buffer[0] = 2;
key.data = name_list;
key.size = strlen(name_list);
_nc_STRCPY(buffer + 1,
term_names,
sizeof(buffer) - 1);
data.size = name_size + 1;
_nc_db_put(capdb, &key, &data);
while (*other_names != '\0') {
ptr = other_names++;
assert(ptr < buffer + sizeof(buffer) - 1);
while (*other_names != '|' && *other_names != '\0')
other_names++;
if (*other_names != '\0')
*(other_names++) = '\0';
key.data = ptr;
key.size = strlen(ptr);
_nc_db_put(capdb, &key, &data);
}
}
}
#else /* !USE_HASHED_DB */
if (call_count++ == 0) {
start_time = 0;
}
if (strlen(first_name) >= sizeof(filename) - (2 + LEAF_LEN))
_nc_warning("terminal name too long.");
_nc_SPRINTF(filename, _nc_SLIMIT(sizeof(filename))
LEAF_FMT "/%s", first_name[0], first_name);
/*
* Has this primary name been written since the first call to
* write_entry()? If so, the newer write will step on the older,
* so warn the user.
*/
if (start_time > 0 &&
stat(filename, &statbuf) >= 0
&& statbuf.st_mtime >= start_time) {
#if HAVE_LINK && !USE_SYMLINKS
/*
* If the file has more than one link, the reason for the previous
* write could be that the current primary name used to be an alias for
* the previous entry. In that case, unlink the file so that we will
* not modify the previous entry as we write this one.
*/
if (statbuf.st_nlink > 1) {
_nc_warning("name redefined.");
unlink(filename);
} else {
_nc_warning("name multiply defined.");
}
#else
_nc_warning("name multiply defined.");
#endif
}
check_writeable(first_name[0]);
write_file(filename, tp);
if (start_time == 0) {
if (stat(filename, &statbuf) < 0
|| (start_time = statbuf.st_mtime) == 0) {
_nc_syserr_abort("error obtaining time from %s/%s",
_nc_tic_dir(0), filename);
}
}
while (*other_names != '\0') {
ptr = other_names++;
while (*other_names != '|' && *other_names != '\0')
other_names++;
if (*other_names != '\0')
*(other_names++) = '\0';
if (strlen(ptr) > sizeof(linkname) - (2 + LEAF_LEN)) {
_nc_warning("terminal alias %s too long.", ptr);
continue;
}
if (strchr(ptr, '/') != 0) {
_nc_warning("cannot link alias %s.", ptr);
continue;
}
check_writeable(ptr[0]);
_nc_SPRINTF(linkname, _nc_SLIMIT(sizeof(linkname))
LEAF_FMT "/%s", ptr[0], ptr);
if (strcmp(filename, linkname) == 0) {
_nc_warning("self-synonym ignored");
} else if (stat(linkname, &statbuf) >= 0 &&
statbuf.st_mtime < start_time) {
_nc_warning("alias %s multiply defined.", ptr);
} else if (_nc_access(linkname, W_OK) == 0)
#if HAVE_LINK
{
int code;
#if USE_SYMLINKS
if (first_name[0] == linkname[0])
strncpy(symlinkname, first_name, sizeof(symlinkname) - 1);
else {
_nc_STRCPY(symlinkname, "../", sizeof(suymlinkname));
strncat(symlinkname, filename, sizeof(symlinkname) - 4);
}
symlinkname[sizeof(symlinkname) - 1] = '\0';
#endif /* USE_SYMLINKS */
#if HAVE_REMOVE
code = remove(linkname);
#else
code = unlink(linkname);
#endif
if (code != 0 && errno == ENOENT)
code = 0;
#if USE_SYMLINKS
if (symlink(symlinkname, linkname) < 0)
#else
if (link(filename, linkname) < 0)
#endif /* USE_SYMLINKS */
{
/*
* If there wasn't anything there, and we cannot
* link to the target because it is the same as the
* target, then the source must be on a filesystem
* that uses caseless filenames, such as Win32, etc.
*/
if (code == 0 && errno == EEXIST)
_nc_warning("can't link %s to %s", filename, linkname);
else if (code == 0 && (errno == EPERM || errno == ENOENT))
write_file(linkname, tp);
else {
#if MIXEDCASE_FILENAMES
_nc_syserr_abort("can't link %s to %s", filename, linkname);
#else
_nc_warning("can't link %s to %s (errno=%d)", filename,
linkname, errno);
#endif
}
} else {
DEBUG(1, ("Linked %s", linkname));
}
}
#else /* just make copies */
write_file(linkname, tp);
#endif /* HAVE_LINK */
}
#endif /* USE_HASHED_DB */
}
static void
play_game(void)
{
int dead = 0, i, j;
char c;
int selection[4], card;
while (dead < 4) {
dead = 0;
for (i = 0; i < 4; i++) {
card = grid[freeptr[i] - 1];
if (((card % SUIT_LENGTH) == KING)
||
(card == NOCARD))
selection[i] = NOCARD;
else
selection[i] = find(card + 1);
if (selection[i] == NOCARD)
dead++;
};
if (dead < 4) {
char live[NSUITS + 1], *lp = live;
for (i = 0; i < 4; i++) {
if (selection[i] != NOCARD) {
move(BASEROW + (selection[i] / GRID_WIDTH) * 2 + 3,
(selection[i] % GRID_WIDTH) * 5);
(void) printw(" %c ", (*lp++ = (char) ('a' + i)));
}
};
*lp = '\0';
if (strlen(live) == 1) {
move(PROMPTROW, 0);
(void) printw(
"Making forced moves... ");
refresh();
(void) sleep(1);
c = live[0];
} else {
char buf[BUFSIZ];
_nc_SPRINTF(buf, _nc_SLIMIT(sizeof(buf))
"Type [%s] to move, r to redraw, q or INTR to quit: ",
live);
do {
move(PROMPTROW, 0);
(void) addstr(buf);
move(PROMPTROW, (int) strlen(buf));
clrtoeol();
AddCh(' ');
} while
(((c = (char) getch()) < 'a' || c > 'd')
&& (c != 'r')
&& (c != 'q'));
}
for (j = 0; j < 4; j++)
if (selection[j] != NOCARD) {
move(BASEROW + (selection[j] / GRID_WIDTH) * 2 + 3,
(selection[j] % GRID_WIDTH) * 5);
(void) printw(" ");
}
if (c == 'r')
display_cards(deal_number);
else if (c == 'q')
die(SIGINT);
else {
i = c - 'a';
if (selection[i] == NOCARD)
beep();
else {
movecard(selection[i], freeptr[i]);
freeptr[i] = selection[i];
}
}
}
}
move(PROMPTROW, 0);
(void) standout();
(void) printw("Finished deal %d - type any character to continue...", deal_number);
(void) standend();
(void) getch();
}
_tracecchar_t2(int bufnum, const cchar_t *ch)
{
char *result = _nc_trace_buf(bufnum, (size_t) BUFSIZ);
if (result != 0) {
_nc_STRCPY(result, l_brace, TRACE_BUF_SIZE(bufnum));
if (ch != 0) {
const char *found;
attr_t attr = AttrOfD(ch);
if ((found = _nc_altcharset_name(attr, (chtype) CharOfD(ch))) != 0) {
(void) _nc_trace_bufcat(bufnum, found);
attr &= ~A_ALTCHARSET;
} else if (isWidecExt(CHDEREF(ch))) {
(void) _nc_trace_bufcat(bufnum, "{NAC}");
attr &= ~A_CHARTEXT;
} else {
PUTC_DATA;
int n;
(void) _nc_trace_bufcat(bufnum, "{ ");
for (PUTC_i = 0; PUTC_i < CCHARW_MAX; ++PUTC_i) {
PUTC_ch = ch->chars[PUTC_i];
if (PUTC_ch == L'\0') {
if (PUTC_i == 0)
(void) _nc_trace_bufcat(bufnum, "\\000");
break;
}
PUTC_INIT;
PUTC_n = (int) wcrtomb(PUTC_buf, ch->chars[PUTC_i], &PUT_st);
if (PUTC_n <= 0) {
if (PUTC_ch != L'\0') {
/* it could not be a multibyte sequence */
(void) _nc_trace_bufcat(bufnum,
_nc_tracechar(CURRENT_SCREEN,
UChar(ch->chars[PUTC_i])));
}
break;
} else if (ch->chars[PUTC_i] > 255) {
char temp[80];
_nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
"{%d:\\u%lx}",
wcwidth(ch->chars[PUTC_i]),
(unsigned long) ch->chars[PUTC_i]);
(void) _nc_trace_bufcat(bufnum, temp);
break;
}
for (n = 0; n < PUTC_n; n++) {
if (n)
(void) _nc_trace_bufcat(bufnum, ", ");
(void) _nc_trace_bufcat(bufnum,
_nc_tracechar(CURRENT_SCREEN,
UChar(PUTC_buf[n])));
}
}
(void) _nc_trace_bufcat(bufnum, " }");
}
if (attr != A_NORMAL) {
(void) _nc_trace_bufcat(bufnum, " | ");
(void) _nc_trace_bufcat(bufnum, _traceattr2(bufnum + 20, attr));
}
#if NCURSES_EXT_COLORS
/*
* Just in case the extended color is different from the chtype
* value, trace both.
*/
if (ch->ext_color != PairNumber(attr)) {
char temp[80];
_nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
" X_COLOR{%d:%d}", ch->ext_color, PairNumber(attr));
(void) _nc_trace_bufcat(bufnum, temp);
}
#endif
}
result = _nc_trace_bufcat(bufnum, r_brace);
}
return result;
}
