int
main(int argc, char *argv[])
{
wctype_t t;
int i, j;
struct {
const char *name;
int (*func)(wint_t);
} cls[] = {
{ "alnum", iswalnum },
{ "alpha", iswalpha },
{ "blank", iswblank },
{ "cntrl", iswcntrl },
{ "digit", iswdigit },
{ "graph", iswgraph },
{ "lower", iswlower },
{ "print", iswprint },
{ "punct", iswpunct },
{ "space", iswspace },
{ "upper", iswupper },
{ "xdigit", iswxdigit }
};
printf("1..2\n");
/*
* C/POSIX locale.
*/
for (i = 0; i < sizeof(cls) / sizeof(*cls); i++) {
t = wctype(cls[i].name);
assert(t != 0);
for (j = 0; j < 256; j++)
assert(cls[i].func(j) == iswctype(j, t));
}
t = wctype("elephant");
assert(t == 0);
for (i = 0; i < 256; i++)
assert(iswctype(i, t) == 0);
/*
* Japanese (EUC) locale.
*/
assert(strcmp(setlocale(LC_CTYPE, "ja_JP.eucJP"), "ja_JP.eucJP") == 0);
for (i = 0; i < sizeof(cls) / sizeof(*cls); i++) {
t = wctype(cls[i].name);
assert(t != 0);
for (j = 0; j < 65536; j++)
assert(cls[i].func(j) == iswctype(j, t));
}
t = wctype("elephant");
assert(t == 0);
for (i = 0; i < 65536; i++)
assert(iswctype(i, t) == 0);
printf("ok 1 - iswctype()\n");
printf("ok 2 - wctype()\n");
return (0);
}
static int match_bracket(const char *p, int k, int kfold)
{
wchar_t wc;
int inv = 0;
p++;
if (*p=='^' || *p=='!') {
inv = 1;
p++;
}
if (*p==']') {
if (k==']') return !inv;
p++;
} else if (*p=='-') {
if (k=='-') return !inv;
p++;
}
wc = p[-1];
for (; *p != ']'; p++) {
if (p[0]=='-' && p[1]!=']') {
wchar_t wc2;
int l = mbtowc(&wc2, p+1, 4);
if (l < 0) return 0;
if (wc <= wc2)
if ((unsigned)k-wc <= wc2-wc ||
(unsigned)kfold-wc <= wc2-wc)
return !inv;
p += l-1;
continue;
}
if (p[0]=='[' && (p[1]==':' || p[1]=='.' || p[1]=='=')) {
const char *p0 = p+2;
int z = p[1];
p+=3;
while (p[-1]!=z || p[0]!=']') p++;
if (z == ':' && p-1-p0 < 16) {
char buf[16];
memcpy(buf, p0, p-1-p0);
buf[p-1-p0] = 0;
if (iswctype(k, wctype(buf)) ||
iswctype(kfold, wctype(buf)))
return !inv;
}
continue;
}
if (*p < 128U) {
wc = (unsigned char)*p;
} else {
int l = mbtowc(&wc, p, 4);
if (l < 0) return 0;
p += l-1;
}
if (wc==k || wc==kfold) return !inv;
}
return inv;
}
int
_reg_iswblank(wint_t wc)
{
static int initialized;
static wctype_t wt;
if (!initialized)
{
initialized = 1;
wt = wctype("blank");
}
return iswctype(wc, wt);
}
/*
* cset_in_hard --
* Determine whether a character is in the set without using
* the cache.
*/
bool
cset_in_hard(struct cset *cs, wchar_t ch)
{
struct csclass *csc;
for (csc = cs->cs_classes; csc != NULL; csc = csc->csc_next)
if (csc->csc_invert ^ (iswctype(ch, csc->csc_type) != 0))
return (cs->cs_invert ^ true);
if (cs->cs_root != NULL) {
cs->cs_root = cset_splay(cs->cs_root, ch);
return (cs->cs_invert ^ (cset_rangecmp(cs->cs_root, ch) == 0));
}
return (cs->cs_invert ^ false);
}
// -----------------------------------------------------------------------------
//Function Name :testwctype13
//API Tested :wctype
//TestCase Description:wctype returns -> property descriptor if name is valid
//this prop desc can be used by iswctype function to test the wide char passed
// to it is of type returned by the wctype fun.
// -----------------------------------------------------------------------------
TInt CTestLibcwchar::testwctype13L()
{
wctype_t type;
type = wctype("upper");
if(type == (wctype_t)0)
{
return KErrGeneral;
}
if(iswctype((wint_t)L'K',type))
{
return KErrNone;
}
return KErrGeneral;
}
// -----------------------------------------------------------------------------
//Function Name :testwctype16
//API Tested :wctype
//TestCase Description:wctype returns -> property descriptor if name is valid
//this prop desc can be used by iswctype function to test the wide char passed
// to it is of type returned by the wctype fun.
// -----------------------------------------------------------------------------
TInt CTestLibcwchar::testwctype16L()
{
wctype_t type;
type = wctype("xdigit");
if(type == (wctype_t)0)
{
return KErrGeneral;
}
if(iswctype(6,type))
{
return KErrGeneral;
}
return KErrNone;
}
// -----------------------------------------------------------------------------
//Function Name :testwctype12
//API Tested :wctype
//TestCase Description:wctype returns -> property descriptor if name is valid
//this prop desc can be used by iswctype function to test the wide char passed
// to it is of type returned by the wctype fun.
// -----------------------------------------------------------------------------
TInt CTestLibcwchar::testwctype12L()
{
wctype_t type;
type = wctype("punct");
if(type == (wctype_t)0)
{
return KErrGeneral;
}
if(iswctype(L'k',type))
{
return KErrGeneral;
}
return KErrNone;
}
// -----------------------------------------------------------------------------
//Function Name :testwctype10
//API Tested :wctype
//TestCase Description:wctype returns -> property descriptor if name is valid
//this prop desc can be used by iswctype function to test the wide char passed
// to it is of type returned by the wctype fun.(negative test case)
// -----------------------------------------------------------------------------
TInt CTestLibcwchar::testwctype10L()
{
wctype_t type;
type = wctype("lower");
if(type == (wctype_t)0)
{
return KErrGeneral;
}
if(iswctype(L'K',type))
{
return KErrGeneral;
}
return KErrNone;
}
// -----------------------------------------------------------------------------
//Function Name :testwctype5
//API Tested :wctype
//TestCase Description:wctype returns -> property descriptor if name is valid
//this prop desc can be used by iswctype function to test the wide char passed
// to it is of type returned by the wctype fun.
// -----------------------------------------------------------------------------
TInt CTestLibcwchar::testwctype5L()
{
wctype_t type;
type = wctype("blank");
if(type == (wctype_t)0)
{
return KErrGeneral;
}
if(iswctype(L' ',type))
{
return KErrNone;
}
return KErrGeneral;
}
// -----------------------------------------------------------------------------
//Function Name :testwctype4
//API Tested :wctype
//TestCase Description:wctype returns -> property descriptor if name is valid
//this prop desc can be used by iswctype function to test the wide char passed
// to it is of type returned by the wctype fun.(negative test case)
// -----------------------------------------------------------------------------
TInt CTestLibcwchar::testwctype4L()
{
wctype_t type;
type = wctype("alpha");
if(type == (wctype_t)0)
{
return KErrGeneral;
}
if(iswctype(L'5',type))
{
return KErrGeneral;
}
return KErrNone;
}
// -----------------------------------------------------------------------------
//Function Name :testwctype2
//API Tested :wctype
//TestCase Description:wctype returns -> property descriptor if name is valid
//this prop desc can be used by iswctype function to test the wide char passed
// to it is of type returned by the wctype fun.
// -----------------------------------------------------------------------------
TInt CTestLibcwchar::testwctype2L()
{
wctype_t type;
type = wctype("alnum");
if(type == (wctype_t)0)
{
return KErrGeneral;
}
if(iswctype((wint_t)L'6',type))
{
return KErrNone;
}
return KErrGeneral;
}
/*
* See if a character matches a character class, starting at the first colon
* of "[:class:]".
* If a valid character class is recognized, a pointer to the next character
* after the final closing bracket is stored into *end, otherwise a null
* pointer is stored into *end.
*/
static int
match_charclass(const char *p, wchar_t chr, const char **end)
{
char name[20];
const char *nameend;
wctype_t cclass;
*end = NULL;
p++;
nameend = strstr(p, ":]");
if (nameend == NULL || nameend - p >= sizeof(name) || nameend == p)
return 0;
memcpy(name, p, nameend - p);
name[nameend - p] = '\0';
*end = nameend + 2;
cclass = wctype(name);
/* An unknown class matches nothing but is valid nevertheless. */
if (cclass == 0)
return 0;
return iswctype(chr, cclass);
}
int main()
{
wctype_t wct_kanji, wct_kata, wct_hira /* , ... */ ;
if ( setlocale( LC_CTYPE, "ja_JP.UTF-8" ) == NULL)
fputws(L"Unable to set the locale.\n", stderr);
if (( wct_kata = wctype( "jkata" ) ) == 0 )
{ wprintf( L"The locale doesn't support the wide-character type "
"string \"jkata\".\n" );
return -1;
}
/* ... */
wchar_t wc = fgetwc( stdin );
if ( iswctype( wc, wct_kata ) ) // Mainly 0xFF66 − 0xFF9F.
wprintf( L"%lc is a katakana character.\n", wc );
else
wprintf( L"%lc is a not katakana character.\n", wc );
return 0;
}
void wctype_check_functions(wint_t i, wctype_t t, wctrans_t tr, locale_t l)
{
(void)iswalnum(i);
(void)iswalnum_l(i, l);
(void)iswalpha(i);
(void)iswalpha_l(i, l);
(void)iswblank(i);
(void)iswblank_l(i, l);
(void)iswcntrl(i);
(void)iswcntrl_l(i, l);
(void)iswctype(i, t);
(void)iswctype_l(i, t, l);
(void)iswdigit(i);
(void)iswdigit_l(i, l);
(void)iswgraph(i);
(void)iswgraph_l(i, l);
(void)iswlower(i);
(void)iswlower_l(i, l);
(void)iswprint(i);
(void)iswprint_l(i, l);
(void)iswpunct(i);
(void)iswpunct_l(i, l);
(void)iswspace(i);
(void)iswspace_l(i, l);
(void)iswupper(i);
(void)iswupper_l(i, l);
(void)iswxdigit(i);
(void)iswxdigit_l(i, l);
(void)towctrans(i, tr);
(void)towctrans_l(i, tr, l);
(void)towlower(i);
(void)towlower_l(i, l);
(void)towupper(i);
(void)towupper_l(i, l);
(void)wctrans((const char *)1234);
(void)wctrans_l((const char *)1234, l);
(void)wctype((const char *)1234);
(void)wctype_l((const char *)1234, l);
}
/* Note: Using wctype()/iswctype() may seem odd, but that way we can avoid
* hardcoded character class lists.
*/
static int sub_bracket( const char *p, int c )
{
const char *s = p;
char sname[CCL_NAME_MAX + 1];
int i;
int type;
switch( *++p ) {
case ':':
++p;
for( i = 0; i < CCL_NAME_MAX; i++ ) {
if( !isalpha(*p ) )
break;
sname[i] = *p++;
}
sname[i] = '\0';
if( *p++ != ':' )
return( 0 );
if( *p++ != ']' )
return( 0 );
type = wctype( sname );
if( type ) {
int rc;
rc = p - s;
return( iswctype( c, type ) ? rc : -rc );
}
return( 0 );
case '=':
return( 0 );
case '.':
return( 0 );
default:
return( 0 );
}
}
/*
Returns whether we should save our changes or not.
Edits an existing an entry. This routine is far to big, and handles
everything, from movement between fields, and editing fields, even
painting the screen.
*/
int
edit_entry(dbrecord * entry, const char *operationDesc, const char *entryDesc)
{
int *len;
int col0;
wchar_t *line=NULL;
char tbuf[MAXSCREENWIDTH];
int code = 0;
wchar_t ch;
dbbuffer tmp;
register int i, j, row, col;
initHeading() ;
/* Where is "column zero"? To right of longest field name. */
col0 = idx.idx_maxlen + 2;
clear(); /* Clear the screen. */
initEntryLine() ;
paintHeading(operationDesc) ;
/* get max col TODO: change this when sigwhinch */
/* first time: allocat wchar fulldbdir name
fulldbdir is a static.*/
for (row = STARTROW; row < (idx.idx_nlines+STARTROW); row++) {
/* print field names. */
mvaddwstr(row, 0, idx.idx_lines[row-STARTROW]);
}
/* Allocate some space in a temporary entry, and copy entry */
/* to be edited into it. This way they can abort the edit. */
/* Here we need to allocate some extra space so we can edit */
for (i = STARTROW; i < (idx.idx_nlines+STARTROW); i++) {
int k = i-STARTROW ;
if (entry->db_lens[k] == 0) {
/* Allocate memory for this line. */
size_t linelen = (MAXSCREENWIDTH * sizeof(wchar_t));
tmp.db_lines[k] =
(wchar_t *) ymalloc(linelen,
"edit_entry","tmp.db_lines[k]" );
memset(tmp.db_lines[k],0,linelen);
tmp.db_lens[k] = 0;
} else {
/* Copy and print the line from the entry. */
tmp.db_lines[k] =
wcsFromUnicode_alloc((size_t *) & tmp.db_lens[k],
entry->db_lines[k],
(int32_t) entry->db_lens[k]);
if (tmp.db_lines[k] == NULL) {
yerror( YICU_CONV_ERR ,"edit_entry->wcsFromUnicode_alloc", "tmp.db_lines[k]", YX_EXTERNAL_CAUSE ) ;
}
/* reallocates more space to maximum linebuffer size. */
tmp.db_lines[k] =
(wchar_t *) yrealloc(tmp.db_lines[k], (size_t)
(MAXSCREENWIDTH * sizeof(wchar_t)),"edit_entry","tmp.db_lines[k]");
}
move(i, col0);
clrtoeol();
if (tmp.db_lens[k] > 0) {
addwstr(tmp.db_lines[k]);
}
} /* *could* have factored out the index code. */
col = col0;
row = STARTROW; /* row er hvilke rad i recorden (felt). */
move(row, col);
refresh();
/* Editing entry. We provide basic EMACS-style cntrl chars. */
while ((code = get_wch(&ch)) != EOF) {
/* Get the current line and line length. */
line = tmp.db_lines[row-STARTROW];
/* f.p. *len = &tmp.db_lens[row]; */
len = &tmp.db_lens[row-STARTROW];
switch (ch) {
case CTRL('a'): /* beginning of line */
col = col0;
break;
case KEY_LEFT:
case CTRL('b'): /* back character */
if (col > col0)
col--;
break;
case CTRL('d'): /* delete character */
if (col == (col0 + (int)wcslen(line))) {
col--;
} else if (*len) {
/* Calculate position of character in string. */
int l = col - col0;
/* Shuffle the string to the "left". */
while (l < *len) {
line[l] = line[l + 1];
l++;
}
*len -= 1;
/* Delete the character on the screen. */
delch();
if (col== (col0 + (int)wcslen(line)) ) {
--col ;
}
}
break;
case CTRL('e'): /* end of line */
col = col0 + *len;
break;
case KEY_RIGHT:
case CTRL('f'): /* forward character */
if ((col - col0) < *len)
col++;
break;
case KEY_BACKSPACE:
case CTRL('h'): /* backspace delete */
case '\177':
if (*len && ((col - 1) >= col0)) {
/* Calculate position of character to delete. */
int l = col - col0 - 1;
if (l < 0)
break;
/* Shuffle string "left". */
while (l < *len) {
line[l] = line[l + 1];
l++;
}
*len -= 1;
/* Delete the character from the screen. */
move(row, --col);
delch();
}
break;
case CTRL('k'): /* kill line */
if (len) {
int l = col - col0;
line[l] = (wchar_t) '\0';
*len = l;
clrtoeol();
}
break;
case CTRL('l'): /* redraw screen */
wrefresh(curscr);
break;
case KEY_DOWN:
case CTRL('n'): /* next line */
/* Wrap around to the top if necessary. */
if (++row >= (idx.idx_nlines+STARTROW))
row = STARTROW;
/* If nothing in this column, move to nearest */
/* non-empty column. */
if ((col - col0) > tmp.db_lens[row-STARTROW])
col = col0 + tmp.db_lens[row-STARTROW];
line[*len] = (wchar_t) '\0';
break;
case KEY_UP:
case CTRL('p'): /* previous line */
/* Wrap around if necessary. */
if (--row < STARTROW)
row = (idx.idx_nlines+STARTROW) - 1;
/* If nothing in this column, move to nearest */
/* on-empty column. */
if ((col - col0) > tmp.db_lens[row-STARTROW])
col = col0 + tmp.db_lens[row-STARTROW];
line[*len] = (wchar_t) '\0';
break;
case CTRL('['): /* save entry: ESC or something... */
if (line[*len] != (wchar_t) '\0')
line[*len] = (wchar_t) '\0';
sprintf(tbuf, "Save %s entry in database (y/n)? ", entryDesc);
ch = prompt_char(idx.idx_nlines + 2+ STARTROW, 0, tbuf, "yYnN");
/* See what they said. */
switch (ch) {
case '\n': /* never mind */
move(idx.idx_nlines + 2, 0);
clrtoeol();
break;
case 'Y': /* save entry */
case 'y':
/* Copy the temporary entry into the real entry. */
/* if there isn't anything to copy, then the entry db gets the value
NULL, and length 0 */
for (i = 0; i < idx.idx_nlines; i++) {
/* remove old contents in entry */
if (entry->db_lens[i] > 0) {
free(entry->db_lines[i]);
entry->db_lines[i] = NULL;
entry->db_lens[i] = 0;
}
if (tmp.db_lens[i] > 0) {
entry->db_lens[i]=tmp.db_lens[i] ;
entry->db_lines[i] =
unicodeFromWcs_alloc((size_t *) &entry->db_lens[i],tmp.db_lines[i]);
if (entry->db_lines[i] == NULL) {
yerror( YICU_CONV_ERR ,"edit_entry->unicodeFromWcs_alloc", "entry->db_lines[i]", YX_EXTERNAL_CAUSE ) ;
}
} /* had a dangling else bug here ? */
free(tmp.db_lines[i]);
tmp.db_lines[i] = NULL ;
tmp.db_lens[i] = 0;
}
return (1);
case 'N': /* don't save entry */
case 'n':
/* Free temporary memory. */
for (i = 0; i < idx.idx_nlines; i++) {
tmp.db_lens[i] = 0;
free(tmp.db_lines[i]);
tmp.db_lines[i] = NULL;
}
return (0);
}
break;
case '\r': /* return the string */
case '\n': /* go to next line */
/* Wrap around if necessary. */
if (++row >= (idx.idx_nlines+STARTROW))
row = STARTROW;
col = col0;
break;
default: /* something else */
/* User's kill character: accepted to del line too. */
if (ch == KEY_DL) {
move(row, col0);
clrtoeol();
col = col0;
*line = (wchar_t) '\0';
*len = 0;
} else if (code != KEY_CODE_YES) {
/* If it's a printable character, insert it into */
/* the string. */
if (iswctype(ch, wctype("print"))) {
if (col == (COLS - 1)) {
beep();
break;
}
/* Calculate character position. */
i = col - col0;
/* If necessary, move string * to "right" */
/* to insert the character. */
if (i < *len) {
for (j = *len; j >= i; j--)
line[j + 1] = line[j];
}
line[i] = ch;
*len += 1;
col++;
/* Insert the character on the screen. */
InsWch((chtype) ch);
}
}
break;
}
/* Move to the current row/column. */
move(row, col);
refresh();
}
return (0);
}
int iswprint( wint_t wc )
{
return iswctype( wc, _PDCLIB_CTYPE_GRAPH | _PDCLIB_CTYPE_SPACE );
}
static int Is_wc_8(int c) { return iswctype(c, ctype[CTYPES+7].wtype); }
int __iswctype_l(wint_t c, wctype_t t, locale_t l)
{
return iswctype(c, t);
}
/*
* @implemented
*/
int iswcntrl(wint_t c)
{
return iswctype(c, _CONTROL);
}
static int
do_test (void)
{
wctype_t wct;
wchar_t buf[1000];
int result = 1;
setlocale (LC_ALL, "");
wprintf (L"locale = %s\n", setlocale (LC_CTYPE, NULL));
wct = wctype ("jhira");
if (wct == 0)
error (EXIT_FAILURE, 0, "jhira: no such character class");
if (fgetws (buf, sizeof (buf) / sizeof (buf[0]), stdin) != NULL)
{
int n;
wprintf (L"buf[] = \"%ls\"\n", buf);
result = 0;
for (n = 0; buf[n] != L'\0'; ++n)
{
wprintf (L"jhira(U%04lx = %lc) = %d\n", (long) buf[n], buf[n],
iswctype (buf[n], wct));
result |= ((buf[n] < 0xff && iswctype (buf[n], wct))
|| (buf[n] > 0xff && !iswctype (buf[n], wct)));
}
}
wct = wctype ("jkata");
if (wct == 0)
error (EXIT_FAILURE, 0, "jkata: no such character class");
if (fgetws (buf, sizeof (buf) / sizeof (buf[0]), stdin) != NULL)
{
int n;
wprintf (L"buf[] = \"%ls\"\n", buf);
result = 0;
for (n = 0; buf[n] != L'\0'; ++n)
{
wprintf (L"jkata(U%04lx = %lc) = %d\n", (long) buf[n], buf[n],
iswctype (buf[n], wct));
result |= ((buf[n] < 0xff && iswctype (buf[n], wct))
|| (buf[n] > 0xff && !iswctype (buf[n], wct)));
}
}
wct = wctype ("jdigit");
if (wct == 0)
error (EXIT_FAILURE, 0, "jdigit: no such character class");
if (fgetws (buf, sizeof (buf) / sizeof (buf[0]), stdin) != NULL)
{
int n;
wprintf (L"buf[] = \"%ls\"\n", buf);
result = 0;
for (n = 0; buf[n] != L'\0'; ++n)
{
wprintf (L"jdigit(U%04lx = %lc) = %d\n", (long) buf[n], buf[n],
iswctype (buf[n], wct));
result |= ((buf[n] < 0xff && iswctype (buf[n], wct))
|| (buf[n] > 0xff && !iswctype (buf[n], wct)));
}
}
wct = wctype ("jspace");
if (wct == 0)
error (EXIT_FAILURE, 0, "jspace: no such character class");
if (fgetws (buf, sizeof (buf) / sizeof (buf[0]), stdin) != NULL)
{
int n;
wprintf (L"buf[] = \"%ls\"\n", buf);
result = 0;
for (n = 0; buf[n] != L'\0'; ++n)
{
wprintf (L"jspace(U%04lx = %lc) = %d\n", (long) buf[n], buf[n],
iswctype (buf[n], wct));
result |= ((buf[n] < 0xff && iswctype (buf[n], wct))
|| (buf[n] > 0xff && !iswctype (buf[n], wct)));
}
}
wct = wctype ("jkanji");
if (wct == 0)
error (EXIT_FAILURE, 0, "jkanji: no such character class");
if (fgetws (buf, sizeof (buf) / sizeof (buf[0]), stdin) != NULL)
{
int n;
wprintf (L"buf[] = \"%ls\"\n", buf);
result = 0;
for (n = 0; buf[n] != L'\0'; ++n)
{
wprintf (L"jkanji(U%04lx = %lc) = %d\n", (long) buf[n], buf[n],
iswctype (buf[n], wct));
result |= ((buf[n] < 0xff && iswctype (buf[n], wct))
|| (buf[n] > 0xff && !iswctype (buf[n], wct)));
}
}
return result;
}
int iswlower(wint_t wc) {
return iswctype(wc, _CtLow);
}
static char *
getarg(char *arg)
{
char *xarg = arg;
wchar_t c;
char mbc[MB_LEN_MAX];
size_t len;
int escape = 0;
int inquote = 0;
arg[0] = '\0';
while (MORE) {
len = 0;
c = getwchr(mbc, &len);
if (((arg - xarg) + len) > BUFLIM) {
EMSG2(ARG2LONG, BUFLIM);
exit(2);
ERR = TRUE;
return (NULL);
}
switch (c) {
case '\n':
if (ZERO) {
store_str(&arg, mbc, len);
continue;
}
/* FALLTHRU */
case '\0':
case WEOF: /* Note WEOF == EOF */
if (escape) {
EMSG(BADESCAPE);
ERR = TRUE;
return (NULL);
}
if (inquote) {
EMSG(MISSQUOTE);
ERR = TRUE;
return (NULL);
}
N_lines++;
break;
case '"':
if (ZERO || escape || (inquote == 1)) {
/* treat it literally */
escape = 0;
store_str(&arg, mbc, len);
} else if (inquote == 2) {
/* terminating double quote */
inquote = 0;
} else {
/* starting quoted string */
inquote = 2;
}
continue;
case '\'':
if (ZERO || escape || (inquote == 2)) {
/* treat it literally */
escape = 0;
store_str(&arg, mbc, len);
} else if (inquote == 1) {
/* terminating single quote */
inquote = 0;
} else {
/* starting quoted string */
inquote = 1;
}
continue;
case '\\':
/*
* Any unquoted character can be escaped by
* preceding it with a backslash.
*/
if (ZERO || inquote || escape) {
escape = 0;
store_str(&arg, mbc, len);
} else {
escape = 1;
}
continue;
default:
/* most times we will just want to store it */
if (inquote || escape || ZERO || !iswctype(c, blank)) {
escape = 0;
store_str(&arg, mbc, len);
continue;
}
/* unquoted blank */
break;
}
/*
* At this point we are processing a complete argument.
*/
if (strcmp(xarg, LEOF) == 0 && *LEOF != '\0') {
MORE = FALSE;
return (NULL);
}
if (c == WEOF) {
MORE = FALSE;
}
if (xarg[0] == '\0')
continue;
break;
}
return (xarg[0] == '\0' ? NULL : xarg);
}
int iswblank( wint_t wc )
{
return iswctype( wc, _PDCLIB_CTYPE_BLANK );
}
int iswspace(wint_t wc) {
return iswctype(wc, _CtSpc);
}
int
iswblank (wint_t wc)
{
return iswctype(wc, wctype("blank"));
}
/* TODO: all length calculations of the string must be rebuilt.
*
* BUG:
* Når jeg står på slutten av linjen så blir cursor pos
* justert mot venstre selv om jeg ikke sletter noe.
*
* */
void
prompt_str(int row, int col, const char *promptstr, wchar_t * answer)
{
wchar_t *line = answer;
int len, col0;
/* struct sgttyb _tty ; */
register int code, i, j;
/* Converts the promptstr to a wide version. */
wchar_t *wpromptstr = mbstowcs_alloc(promptstr);
if (wpromptstr == NULL) {
yerror( YMBS_WCS_ERR,"prompt_str->mbstowcs_alloc", "wpromptstr", YX_EXTERNAL_CAUSE ) ;
}
wchar_t ch;
/* Print the wide prompt at (row,col). */
mvaddwstr(row, col, wpromptstr);
refresh();
/* Calc "column zero", which is at right end of prompt. */
col += wcslen(wpromptstr);
col0 = col;
mvaddwstr(row, col, answer);
len = wcslen(answer) ;
col += len ;
/* Read chars till we get what we want. Useris allowed */
/* basic EMACS-style line editing. */
while ((code = get_wch(&ch)) != EOF) {
switch (ch) {
case CTRL('a'): /* beginning of line */
col = col0;
break;
case KEY_LEFT:
case CTRL('b'): /* back character */
if (col > col0)
col--;
break;
case CTRL('d'): /* delete character */
/*
* If there's stuff in the string,
* delete this character.
*/
if (col == (col0 + (int)wcslen(line))) {
col--;
} else if (len) {
/* Calc string pos of char to delete. */
i = col - col0;
/* Shuffle the string "left" one place. */
while (i < len) {
line[i] = line[i + 1];
i++;
}
/* Delete char on the screen. */
len -= 1;
delch(); /* prob ok that isn't wide. */
if (col== (col0 + (int)wcslen(line)) ) {
--col ;
}
}
break;
case CTRL('e'): /* end of line */
col = col0 + len;
break;
case KEY_RIGHT:
case CTRL('f'): /* forward character */
if ((col - col0) < len)
col++;
break;
case KEY_BACKSPACE:
case CTRL('h'): /* backspace delete */
case '\177':
/* If stuff in the string, delete char. */
if (len && ((col - 1) >= col0)) {
/* Calc pos in string of char to delete */
int l = col - col0 - 1;
if (l < 0)
break;
/* Shuffle the string "left" one place. */
while (l < len) {
line[l] = line[l + 1];
l++;
}
len -= 1;
/* Delete the character on the screen. */
move(row, --col);
delch();
}
break;
case CTRL('k'): /* kill line */
/* Clear the string. */
if (len) {
i = col - col0;
line[i] = '\0';
len = i;
clrtoeol();
}
break;
case CTRL('l'): /* redraw screen */
wrefresh(curscr);
break;
case KEY_ENTER:
case '\r': /* return the string */
case '\n': /* return the string */
line[len] = '\0';
return;
default: /* regular character */
if (ch == KEY_DL) {
move(row, col0);
clrtoeol();
col = col0;
*line = '\0';
len = 0;
} else if (code != KEY_CODE_YES) {
if (iswctype(ch, wctype("print"))) {
if (col == (COLS - 1)) {
beep();
break;
}
/* Calculate position of char in string. */
i = col - col0;
/* If we have to, move string "right" one */
/* place to insert the character. */
if (i < len) {
for (j = len; j >= i; j--)
line[j + 1] = line[j];
}
line[i] = ch;
len += 1;
col++;
/* Insert the character on the screen. */
InsWch((chtype) ch);
/* ins_wch(&ch); */
}
}
break;
}
/* Move the cursor. */
move(row, col);
refresh();
}
}
int iswgraph( wint_t wc )
{
return iswctype( wc, _PDCLIB_CTYPE_GRAPH );
}
int
iswprint(wint_t wc)
{
return iswctype(wc, _CTprint);
}
/*
* Convert a unicode string to an unsigned long integer.
*
* Ignores `locale' stuff. Assumes that the upper and lower case
* alphabets and digits are each contiguous.
*
* @implemented
*/
unsigned long
wcstoul(const wchar_t *nptr, wchar_t **endptr, int base)
{
const wchar_t *s = nptr;
unsigned long acc;
int c;
unsigned long cutoff;
int neg = 0, any, cutlim;
/*
* See strtol for comments as to the logic used.
*/
do {
c = *s++;
} while (iswctype(c, _SPACE));
if (c == L'-')
{
neg = 1;
c = *s++;
}
else if (c == L'+')
c = *s++;
if ((base == 0 || base == 16) &&
c == L'0' && (*s == L'x' || *s == L'X'))
{
c = s[1];
s += 2;
base = 16;
}
if (base == 0)
base = c == L'0' ? 8 : 10;
cutoff = (unsigned long)ULONG_MAX / (unsigned long)base;
cutlim = (unsigned long)ULONG_MAX % (unsigned long)base;
for (acc = 0, any = 0;; c = *s++)
{
if (iswctype(c, _DIGIT))
c -= L'0';
else if (iswctype(c, _ALPHA))
c -= iswctype(c, _UPPER) ? L'A' - 10 : L'a' - 10;
else
break;
if (c >= base)
break;
if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
any = -1;
else {
any = 1;
acc *= base;
acc += c;
}
}
if (any < 0)
{
acc = ULONG_MAX;
}
else if (neg)
acc = -acc;
if (endptr != 0)
*endptr = any ? (wchar_t *)((size_t)(s - 1)) : (wchar_t *)((size_t)nptr);
return acc;
}
