/*
* Handle delete backward-word
*/
static void rl_key_delete_backward_word (void)
{
if (!rl_ucspos)
return;
rl_key_left ();
if (rl_ucspos > 0 && !iswalnum (rl_ucs_at (&rl_ucs, rl_ucspos)))
while (rl_ucspos > 0 && !iswalnum (rl_ucs_at (&rl_ucs, rl_ucspos)))
{
rl_key_delete ();
rl_key_left ();
}
if (!rl_ucspos)
{
rl_key_delete ();
return;
}
while (rl_ucspos > 0 && iswalnum (rl_ucs_at (&rl_ucs, rl_ucspos)))
{
rl_key_delete ();
rl_key_left ();
}
if (!iswalnum (rl_ucs_at (&rl_ucs, rl_ucspos)))
rl_key_right ();
else
rl_key_delete ();
}
bool move_word_state_machine_t::consume_char_punctuation(wchar_t c) {
enum { s_always_one = 0, s_rest, s_whitespace_rest, s_whitespace, s_alphanumeric, s_end };
bool consumed = false;
while (state != s_end && !consumed) {
switch (state) {
case s_always_one: {
// Always consume the first character.
consumed = true;
if (iswspace(c)) {
state = s_whitespace;
} else {
// Don't allow switching type (ws->nonws) after non-whitespace.
state = s_rest;
}
break;
}
case s_rest: {
if (iswspace(c)) {
// Consume only trailing whitespace.
state = s_whitespace_rest;
} else if (iswalnum(c)) {
// Consume only alnums.
state = s_alphanumeric;
} else {
consumed = false;
state = s_end;
}
break;
}
case s_whitespace_rest:
case s_whitespace: {
// "whitespace" consumes whitespace and switches to alnums,
// "whitespace_rest" only consumes whitespace.
if (iswspace(c)) {
// Consumed whitespace.
consumed = true;
} else {
state = state == s_whitespace ? s_alphanumeric : s_end;
}
break;
}
case s_alphanumeric: {
if (iswalnum(c)) {
consumed = true; // consumed alphanumeric
} else {
state = s_end;
}
break;
}
case s_end:
default: { break; }
}
}
return consumed;
}
/*
* Handle forward-word
*/
static void rl_key_forward_word (void)
{
if (rl_ucspos < rl_ucscol.len)
rl_key_right ();
if (rl_ucspos < rl_ucscol.len && !iswalnum (rl_ucs_at (&rl_ucs, rl_ucspos)))
while (rl_ucspos < rl_ucscol.len && !iswalnum (rl_ucs_at (&rl_ucs, rl_ucspos)))
rl_key_right ();
while (rl_ucspos < rl_ucscol.len && iswalnum (rl_ucs_at (&rl_ucs, rl_ucspos)))
rl_key_right ();
}
static int MatchSet( DaoRegex *self, DaoRgxItem *patt, daoint pos )
{
DCharState ch = { 1, 1, 0 };
DCharState chi = ch, chi2 = ch, chi3 = ch;
char *chars = self->wordbuf + patt->word;
char *end = chars + patt->length;
char *src = self->source;
int blmatch = 1;
int matched = 0;
short i;
patt->offset = 0;
if( pos >= self->end ) return 0;
ch = DString_DecodeChar( src + pos, src + self->end );
if( patt->config & PAT_CONFIG_CASEINS ) ch.value = towlower( ch.value );
patt->offset = ch.width;
for(i=0; i<patt->length; ){
chi3.type = 0;
chi3.width = 0;
chi3.value = 0;
chi = DString_DecodeChar2( chars + i, end );
chi2 = DString_DecodeChar2( chars + i + chi.width, end );
if( (i + chi.width + chi2.width) < patt->length ){
chi3 = DString_DecodeChar2( chars + i + chi.width + chi2.width, end );
}
if( i == 0 && chi.value == '^' ){
blmatch = 0;
}else if( chi.value == '%' ){
i += chi2.width;
switch( chi2.value ){
case 's': case 'S': case 'k': case 'K': case 'p': case 'P':
case 'c': case 'C': case 'a': case 'A': case 'w': case 'W':
case 'e': case 'E': case 'd': case 'D': case 'x': case 'X':
patt->type = chi2.value;
matched = (MatchOne( self, patt, pos ) !=0);
patt->type = PAT_SET;
break;
case 't' : matched = (ch.value == '\t'); break;
case 'n' : matched = (ch.value == '\n'); break;
default : matched = (ch.value == chi2.value); break;
}
}else if( chi3.type && iswalnum(chi.value) && chi2.value == '-' && iswalnum(chi3.value) ){
i += chi2.width + chi3.width;
matched = ( ch.value >= chi.value && ch.value <= chi3.value );
}else{
matched = (chi.value == ch.value);
}
i += chi.width;
if( matched ) break;
}
if( matched == blmatch ) return 1;
patt->offset = 0;
return 0;
}
// a text run is a string of consecutive text with uniform style
void HtmlFormatter::EmitTextRun(const char* s, const char* end) {
currReparseIdx = s - htmlParser->Start();
CrashIf(!ValidReparseIdx(currReparseIdx, htmlParser));
CrashIf(IsSpaceOnly(s, end) && !preFormatted);
const char* tmp = ResolveHtmlEntities(s, end, textAllocator);
bool resolved = tmp != s;
if (resolved) {
s = tmp;
end = s + str::Len(s);
}
while (s < end) {
// don't update the reparseIdx if s doesn't point into the original source
if (!resolved)
currReparseIdx = s - htmlParser->Start();
size_t strLen = str::Utf8ToWcharBuf(s, end - s, buf, dimof(buf));
// soft hyphens should not be displayed
strLen -= str::RemoveChars(buf, L"\xad");
if (0 == strLen)
break;
textMeasure->SetFont(CurrFont());
RectF bbox = textMeasure->Measure(buf, strLen);
EnsureDx(bbox.Width);
if (bbox.Width <= pageDx - currX) {
AppendInstr(DrawInstr::Str(s, end - s, bbox, dirRtl));
currX += bbox.Width;
break;
}
size_t lenThatFits = StringLenForWidth(textMeasure, buf, strLen, pageDx - NewLineX());
// try to prevent a break in the middle of a word
if (iswalnum(buf[lenThatFits])) {
for (size_t len = lenThatFits; len > 0; len--) {
if (!iswalnum(buf[len - 1])) {
lenThatFits = len;
break;
}
}
}
textMeasure->SetFont(CurrFont());
bbox = textMeasure->Measure(buf, lenThatFits);
CrashIf(bbox.Width > pageDx);
// s is UTF-8 and buf is UTF-16, so one
// WCHAR doesn't always equal one char
// TODO: this usually fails for non-BMP characters (i.e. hardly ever)
for (size_t i = lenThatFits; i > 0; i--) {
lenThatFits += buf[i - 1] < 0x80 ? 0 : buf[i - 1] < 0x800 ? 1 : 2;
}
AppendInstr(DrawInstr::Str(s, lenThatFits, bbox, dirRtl));
currX += bbox.Width;
s += lenThatFits;
}
}
int dao_character( uint_t ch )
{
#ifdef BSD
return (ch == '_' || iswalnum(ch) || iswideogram(ch) || iswphonogram(ch) );
#elif defined(LINUX)
return (ch == '_' || iswalnum(ch));
#else
uint_t ch2 = ch;
if( sizeof(wchar_t) == 2 && ch > 0xFFFF ) ch = 0; /* for isw*(); */
return (ch == '_' || iswalnum(ch) || dao_cjk(ch2));
#endif
}
/*
* Handle backward-word
*/
static void rl_key_backward_word (void)
{
if (rl_ucspos > 0)
rl_key_left ();
if (rl_ucspos > 0 && !iswalnum (rl_ucs_at (&rl_ucs, rl_ucspos)))
while (rl_ucspos > 0 && !iswalnum (rl_ucs_at (&rl_ucs, rl_ucspos)))
rl_key_left ();
while (rl_ucspos > 0 && iswalnum (rl_ucs_at (&rl_ucs, rl_ucspos)))
rl_key_left ();
if (!iswalnum (rl_ucs_at (&rl_ucs, rl_ucspos)))
rl_key_right ();
}
int BLC_PREFIX(iswctype)(wint_t wc, wctype_t desc)
{
switch (desc) {
case wctype_alnum:
return iswalnum(wc);
case wctype_alpha:
return iswalpha(wc);
case wctype_blank:
return iswblank(wc);
case wctype_cntrl:
return iswcntrl(wc);
case wctype_digit:
return iswdigit(wc);
case wctype_graph:
return iswgraph(wc);
case wctype_lower:
return iswlower(wc);
case wctype_print:
return iswprint(wc);
case wctype_punct:
return iswpunct(wc);
case wctype_space:
return iswspace(wc);
case wctype_upper:
return iswupper(wc);
case wctype_xdigit:
return iswxdigit(wc);
default:
return 0;
}
}
int main()
{
wint_t wc;
int i, dummy;
setlocale( LC_CTYPE, "" );
wprintf( L"\nThe current locale for the 'is ...' functions is '%s'.\n",
setlocale( LC_CTYPE, NULL ) );
wprintf( L"These are the alphanumeric wide characters"
" in this locale:\n\n" );
for ( wc = 0, i = 0; wc < 1024; wc++ )
if ( iswalnum( wc ) )
{
if ( i % 25 == 0 )
{
wprintf( L"... more ...\n" );
dummy = getchar(); // Wait before printing more
wprintf( L"Wide character Code\n" );
wprintf( L"-----------------------\n" );
}
wprintf( L"%5lc %4lu\n", wc, wc );
i++;
}
wprintf( L"-----------------------\n" );
return 0;
}
int get_trait (qse_wcint_t code)
{
int trait = 0;
if (iswupper(code)) trait |= TRAIT_UPPER;
if (iswlower(code)) trait |= TRAIT_LOWER;
if (iswalpha(code)) trait |= TRAIT_ALPHA;
if (iswdigit(code)) trait |= TRAIT_DIGIT;
if (iswxdigit(code)) trait |= TRAIT_XDIGIT;
if (iswalnum(code)) trait |= TRAIT_ALNUM;
if (iswspace(code)) trait |= TRAIT_SPACE;
if (iswprint(code)) trait |= TRAIT_PRINT;
if (iswgraph(code)) trait |= TRAIT_GRAPH;
if (iswcntrl(code)) trait |= TRAIT_CNTRL;
if (iswpunct(code)) trait |= TRAIT_PUNCT;
if (iswblank(code)) trait |= TRAIT_BLANK;
/*
if (iswascii(code)) trait |= TRAIT_ASCII;
if (isphonogram(code)) trait |= TRAIT_PHONO;
if (isideogram(code)) trait |= TRAIT_IDEOG;
if (isenglish(code)) trait |= TRAIT_ENGLI;
*/
return trait;
}
int fileHandle::importFound(char* _filename)
{
ifstream in((const char*)_filename);
char buffer[65536]="";
if (in.is_open()){
if (! in.eof()){
in.getline (buffer,65536);
if (!iswalnum(buffer[0]) && !iswpunct(buffer[0]) && !iswspace(buffer[0]) && !iswdigit(buffer[0])){
cout << "BAD FILE"<<endl;
return -1;
}
}
in.getline (buffer,65536);
while (!in.eof()){
if (iswdigit(buffer[0])){
char * pch;
pch = strtok(buffer,",");
while (pch != NULL){
int scanNum;
scanNum=atoi(pch);
found_scans.push_back(scanNum);
pch = strtok(NULL,",");
}
}
in.getline (buffer,65536);
}
}
else
{ cout << "Error opening file"; return 0; }
return 1;
}
static int
keyword_or_ident(mvc * c, int cur)
{
struct scanner *lc = &c->scanner;
keyword *k = NULL;
int s;
lc->started = 1;
utf8_putchar(lc, cur);
s = lc->yycur;
lc->yyval = IDENT;
while ((cur = scanner_getc(lc)) != EOF) {
if (!iswalnum(cur) && cur != '_') {
utf8_putchar(lc, cur);
(void)scanner_token(lc, IDENT);
k = find_keyword_bs(lc,s);
if (k)
lc->yyval = k->token;
/* find keyword in SELECT/JOIN/UNION FUNCTIONS */
else if (sql_find_func(c->sa, cur_schema(c), lc->rs->buf+lc->rs->pos+s, -1, F_FILT, NULL))
lc->yyval = FILTER_FUNC;
return lc->yyval;
}
}
(void)scanner_token(lc, IDENT);
k = find_keyword_bs(lc,s);
if (k)
lc->yyval = k->token;
/* find keyword in SELECT/JOIN/UNION FUNCTIONS */
else if (sql_find_func(c->sa, cur_schema(c), lc->rs->buf+lc->rs->pos+s, -1, F_FILT, NULL))
lc->yyval = FILTER_FUNC;
return lc->yyval;
}
static int
p_isalnum(TParser *prs)
{
Assert( prs->state );
if (prs->usewide)
{
if (lc_ctype_is_c())
{
unsigned int c = *(prs->wstr + prs->state->poschar);
/*
* any non-ascii symbol with multibyte encoding
* with C-locale is an alpha character
*/
if ( c > 0x7f )
return 1;
return isalnum(0xff & c);
}
return iswalnum( (wint_t)*( prs->wstr + prs->state->poschar));
}
return isalnum( *(unsigned char*)( prs->str + prs->state->posbyte ));
}
std::wstring UrlEncodeString(const wchar_t *pwz)
{
std::wstring result;
while (*pwz)
{
wchar_t ch = *pwz;
const wchar_t c_wzUnreservedSpecialChars[] = L"-_.~";
if ( iswalnum(ch) || wcschr(c_wzUnreservedSpecialChars, ch) != nullptr)
{
result += ch;
}
else if (ch == L' ')
{
result += L'+';
}
else
{
wchar_t wszPercentEncoded[16];
assert(ch >= 0x10 && ch <= 0xFF);
swprintf_s(wszPercentEncoded, L"%%%02X", (int)ch);
result += wszPercentEncoded;
}
pwz++;
}
return result;
}
int iswctype(wint_t wc, wctype_t type) {
switch (type) {
case WCTYPE_ALNUM:
return iswalnum(wc);
case WCTYPE_ALPHA:
return iswalpha(wc);
case WCTYPE_BLANK:
return iswblank(wc);
case WCTYPE_CNTRL:
return iswcntrl(wc);
case WCTYPE_DIGIT:
return iswdigit(wc);
case WCTYPE_GRAPH:
return iswgraph(wc);
case WCTYPE_LOWER:
return iswlower(wc);
case WCTYPE_PRINT:
return iswprint(wc);
case WCTYPE_PUNCT:
return iswpunct(wc);
case WCTYPE_SPACE:
return iswspace(wc);
case WCTYPE_UPPER:
return iswupper(wc);
case WCTYPE_XDIGIT:
return iswxdigit(wc);
}
return 0;
}
static int
set_quote(arg_string *as)
{ int needq = 0;
const wchar_t *s = as->text;
for(; *s; s++)
{ if ( !iswalnum(*s) )
{ if ( *s == '"' )
needq |= QDBLQ;
else if ( *s == '\'' )
needq |= QSBLQ;
else
needq |= QMISC;
}
}
if ( !needq )
{ as->quote = 0;
return TRUE;
}
needq &= ~QMISC;
switch( needq )
{ case QDBLQ:
as->quote = '\'';
return TRUE;
case 0:
case QSBLQ:
as->quote = '"';
return TRUE;
default:
return FALSE;
}
}
wchar_t *
prepkey(const char *string, wchar_t termchar)
{
const char *readp;
wchar_t *key, *writep;
wchar_t ch;
size_t clen;
/*
* Reformat search string and convert to wide character representation
* to avoid doing it multiple times later.
*/
if ((key = malloc(sizeof(wchar_t) * (strlen(string) + 1))) == NULL)
err(2, NULL);
readp = string;
writep = key;
while ((clen = mbrtowc(&ch, readp, MB_LEN_MAX, NULL)) != 0) {
if (clen == (size_t)-1 || clen == (size_t)-2)
errc(2, EILSEQ, NULL);
if (fflag)
ch = towlower(ch);
if (!dflag || iswalnum(ch))
*writep++ = ch;
readp += clen;
}
*writep = L'\0';
if (termchar != L'\0' && (writep = wcschr(key, termchar)) != NULL)
*++writep = L'\0';
return (key);
}
/*
* Return LESS, GREATER, or EQUAL depending on how the string1 compares with
* string2 (s1 ??? s2).
*
* o Matches up to len(s1) are EQUAL.
* o Matches up to len(s2) are GREATER.
*
* Compare understands about the -f and -d flags, and treats comparisons
* appropriately.
*
* The string "s1" is null terminated. The string s2 is '\n' terminated (or
* "back" terminated).
*/
int
compare(wchar_t *s1, unsigned char *s2, unsigned char *back)
{
wchar_t ch1, ch2;
size_t len2;
for (; *s1 && s2 < back && *s2 != '\n'; ++s1, s2 += len2) {
ch1 = *s1;
len2 = mbrtowc(&ch2, s2, back - s2, NULL);
if (len2 == (size_t)-1 || len2 == (size_t)-2) {
ch2 = *s2;
len2 = 1;
}
if (fflag)
ch2 = towlower(ch2);
if (dflag && !iswalnum(ch2)) {
/* Ignore character in comparison. */
--s1;
continue;
}
if (ch1 != ch2)
return (ch1 < ch2 ? LESS : GREATER);
}
return (*s1 ? GREATER : EQUAL);
}
ScreenCharacterType
getScreenCharacterType (const ScreenCharacter *character) {
if (iswspace(character->text)) return SCT_SPACE;
if (iswalnum(character->text)) return SCT_WORD;
if (wcschr(WS_C("_"), character->text)) return SCT_WORD;
return SCT_NONWORD;
}
bool move_word_state_machine_t::consume_char_punctuation(wchar_t c) {
enum { s_always_one = 0, s_whitespace, s_alphanumeric, s_end };
bool consumed = false;
while (state != s_end && !consumed) {
switch (state) {
case s_always_one: {
// Always consume the first character.
consumed = true;
state = s_whitespace;
break;
}
case s_whitespace: {
if (iswspace(c)) {
// Consumed whitespace.
consumed = true;
} else {
state = s_alphanumeric;
}
break;
}
case s_alphanumeric: {
if (iswalnum(c)) {
consumed = true; // consumed alphanumeric
} else {
state = s_end;
}
break;
}
case s_end:
default: { break; }
}
}
return consumed;
}
static int
pg_wc_isalnum(pg_wchar c)
{
switch (pg_regex_strategy)
{
case PG_REGEX_LOCALE_C:
return (c <= (pg_wchar) 127 &&
(pg_char_properties[c] & PG_ISALNUM));
case PG_REGEX_LOCALE_WIDE:
#ifdef USE_WIDE_UPPER_LOWER
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
return iswalnum((wint_t) c);
#endif
/* FALL THRU */
case PG_REGEX_LOCALE_1BYTE:
return (c <= (pg_wchar) UCHAR_MAX &&
isalnum((unsigned char) c));
case PG_REGEX_LOCALE_WIDE_L:
#if defined(HAVE_LOCALE_T) && defined(USE_WIDE_UPPER_LOWER)
if (sizeof(wchar_t) >= 4 || c <= (pg_wchar) 0xFFFF)
return iswalnum_l((wint_t) c, pg_regex_locale);
#endif
/* FALL THRU */
case PG_REGEX_LOCALE_1BYTE_L:
#ifdef HAVE_LOCALE_T
return (c <= (pg_wchar) UCHAR_MAX &&
isalnum_l((unsigned char) c, pg_regex_locale));
#endif
break;
}
return 0; /* can't get here, but keep compiler quiet */
}
/* The universal variable format has some funny escaping requirements; here we try to be safe */
static bool is_universal_safe_to_encode_directly(wchar_t c)
{
if (c < 32 || c > 128)
return false;
return iswalnum(c) || wcschr(L"/", c);
}
void
test1()
{
int i;
for (i = 0; i < 256; i++) {
printf(" %02x: ", i);
check_bool(isalnum(i), iswalnum(i), '1');
check_bool(isalpha(i), iswalpha(i), '2');
check_bool(isblank(i), iswblank(i), '3');
check_bool(iscntrl(i), iswcntrl(i), '4');
check_bool(isdigit(i), iswdigit(i), '5');
check_bool(isgraph(i), iswgraph(i), '6');
check_bool(islower(i), iswlower(i), '6');
check_bool(isprint(i), iswprint(i), '7');
check_bool(ispunct(i), iswpunct(i), '8');
check_bool(isspace(i), iswspace(i), '9');
check_bool(isupper(i), iswupper(i), 'a');
check_bool(isxdigit(i), iswxdigit(i), 'b');
check_value(tolower(i), towlower(i), 'c');
check_value(toupper(i), towupper(i), 'd');
if (i % 8 == 7)
printf("\n");
}
printf("%\n");
}
int
main ()
{
/* Check that the isw* functions exist as functions or as macros. */
(void) iswalnum (0);
(void) iswalpha (0);
#if 0 /* not portable: missing on mingw */
(void) iswblank (0);
#endif
(void) iswcntrl (0);
(void) iswdigit (0);
(void) iswgraph (0);
(void) iswlower (0);
(void) iswprint (0);
(void) iswpunct (0);
(void) iswspace (0);
(void) iswupper (0);
(void) iswxdigit (0);
/* Check that the isw* functions map WEOF to 0. */
ASSERT (!iswalnum (e));
ASSERT (!iswalpha (e));
#if 0 /* not portable: missing on mingw */
ASSERT (!iswblank (e));
#endif
ASSERT (!iswcntrl (e));
ASSERT (!iswdigit (e));
ASSERT (!iswgraph (e));
ASSERT (!iswlower (e));
ASSERT (!iswprint (e));
ASSERT (!iswpunct (e));
ASSERT (!iswspace (e));
ASSERT (!iswupper (e));
ASSERT (!iswxdigit (e));
/* Check that the tow* functions exist as functions or as macros. */
(void) towlower (0);
(void) towupper (0);
/* Check that the tow* functions map WEOF to WEOF. */
ASSERT (towlower (e) == e);
ASSERT (towupper (e) == e);
return 0;
}
/* Handler of Ctrl-W shortcut, which remove all to the left until beginning of
* the word is found (i.e. until first delimiter character). */
static void
cmd_ctrl_w(key_info_t key_info, keys_info_t *keys_info)
{
int old;
input_stat.history_search = HIST_NONE;
stop_completion();
old = input_stat.index;
while(input_stat.index > 0 && iswspace(input_stat.line[input_stat.index - 1]))
{
input_stat.curs_pos -= vifm_wcwidth(input_stat.line[input_stat.index - 1]);
input_stat.index--;
}
if(iswalnum(input_stat.line[input_stat.index - 1]))
{
while(input_stat.index > 0 &&
iswalnum(input_stat.line[input_stat.index - 1]))
{
const wchar_t curr_wchar = input_stat.line[input_stat.index - 1];
input_stat.curs_pos -= vifm_wcwidth(curr_wchar);
input_stat.index--;
}
}
else
{
while(input_stat.index > 0 &&
!iswalnum(input_stat.line[input_stat.index - 1]) &&
!iswspace(input_stat.line[input_stat.index - 1]))
{
const wchar_t curr_wchar = input_stat.line[input_stat.index - 1];
input_stat.curs_pos -= vifm_wcwidth(curr_wchar);
input_stat.index--;
}
}
if(input_stat.index != old)
{
wcsdel(input_stat.line, input_stat.index + 1, old - input_stat.index);
input_stat.len -= old - input_stat.index;
}
update_cmdline_text();
}
/* Might this line be a mail header?
* We deem a line to be a possible header if it matches the
* Perl regexp /^[A-Z][-A-Za-z0-9]*:\s/. This is *not* the same
* as in RFC whatever-number-it-is; we want to be gratuitously
* conservative to avoid mangling ordinary civilised text.
*/
static int
might_be_header(const wchar_t *line)
{
if (!iswupper(*line++))
return 0;
while (*line && (iswalnum(*line) || *line == '-'))
++line;
return (*line == ':' && iswspace(line[1]));
}
/**
checks to see if we have a character that sapi is not friendly with.
Currently we just filter spaces, punctuation and quote markers.
This routine will probably need tweeking. I've worked it to just
return false for alpha-numeric and true for everything else, but
I got a little paranoid.
@param - [in] character
@retval - true if its dirty.
**/
bool sapi_textbased_lipsync::is_dirty_char(wchar_t in)
{
if (iswspace(in) || (iswpunct(in) && in != L'\''))
return (true);
return (false);
if (iswalnum(in))
return (false);
return (true);
}
/* cv__isword():
* Return if p is part of a word according to vi
*/
libedit_private int
cv__isword(wint_t p)
{
if (iswalnum(p) || p == L'_')
return 1;
if (iswgraph(p))
return 2;
return 0;
}
int iswpunct_l(wint_t c, struct __locale_t *locale)
{
/* Silence warning */
_CRT_UNUSED(locale);
/* We're using a locale-independent representation of upper/lower case
based on Unicode data. Thus, the locale doesn't matter. */
return !iswalnum (c) && iswgraph (c);
}
static inline char chType(wchar_t c)
{
if (iswspace(c))
return 1;
else if (iswalnum(c) || c == '_')
return 2;
else
return 0;
}
