BOOL __costume_internal_if_factor(const pcostumex cxlist)
{
BOOL ret = 0;
if(*_costume_ict == '(') {
_costume_ict++;
ret = __costume_internal_if_and_or(cxlist);
_costume_ict++;
} else if (_isnumeric(*_costume_ict)) {
if(*_costume_ict == '0') {
if(*++_costume_ict == 'x') { // only lower
_costume_ict++;
while(TRUE) {
if(_isnumeric(*_costume_ict)) {
ret = ret * 16 + *_costume_ict - '0';
_costume_ict++;
} else if (_isalpha(*_costume_ict)) {
ret = ret * 16 + _to_lower(*_costume_ict) - 'a';
_costume_ict++;
} else {
break;
}
}
} else {
while(_isnumeric(*_costume_ict)) {
ret = ret * 8 + *_costume_ict++ - '0';
}
}
} else {
while(_isnumeric(*_costume_ict)) {
ret = ret * 10 + *_costume_ict++ - '0';
}
}
} else if (_isalpha(*_costume_ict) || *_costume_ict == '_') {
char _temp[20] = {0,}; // find temp
int count;
pcostumex tmp;
for (count = 0; _isalnumub((int)(*_costume_ict)); _costume_ict++, count++)
_temp[count] = *_costume_ict;
_temp[count] = 0;
if (NULL == (tmp = _costume_find_variable(cxlist, _temp)))
return -1; // error
ret = (BOOL)tmp->data;
}
return ret;
}
int isalpha(int c) {
#if !CAM_DRYOS
return _isalpha(c);
#else
return _ctype(c,(_U|_L));
#endif
}
unsigned long _strtoul_t(
const char *nptr,
char **endptr,
register int base
)
{
register const char *s = nptr;
register unsigned long acc;
register int c;
register unsigned long cutoff;
register int neg = 0, any, cutlim;
do {
c = *s++;
} while (_isspace(c));
if (c == '-') {
neg = 1;
c = *s++;
} else if (c == '+')
c = *s++;
if ((base == 0 || base == 16) &&
c == '0' && (*s == 'x' || *s == 'X')) {
c = s[1];
s += 2;
base = 16;
}
if (base == 0)
base = c == '0' ? 8 : 10;
cutoff = neg ? (~((unsigned long)_LONG_MIN)+1) : _LONG_MAX;
cutlim = cutoff % (unsigned long)base;
cutoff /= (unsigned long)base;
for (acc = 0, any = 0;; c = *s++) {
if (_isdigit(c))
c -= '0';
else if (_isalpha(c))
c -= _to_upper(c) & 0xf + 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 = neg ? _LONG_MIN : _LONG_MAX;
} else if (neg)
acc = ~acc+1;
if (endptr != 0)
*endptr = (char *) (any ? s - 1 : nptr);
return (acc);
}
int _isalnum(
int ch
)
{
int ret = 0;
if (_isalpha(ch) || _isdigit(ch))
ret = ch;
return ret;
}
static int _fetch_string_values( struct strset *s, const char **out, int max ) {
void *cookie;
const char *v;
int n = 0;
if( set_iter( s, &cookie ) ) {
while( n < max && set_next( s, &cookie, &v ) ) {
if( _isalpha( v ) ) {
out[ n++ ] = v;
}
}
}
return n;
}
static unsigned long _strtoxl_asc(
const char *nptr,
char **endptr,
register int base,
int flags
)
{
register const char *n_ptr = nptr;
register char c;
register unsigned long number = 0;
register unsigned digval;
register unsigned long maxval;
c = *n_ptr++;
while (_isspace(*n_ptr))
c = *n_ptr++;
if (c == '-') {
flags |= FL_NEG;
c = *n_ptr++;
}
else if(c == '+')
c = *n_ptr++;
if(base < 0 || base > 36 || base == 1) {
if (endptr)
*endptr = nptr;
return 0L;
} else if(base == 0) {
if (c != '0')
base = 10;
else if (*n_ptr == 'x' || *n_ptr == 'X')
base = 16;
else
base = 8;
} else if (base == 16) {
if (c == '0' && (*n_ptr == 'x' || *n_ptr == 'X')) {
++n_ptr;
c = *n_ptr++;
}
}
maxval = _ULONG_MAX / base;
for (;;) {
if (_isdigit((int)(unsigned char)c))
digval = c - '0';
else if (_isalpha((int)(unsigned char)c))
digval = _to_upper(c) & 0xf + 10;
else
break;
if (digval >= (unsigned)base) break;
flags |= FL_READDIGIT;
if (number < maxval || (number == maxval
&& (unsigned long)digval <= _ULONG_MAX %base)) {
number = number * base + digval;
} else {
flags |= FL_OVERFLOW;
if (endptr == _NULL)
break;
}
c = *n_ptr++;
}
--n_ptr;
if (!(flags & FL_READDIGIT))
{
if (endptr)
n_ptr = nptr;
number = 0L;
}
else if ((flags & FL_OVERFLOW) ||
(!(flags & FL_UNSIGNED) &&
(((flags & FL_NEG) && (number > -_LONG_MIN)) ||
(!(flags & FL_NEG) && (number > _LONG_MAX)))))
{
if (flags & FL_UNSIGNED)
number = _ULONG_MAX;
else if (flags & FL_NEG)
number = (unsigned long)(-_LONG_MIN);
else
number = _LONG_MAX;
}
if (endptr != _NULL)
*endptr = n_ptr;
if (flags & FL_NEG)
number = (unsigned long)(-(long)number);
return number;
}
int _isnalpha(
int ch
)
{
return !_isalpha(ch);
}
int isalpha(int c) {
return _isalpha(c);
}
_CODE_ACCESS int isalpha(int c)
{
return(_isalpha(c));
}
_CODE_ACCESS int iswalpha(wint_t c)
{ return (c == WEOF || (char)c != c) ? 0 : _isalpha((char)c); }
