_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; }