/***************************************************************************** * CkBracketType: * checks /citation=([1],[3]) * May be we should check for only single value here like * /citation=[digit] * -Tatiana 1/28/95 ******************************************************************************/ NLM_EXTERN CharPtr CkBracketType(CharPtr str) { if (str == NULL) return "NULL value"; if (*str == '[') { str++; if (!IS_DIGIT(*str)) { return str; } else { while (IS_DIGIT(*str)) { str++; } if (*str != ']') { return str; } str++; if (*str != '\0') { return str; } return NULL; } } else { return str; } }
static int cmp(const void *a, const void *b) { char *da = NULL; char *db = NULL; const char *ca = r_str_trim_ro (a); const char *cb = r_str_trim_ro (b); if (!a || !b) { return (int) (size_t) ((char*) a - (char*) b); } if (sorted_column > 0) { da = strdup (ca); db = strdup (cb); int colsa = r_str_word_set0 (da); int colsb = r_str_word_set0 (db); ca = (colsa > sorted_column)? r_str_word_get0 (da, sorted_column): ""; cb = (colsb > sorted_column)? r_str_word_get0 (db, sorted_column): ""; } if (IS_DIGIT (*ca) && IS_DIGIT (*cb)) { ut64 na = r_num_get (NULL, ca); ut64 nb = r_num_get (NULL, cb); int ret = na > nb; free (da); free (db); return ret; } if (da && db) { int ret = strcmp (ca, cb); free (da); free (db); return ret; } free (da); free (db); return strcmp (a, b); }
static bool check_number(const char* str, size_t len) { char num_type = 0; int stat = 0; for (size_t i = 0; i < len; i++) { if ('<' == str[i] || '>' == str[i]) { if (0 != stat) return false; stat = '<'; } else if ('$' == str[i] || 'O' == str[i] || '%' == str[i]) { if ('$' == stat || '0' == stat) return false; num_type = str[i]; stat = '$'; } else if (IS_DIGIT(str[i])) { if (('%' == num_type) && ('0' != str[i] && '1' != str[i])) return false; else if (('O' == num_type) && !IS_DIGIT(str[i])) return false; stat = '0'; } else if ('A' <= str[i] && 'F' >= str[i]) { if ('$' != num_type) return false; stat = '0'; } else { break; } } return '0' == stat; }
int fast_atoi(const std::string & src) { if (src.empty()) return 0; const char * p = &src[0]; const char * end = p + src.size(); int value = 0; int sign = 1; while (IS_WHITESPACE(*p) || *p == '0') { INCREMENT_PTR(); } switch (*p) { case '-': sign = -1; INCREMENT_PTR(); break; case '+': INCREMENT_PTR(); break; default: break; } while (IS_DIGIT(*p)) { value = value * 10 + (*p - '0'); INCREMENT_PTR(); } parse_end: return value * sign; }
// convert hexadecimal string to unsigned integer char *hatoui(char *first, char *last, unsigned int *out) { unsigned int result = 0; for (; first != last; ++first) { int digit; if (IS_DIGIT(*first)) { digit = *first - '0'; } else if (*first >= 'a' && *first <= 'f') { digit = *first - 'a' + 10; } else if (*first >= 'A' && *first <= 'F') { digit = *first - 'A' + 10; } else { break; } result = 16 * result + digit; } *out = result; return first; }
static bool is_valid_project_name(const char *name) { int i; if (r_str_endswith (name, ".zip")) { return false; } for (i = 0; name[i]; i++) { switch (name[i]) { case '\\': // for w32 case '.': case '_': case ':': case '-': continue; } if (name[i] >= 'a' && name[i] <= 'z') { continue; } if (name[i] >= 'A' && name[i] <= 'Z') { continue; } if (IS_DIGIT (name[i])) { continue; } return false; } return true; }
static char * dir_ConvertDescriptionToPrefName(DIR_Server * server) { #define MAX_PREF_NAME_SIZE 25 char * fileName = nsnull; char fileNameBuf[MAX_PREF_NAME_SIZE]; PRInt32 srcIndex = 0; PRInt32 destIndex = 0; PRInt32 numSrcBytes = 0; const char * descr = nsnull; if (server && server->description) { descr = server->description; numSrcBytes = PL_strlen(descr); while (srcIndex < numSrcBytes && destIndex < MAX_PREF_NAME_SIZE-1) { if (IS_DIGIT(descr[srcIndex]) || IS_ALPHA(descr[srcIndex])) { fileNameBuf[destIndex] = descr[srcIndex]; destIndex++; } srcIndex++; } fileNameBuf[destIndex] = '\0'; /* zero out the last character */ } if (destIndex) /* have at least one character in the file name? */ fileName = strdup(fileNameBuf); return fileName; }
util::number::parse_result util::number::parse(const void* buf, size_t len, uint32_t& n, uint32_t min, uint32_t max) { if (len == 0) { return PARSE_ERROR; } const unsigned char* ptr = (const unsigned char*) buf; const unsigned char* end = ptr + len; n = 0; while (ptr < end) { unsigned char c = *ptr++; if (!IS_DIGIT(c)) { return PARSE_ERROR; } uint32_t tmp = (n * 10) + (c - '0'); // Overflow? if (tmp < n) { return PARSE_ERROR; } n = tmp; } if (n < min) { return PARSE_UNDERFLOW; } else if (n > max) { return PARSE_OVERFLOW; } return PARSE_SUCCEEDED; }
/*************************************************************************** * CkQualEcnum: * -- Ec_num has text format, * but the text only allow digits, period, and hyphen (-) * 12-10-93 ****************************************************************************/ NLM_EXTERN int CkQualEcnum( GBQualPtr PNTR head_gbqp, GBQualPtr gbqp, GBQualPtr preq, Boolean error_msgs, Boolean perform_corrections ) { CharPtr str; int retval = GB_FEAT_ERR_NONE; retval = CkQualText(head_gbqp, gbqp, preq, NULL, FALSE, error_msgs, perform_corrections); if (retval == GB_FEAT_ERR_NONE){ str = gbqp->val; /* open double quote */ while (*str != '\0' && (*str == ' ' || *str == '\"')) str++; for (; *str != '\0' && *str != '\"'; str++) if (!IS_DIGIT(*str) && *str != '.' && *str != '-') { if (error_msgs){ ErrPostEx(SEV_ERROR, ERR_QUALIFIER_BadECnum, "At <%c>(%d) /%s=%s", *str, (int) *str, gbqp->qual,gbqp->val); } retval = GB_FEAT_ERR_DROP; if (perform_corrections){ DeleteGBQualFromList(head_gbqp, gbqp, preq); } break; } } return retval; } /* CkQualEcnum */
// convert string to integer char *atoi(char *first, char *last, int *out) { int sign = 1; if (first != last) { if (*first == '-') { sign = -1; ++first; } else if (*first == '+') { ++first; } } int result = 0; for (; first != last && IS_DIGIT(*first); ++first) { result = 10 * result + (*first - '0'); } *out = result * sign; return first; }
number::parse_result_t number::parse_size_t(const char* string, size_t len, size_t& n, size_t min, size_t max) { if (len == 0) { return PARSE_ERROR; } const char* end = string + len; n = 0; while (string < end) { unsigned char c = (unsigned char) *string++; if (!IS_DIGIT(c)) { return PARSE_ERROR; } size_t tmp = (n * 10) + (c - '0'); // Overflow? if (tmp < n) { return PARSE_ERROR; } n = tmp; } if (n < min) { return PARSE_UNDERFLOW; } else if (n > max) { return PARSE_OVERFLOW; } return PARSE_SUCCEEDED; }
static int cin_get_num(RNum *num, RNumCalc *nc, RNumCalcValue *n) { double d; char str[R_NUMCALC_STRSZ]; // TODO: move into the heap? int i = 0; char c; str[0] = 0; while (cin_get (num, nc, &c)) { if (c != '_' && c!=':' && c!='.' && !isalnum ((ut8)c)) { cin_putback (num, nc, c); break; } if (i < R_NUMCALC_STRSZ) { str[i++] = c; } } str[i] = 0; *n = Nset (r_num_get (num, str)); if (IS_DIGIT (*str) && strchr (str, '.')) { if (sscanf (str, "%lf", &d) < 1) { return 0; } if (n->n < d) { *n = Nsetf (d); } n->d = d; } return 1; }
R_API char *r_hex_from_py_array(char *out, const char *code) { const char abc[] = "0123456789abcdef"; if (*code != '[' || !strchr (code, ']')) { return NULL; } code++; for (; *code; code++) { char *comma = strchr (code, ','); if (!comma) { comma = strchr (code, ']'); } if (!comma) { break; } char * _word = r_str_ndup (code, comma - code); const char *word = _word; while (*word == ' ' || *word == '\t' || *word == '\n') { word++; word = skip_comment_py (word); } if (IS_DIGIT (*word)) { ut8 n = (ut8)r_num_math (NULL, word); *out++ = abc[(n >> 4) & 0xf]; *out++ = abc[n & 0xf]; } free (_word); code = comma; if (*code == ']') { break; } }
int myatoi(const char *str) { int integer = 0; const char * p = str; int flag = 1; switch (*p) { case '+': p ++; break; case '-': flag = -1; p ++; break; default: break; } for (; '\0' != *p && IS_DIGIT(*p); p ++) { integer *= 10; integer += *p - '0'; } return flag > 0 ? integer : -integer; }
char * chxj_url_encode(apr_pool_t *pool, const char *src) { char *dst; register char *sp = (char *)src; int len; register int pos; if (! src) return apr_pstrdup(pool, "\0"); len = strlen(src) * 3 + 1; dst = apr_palloc(pool, len); memset(dst, 0, len); pos = 0; while(*sp) { if (IS_ALPHA_UPPER(*sp) || IS_ALPHA_LOWER(*sp) || IS_DIGIT(*sp)) { dst[pos++] = *sp++; continue; } if (*sp == ' ') { dst[pos++] = '+'; sp++; continue; } dst[pos++] = '%'; dst[pos++] = TO_HEXSTRING((*sp >> 4) & 0x0f); dst[pos++] = TO_HEXSTRING((*sp & 0x0f)); sp++; } return dst; }
static xmlChar * xmlPatScanNCName(xmlPatParserContextPtr ctxt) { const xmlChar *q, *cur; xmlChar *ret = NULL; int val, len; SKIP_BLANKS; cur = q = CUR_PTR; val = xmlStringCurrentChar(NULL, cur, &len); if (!IS_LETTER(val) && (val != '_')) return(NULL); while ((IS_LETTER(val)) || (IS_DIGIT(val)) || (val == '.') || (val == '-') || (val == '_') || (IS_COMBINING(val)) || (IS_EXTENDER(val))) { cur += len; val = xmlStringCurrentChar(NULL, cur, &len); } ret = xmlStrndup(q, cur - q); CUR_PTR = cur; return(ret); }
/*---------------------------------------------------------------------------*/ int getHostAddress (struct sockaddr_in *sin, const char *hostName, short port) { struct hostent * hostent; sin->sin_family = AF_INET; sin->sin_port = htons(port); // first try the name as a numbered IP address if (IS_DIGIT(hostName[0])) { char testStr[16]; webc_str_to_ip((unsigned char *) &sin->sin_addr, hostName); // do a check to make sure we translated an IP address webc_ip_to_str(testStr, (unsigned char *) &sin->sin_addr); if (!strcmp(hostName, testStr)) { // if we go from string to ip addr and back, without // changing the host name, this is success. return(0); } } // try looking up the name via DNS if ((hostent = gethostbyname(hostName))) { memcpy((unsigned char *) &sin->sin_addr, (unsigned char *) hostent->h_addr, 4); return(0); } return (-1); }
/* * [RFC5234] * DIGIT = %x30-39 * ; 0-9 */ int XSkip_digitBlock(const char *head, const char *tail, const char **nextp) { const char *p; for (p = head; p < tail && IS_DIGIT(*p); ++p); *nextp = p; return *nextp - head; } // end function : XSkip_digitBlock
/***************************************************************************** * CkLabelType: * checks /label=,feature_label> or /label=<base_range> * -Tatiana 1/28/95 ******************************************************************************/ NLM_EXTERN CharPtr CkLabelType(CharPtr str) { Boolean range = TRUE, label = TRUE; CharPtr bptr; if (IS_DIGIT(*str)) { for (; IS_DIGIT(*str); str++) continue; if (*str == '.' && *(str+1) == '.') { str += 2; if (!IS_DIGIT(*str)) { range = FALSE; } else { while (IS_DIGIT(*str)) { str++; } } if (*str != '\0') { range = FALSE; } } else { range = FALSE; } } if (!range) { bptr = str; for (; *str != '\0' && !IS_ALPHA(*str); str++) continue; if (*str == '\0') { label = FALSE; /* must be at least one letter */ } for (str = bptr; *str != '\0' && IS_ALPHA(*str) || IS_DIGIT(*str) || *str == '-' || *str == '_' || *str == '\'' || *str == '*'; str++) continue; if (*str != '\0') { label = FALSE; } } if (range || label) { return NULL; } else { return str; } }
static Nlm_Uint8 s_StringToUint8(const char *str, const char **endptr, int *sgn) { int sign = 0; /* actual sign */ Nlm_Uint8 limdiv, limoff, result; const char *s, *save; char c; /* assume error */ *endptr = 0; if (!str) return 0; s = str; while (IS_WHITESP(*s)) s++; /* empty string - error */ if (*s == '\0') return 0; if (*sgn == 1) { if (*s == '-') { sign = 1; s++; } else if (*s == '+') { s++; } } save = s; limdiv = UINT8_MAX / 10; limoff = UINT8_MAX % 10; result = 0; for (c = *s; c; c = *++s) { if (!IS_DIGIT(c)) { break; } c -= '0'; if (result > limdiv || (result == limdiv && c > limoff)) { /* overflow */ return 0; } result *= 10; result += c; } /* there was no conversion - error */ if (save == s) return 0; *sgn = sign; *endptr = s; return result; }
/* int c; ret = hex_to_byte(&c, 'c'); */ R_API int r_hex_to_byte(ut8 *val, ut8 c) { if (IS_DIGIT(c)) { *val = (ut8)(*val) * 16 + (c - '0'); } else if (c >= 'A' && c <= 'F') { *val = (ut8)(*val) * 16 + (c - 'A' + 10); } else if (c >= 'a' && c <= 'f') { *val = (ut8)(*val) * 16 + (c - 'a' + 10); } else { return 1; } return 0; }
static t_bool is_nbr(const char *str) { int idx; if (!(str)) return (FALSE); str += (*str == SIGN_CHAR) ? (1) : (0); idx = 0; while (str[idx] && IS_DIGIT(str[idx])) ++idx; return (((idx == NULL_VALUE) || (str[idx])) ? (FALSE) : (TRUE)); }
static struct portlist * make_portlist(Str port) { struct portlist *first = NULL, *pl; char *p; Str tmp = Strnew(); p = port->ptr; while (*p) { while (*p && !IS_DIGIT(*p)) p++; Strclear(tmp); while (*p && IS_DIGIT(*p)) Strcat_char(tmp, *(p++)); if (tmp->length == 0) break; pl = New(struct portlist); pl->port = atoi(tmp->ptr); pl->next = first; first = pl; } return first; }
static int toLength(char *oval, int *len) { int w; if (!IS_DIGIT(oval[0])) return 0; w = atoi(oval); if (w < 0) return 0; if (w == 0) w = 1; if (oval[strlen(oval) - 1] == '%') *len = -w; else *len = w; return 1; }
/* * Convert a string into a valid C identifier by replacing invalid * characters with '_'. Also makes sure the string is nul-terminated * and takes up at most n bytes. */ void strident_canon(char *s, size_t n) { char c; char *end = s + n - 1; if ((c = *s) == 0) return; if (!IS_ALPHA(c) && c != '_') *s = '_'; while (s < end && ((c = *(++s)) != 0)) { if (!IS_ALPHA(c) && !IS_DIGIT(c) && c != '_') *s = '_'; } *s = 0; }
static int is_valid_ident(const char *s, const char *e, int allowdot) { char c; if (s >= e) return (0); /* name is empty */ c = *s++; if (!IS_ALPHA(c)) return (0); /* does not start with letter */ while (s < e && (c = *s++) != 0) { if (IS_ALPHA(c) || IS_DIGIT(c) || c == '-' || c == '_' || (allowdot && c == '.')) continue; return (0); /* invalid character */ } return (1); }
/* * [RFC2821] * address-literal = "[" IPv4-address-literal / * IPv6-address-literal / * General-address-literal "]" * IPv4-address-literal = Snum 3("." Snum) * IPv6-address-literal = "IPv6:" IPv6-addr * General-address-literal = Standardized-tag ":" 1*dcontent * Standardized-tag = Ldh-str * ; MUST be specified in a standards-track RFC * ; and registered with IANA * * Snum = 1*3DIGIT ; representing a decimal integer * ; value in the range 0 through 255 * Let-dig = ALPHA / DIGIT * Ldh-str = *( ALPHA / DIGIT / "-" ) Let-dig * * IPv6-addr = IPv6-full / IPv6-comp / IPv6v4-full / IPv6v4-comp * IPv6-hex = 1*4HEXDIG * IPv6-full = IPv6-hex 7(":" IPv6-hex) * IPv6-comp = [IPv6-hex *5(":" IPv6-hex)] "::" [IPv6-hex *5(":" * IPv6-hex)] * ; The "::" represents at least 2 16-bit groups of zeros * ; No more than 6 groups in addition to the "::" may be * ; present * IPv6v4-full = IPv6-hex 5(":" IPv6-hex) ":" IPv4-address-literal * IPv6v4-comp = [IPv6-hex *3(":" IPv6-hex)] "::" * [IPv6-hex *3(":" IPv6-hex) ":"] IPv4-address-literal * ; The "::" represents at least 2 16-bit groups of zeros * ; No more than 4 groups in addition to the "::" and * ; IPv4-address-literal may be present */ static int XSkip_addressLiteral(const char *head, const char *tail, const char **nextp) { const char *p = head; *nextp = p; // 全体がマッチしない限りマッチしない if (tail <= p || *p != '[') { return *nextp - head; } // end if // NOTE: 文字種のチェックしかおこなっていない for (++p; p < tail && (IS_DIGIT(*p) || *p == ':' || *p == '.'); ++p); if (tail <= p || *p != ']') { return *nextp - head; } // end if *nextp = p + 1; return *nextp - head; } // end function : XSkip_addressLiteral
static Str ftp_command(FTP ftp, char *cmd, char *arg, int *status) { Str tmp; if (!ftp->host) return NULL; if (cmd) { if (arg) tmp = Sprintf("%s %s\r\n", cmd, arg); else tmp = Sprintf("%s\r\n", cmd); fwrite(tmp->ptr, sizeof(char), tmp->length, ftp->wf); fflush(ftp->wf); } if (!status) return NULL; *status = -1; /* error */ tmp = StrISgets(ftp->rf); if (IS_DIGIT(tmp->ptr[0]) && IS_DIGIT(tmp->ptr[1]) && IS_DIGIT(tmp->ptr[2]) && tmp->ptr[3] == ' ') sscanf(tmp->ptr, "%d", status); if (tmp->ptr[3] != '-') return tmp; /* RFC959 4.2 FTP REPLIES */ /* multi-line response start */ /* * Thus the format for multi-line replies is that the * first line will begin with the exact required reply * code, followed immediately by a Hyphen, "-" (also known * as Minus), followed by text. The last line will begin * with the same code, followed immediately by Space <SP>, * optionally some text, and the Telnet end-of-line code. */ while (1) { tmp = StrISgets(ftp->rf); if (IS_DIGIT(tmp->ptr[0]) && IS_DIGIT(tmp->ptr[1]) && IS_DIGIT(tmp->ptr[2]) && tmp->ptr[3] == ' ') { sscanf(tmp->ptr, "%d", status); break; } } return tmp; }
int myatoi(char *s) { int x; /* the number */ int base; /* number base */ int neg = FALSE; #define IS_DIGIT(c) (((c >= '0') && (c <= ((base==8) ? '7' : '9'))) || \ ((base==16) && (c >= 'a') && (c <= 'f'))) if (*s=='-') { neg = TRUE; s++; } if (*s=='0') { s++; if (*s=='x') { /* 0x<hex number> */ s++; base = 16; } else base = 8; /* 0<octal number> */ } else base = 10; /* <decimal number> */ x = 0; while (IS_DIGIT(tolower(*s))) { /* work through the string */ x *= base; x += VALUE(tolower(*s)); s++; } return neg ? -x : x; }
unsigned char * webc_str_to_ip(unsigned char * ipaddr, const char * ipstr) { int n, i; tc_memset(ipaddr, 0, 4); for (n=0, i=0; ipstr[n] && i<4; n++) { if (IS_DIGIT(ipstr[n])) { ipaddr[i] = (ipaddr[i] * 10) + (ipstr[n] - '0'); } else if (ipstr[n] == '.') { i++; } else { break; } } return (ipaddr); }