slk_wset(int i, const wchar_t *astr, int format)
{
int result = ERR;
size_t arglen;
const wchar_t *str;
char *mystr;
mbstate_t state;
T((T_CALLED("slk_wset(%d, %s, %d)"), i, _nc_viswbuf(astr), format));
init_mb(state);
str = astr;
if ((arglen = wcsrtombs(NULL, &str, 0, &state)) != (size_t) -1) {
if ((mystr = (char *) _nc_doalloc(0, arglen + 1)) != 0) {
str = astr;
if (wcsrtombs(mystr, &str, arglen, &state) != (size_t) -1) {
/* glibc documentation claims that the terminating L'\0'
* is written, but it is not...
*/
mystr[arglen] = 0;
result = slk_set(i, mystr, format);
}
free(mystr);
}
}
returnCode(result);
}
const char *
_nc_visbuf2(int bufnum, const char *buf)
/* visibilize a given string */
{
char *vbuf;
char *tp;
int c;
if (buf == 0)
return ("(null)");
if (buf == CANCELLED_STRING)
return ("(cancelled)");
#ifdef TRACE
tp = vbuf = _nc_trace_buf(bufnum, (strlen(buf) * 4) + 5);
#else
{
static char *mybuf[2];
mybuf[bufnum] = _nc_doalloc(mybuf[bufnum], (strlen(buf) * 4) + 5);
tp = vbuf = mybuf[bufnum];
}
#endif
*tp++ = '"';
while ((c = *buf++) != '\0') {
if (c == '"') {
*tp++ = '\\';
*tp++ = '"';
} else if (is7bits(c) && (isgraph(c) || c == ' ')) {
*tp++ = 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 == '\033') {
*tp++ = '\\';
*tp++ = 'e';
} else if (is7bits(c) && iscntrl(c)) {
*tp++ = '\\';
*tp++ = '^';
*tp++ = '@' + c;
} else {
sprintf(tp, "\\%03o", c & 0xff);
tp += strlen(tp);
}
}
*tp++ = '"';
*tp++ = '\0';
return (vbuf);
}
static char *
save_string(char *d, const char *const s)
{
size_t have = (size_t) (d - my_string);
size_t need = have + strlen(s) + 2;
if (need > my_length) {
my_string = (char *) _nc_doalloc(my_string, my_length = (need + need));
if (my_string == 0)
_nc_err_abort(MSG_NO_MEMORY);
d = my_string + have;
}
_nc_STRCPY(d, s, my_length - have);
return d + strlen(d);
}
_nc_slk_initialize(WINDOW *stwin, int cols)
{
int i, x;
int res = OK;
unsigned max_length;
T((T_CALLED("_nc_slk_initialize()")));
if (SP->_slk) { /* we did this already, so simply return */
returnCode(OK);
} else if ((SP->_slk = typeCalloc(SLK, 1)) == 0)
returnCode(ERR);
SP->_slk->ent = NULL;
/*
* If we use colors, vidputs() will suppress video attributes that conflict
* with colors. In that case, we're still guaranteed that "reverse" would
* work.
*/
if ((no_color_video & 1) == 0)
SetAttr(SP->_slk->attr, A_STANDOUT);
else
SetAttr(SP->_slk->attr, A_REVERSE);
SP->_slk->maxlab = ((num_labels > 0)
? num_labels
: MAX_SKEY(_nc_globals.slk_format));
SP->_slk->maxlen = ((num_labels > 0)
? label_width * label_height
: MAX_SKEY_LEN(_nc_globals.slk_format));
SP->_slk->labcnt = ((SP->_slk->maxlab < MAX_SKEY(_nc_globals.slk_format))
? MAX_SKEY(_nc_globals.slk_format)
: SP->_slk->maxlab);
if (SP->_slk->maxlen <= 0
|| SP->_slk->labcnt <= 0
|| (SP->_slk->ent = typeCalloc(slk_ent,
(unsigned) SP->_slk->labcnt)) == NULL)
returnCode(slk_failed());
max_length = SP->_slk->maxlen;
for (i = 0; i < SP->_slk->labcnt; i++) {
size_t used = max_length + 1;
if ((SP->_slk->ent[i].ent_text = (char *) _nc_doalloc(0, used)) == 0)
returnCode(slk_failed());
memset(SP->_slk->ent[i].ent_text, 0, used);
if ((SP->_slk->ent[i].form_text = (char *) _nc_doalloc(0, used)) == 0)
returnCode(slk_failed());
memset(SP->_slk->ent[i].form_text, 0, used);
memset(SP->_slk->ent[i].form_text, ' ', max_length);
SP->_slk->ent[i].visible = (char) (i < SP->_slk->maxlab);
}
if (_nc_globals.slk_format >= 3) { /* PC style */
int gap = (cols - 3 * (3 + 4 * max_length)) / 2;
if (gap < 1)
gap = 1;
for (i = x = 0; i < SP->_slk->maxlab; i++) {
SP->_slk->ent[i].ent_x = x;
x += max_length;
x += (i == 3 || i == 7) ? gap : 1;
}
} else {
if (_nc_globals.slk_format == 2) { /* 4-4 */
int gap = cols - (SP->_slk->maxlab * max_length) - 6;
if (gap < 1)
gap = 1;
for (i = x = 0; i < SP->_slk->maxlab; i++) {
SP->_slk->ent[i].ent_x = x;
x += max_length;
x += (i == 3) ? gap : 1;
}
} else {
if (_nc_globals.slk_format == 1) { /* 1 -> 3-2-3 */
int gap = (cols - (SP->_slk->maxlab * max_length) - 5)
/ 2;
if (gap < 1)
gap = 1;
for (i = x = 0; i < SP->_slk->maxlab; i++) {
SP->_slk->ent[i].ent_x = x;
x += max_length;
x += (i == 2 || i == 4) ? gap : 1;
}
} else
returnCode(slk_failed());
}
}
SP->_slk->dirty = TRUE;
if ((SP->_slk->win = stwin) == NULL) {
returnCode(slk_failed());
}
/* We now reset the format so that the next newterm has again
* per default no SLK keys and may call slk_init again to
* define a new layout. (juergen 03-Mar-1999)
*/
SP->slk_format = _nc_globals.slk_format;
_nc_globals.slk_format = 0;
returnCode(res);
}
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 == '%') {
const 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 += UChar(*++string);
/* 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;
}
NCURSES_SP_NAME(slk_set) (NCURSES_SP_DCLx int i, const char *astr, int format)
{
SLK *slk;
int offset;
int numchrs;
int numcols;
int limit;
const char *str = astr;
const char *p;
T((T_CALLED("slk_set(%p, %d, \"%s\", %d)"), (void *) SP_PARM, i, str, format));
if (SP_PARM == 0
|| (slk = SP_PARM->_slk) == 0
|| i < 1
|| i > slk->labcnt
|| format < 0
|| format > 2)
returnCode(ERR);
if (str == 0)
str = "";
--i; /* Adjust numbering of labels */
limit = MAX_SKEY_LEN(SP_PARM->slk_format);
while (isspace(UChar(*str)))
str++; /* skip over leading spaces */
p = str;
#if USE_WIDEC_SUPPORT
numcols = 0;
while (*p != 0) {
mbstate_t state;
wchar_t wc;
size_t need;
init_mb(state);
need = mbrtowc(0, p, strlen(p), &state);
if (need == (size_t) -1)
break;
mbrtowc(&wc, p, need, &state);
if (!iswprint((wint_t) wc))
break;
if (wcwidth(wc) + numcols > limit)
break;
numcols += wcwidth(wc);
p += need;
}
numchrs = (p - str);
#else
while (isprint(UChar(*p)))
p++; /* The first non-print stops */
numcols = (p - str);
if (numcols > limit)
numcols = limit;
numchrs = numcols;
#endif
FreeIfNeeded(slk->ent[i].ent_text);
if ((slk->ent[i].ent_text = strdup(str)) == 0)
returnCode(ERR);
slk->ent[i].ent_text[numchrs] = '\0';
if ((slk->ent[i].form_text = (char *) _nc_doalloc(slk->ent[i].form_text,
(unsigned) (limit +
numchrs + 1))
) == 0)
returnCode(ERR);
switch (format) {
default:
case 0: /* left-justified */
offset = 0;
break;
case 1: /* centered */
offset = (limit - numcols) / 2;
break;
case 2: /* right-justified */
offset = limit - numcols;
break;
}
if (offset <= 0)
offset = 0;
else
memset(slk->ent[i].form_text, ' ', (unsigned) offset);
memcpy(slk->ent[i].form_text + offset,
slk->ent[i].ent_text,
(unsigned) numchrs);
if (offset < limit) {
memset(slk->ent[i].form_text + offset + numchrs,
' ',
(unsigned) (limit - (offset + numcols)));
}
slk->ent[i].form_text[numchrs - numcols + limit] = 0;
slk->ent[i].dirty = TRUE;
returnCode(OK);
}
static int
next_char(void)
{
if (!yyin) {
/*
* An string with an embedded null will truncate the input. This is
* intentional (we don't read binary files here).
*/
if (*bufptr == '\0')
return (EOF);
if (*bufptr == '\n') {
_nc_curr_line++;
_nc_curr_col = 0;
}
} else if (!bufptr || !*bufptr) {
/*
* In theory this could be recoded to do its I/O one character at a
* time, saving the buffer space. In practice, this turns out to be
* quite hard to get completely right. Try it and see. If you
* succeed, don't forget to hack push_back() correspondingly.
*/
static char *result;
static size_t allocated;
size_t used;
size_t len;
do {
bufstart = 0;
used = 0;
do {
if (used + (LEXBUFSIZ / 4) >= allocated) {
allocated += (allocated + LEXBUFSIZ);
result = _nc_doalloc(result, allocated);
if (result == 0)
return (EOF);
}
if (used == 0)
_nc_curr_file_pos = ftell(yyin);
if (fgets(result + used, allocated - used, yyin) != NULL) {
bufstart = result;
if (used == 0) {
_nc_curr_line++;
_nc_curr_col = 0;
}
} else {
if (used != 0)
strlcat(result, "\n", allocated);
}
if ((bufptr = bufstart) != 0) {
used = strlen(bufptr);
while (iswhite(*bufptr))
bufptr++;
/*
* Treat a trailing <cr><lf> the same as a <newline> so we
* can read files on OS/2, etc.
*/
if ((len = strlen(bufptr)) > 1) {
if (bufptr[len - 1] == '\n'
&& bufptr[len - 2] == '\r') {
len--;
bufptr[len - 1] = '\n';
bufptr[len] = '\0';
}
}
} else {
return (EOF);
}
} while (bufptr[len - 1] != '\n'); /* complete a line */
} while (result[0] == '#'); /* ignore comments */
}
first_column = (bufptr == bufstart);
_nc_curr_col++;
return (*bufptr++);
}
_nc_slk_initialize(WINDOW *stwin, int cols)
{
int i;
int res = OK;
unsigned max_length;
SCREEN *sp;
TERMINAL *term;
int numlab;
T((T_CALLED("_nc_slk_initialize()")));
assert(stwin);
sp = _nc_screen_of(stwin);
if (0 == sp)
returnCode(ERR);
term = TerminalOf(SP_PARM);
assert(term);
numlab = NumLabels;
if (SP_PARM->_slk) { /* we did this already, so simply return */
returnCode(OK);
} else if ((SP_PARM->_slk = typeCalloc(SLK, 1)) == 0)
returnCode(ERR);
if (!SP_PARM->slk_format)
SP_PARM->slk_format = _nc_globals.slk_format;
/*
* If we use colors, vidputs() will suppress video attributes that conflict
* with colors. In that case, we're still guaranteed that "reverse" would
* work.
*/
if ((NoColorVideo & 1) == 0)
SetAttr(SP_PARM->_slk->attr, A_STANDOUT);
else
SetAttr(SP_PARM->_slk->attr, A_REVERSE);
SP_PARM->_slk->maxlab = ((numlab > 0)
? numlab
: MAX_SKEY(SP_PARM->slk_format));
SP_PARM->_slk->maxlen = ((numlab > 0)
? LabelWidth * LabelHeight
: MAX_SKEY_LEN(SP_PARM->slk_format));
SP_PARM->_slk->labcnt = ((SP_PARM->_slk->maxlab < MAX_SKEY(SP_PARM->slk_format))
? MAX_SKEY(SP_PARM->slk_format)
: SP_PARM->_slk->maxlab);
if (SP_PARM->_slk->maxlen <= 0
|| SP_PARM->_slk->labcnt <= 0
|| (SP_PARM->_slk->ent = typeCalloc(slk_ent,
(unsigned) SP_PARM->_slk->labcnt))
== NULL)
returnCode(slk_failed(NCURSES_SP_ARG));
max_length = SP_PARM->_slk->maxlen;
for (i = 0; i < SP_PARM->_slk->labcnt; i++) {
size_t used = max_length + 1;
SP_PARM->_slk->ent[i].ent_text = (char *) _nc_doalloc(0, used);
if (SP_PARM->_slk->ent[i].ent_text == 0)
returnCode(slk_failed(NCURSES_SP_ARG));
memset(SP_PARM->_slk->ent[i].ent_text, 0, used);
SP_PARM->_slk->ent[i].form_text = (char *) _nc_doalloc(0, used);
if (SP_PARM->_slk->ent[i].form_text == 0)
returnCode(slk_failed(NCURSES_SP_ARG));
memset(SP_PARM->_slk->ent[i].form_text, 0, used);
memset(SP_PARM->_slk->ent[i].form_text, ' ', max_length);
SP_PARM->_slk->ent[i].visible = (char) (i < SP_PARM->_slk->maxlab);
}
res = _nc_format_slks(NCURSES_SP_ARGx cols);
if ((SP_PARM->_slk->win = stwin) == NULL) {
returnCode(slk_failed(NCURSES_SP_ARG));
}
/* We now reset the format so that the next newterm has again
* per default no SLK keys and may call slk_init again to
* define a new layout. (juergen 03-Mar-1999)
*/
_nc_globals.slk_format = 0;
returnCode(res);
}