void process_char(uint8 c){ if(c=='\n' || c == '\r'){ if(keylen>0) process_keyvalue(); keylen = valuelen = 0; state = STATE_WAITING_KEY; }else{ if(state == STATE_WAITING_KEY){ if(c=='#'){ state = STATE_IN_COMMENT; }else if(is_alpha(c)){ key[keylen++] = c; state = STATE_IN_KEY; } }else if(state == STATE_IN_KEY){ if(is_alpha(c)){ if(keylen<sizeof(key)) key[keylen++] = c; }else{ state = STATE_WAITING_VALUE; valuelen = 0; } }else if(state == STATE_WAITING_VALUE){ if(is_alpha(c)){ value[valuelen++] = c; state = STATE_IN_VALUE; } }else if(state == STATE_IN_VALUE){ if(valuelen<sizeof(value)) value[valuelen++] = c; } } }
int main(void){ for(char i = 'a'; i <= 'z'; ++i){ assert(is_alpha(i)); assert(!is_digit(i)); assert(is_lower(i)); assert(!is_upper(i)); assert(to_lower(i) == i); assert(to_upper(i) != i); } for(char i = 'A'; i <= 'Z'; ++i){ assert(is_alpha(i)); assert(!is_digit(i)); assert(!is_lower(i)); assert(is_upper(i)); assert(to_lower(i) != i); assert(to_upper(i) == i); } for(char i = '0'; i <= '9'; ++i){ assert(!is_alpha(i)); assert(is_digit(i)); assert(!is_lower(i)); assert(!is_upper(i)); assert(to_lower(i) == i); assert(to_upper(i) == i); } printf("TEST SUCEEDED\n"); return 0; }
string pick_up_word(string& word) { string tmp = word; string::size_type len = word.length(); if(!is_alpha(word[0])) { string tmpword(word,1,len-1); tmp = tmpword; } for(string::size_type i = 0; i < tmp.length(); ++i) { if(!is_alpha(tmp[i])) { string tmpword(tmp,0,i); tmp = tmpword; break; } else if(!islower(tmp[i])) { tmp[i] = tolower(tmp[i]); } } word = tmp; return tmp; }
void process_char(uint8 c){ static char uart_str[50]; if(c=='\n' || c == '\r'){ if(keylen>0){ uint8 ret = process_keyvalue(); if(ret == 0){ UART_Print("Read "); for(uint8 i=0;i<keylen;i++){ UART_Print(key[i]); } UART_Print(" "); for(uint8 i=0;i<valuelen;i++){ UART_Print(value[i]); } UART_Print("\n\r"); }else if(ret==1){ UART_Print("Unrecognised key: \""); for(uint8 i=0;i<keylen;i++){ UART_Print(key[i]); } UART_Print("\"\n\r"); }else if(ret==2){ UART_Print("Expected value after key: \""); for(uint8 i=0;i<keylen;i++){ UART_Print(key[i]); } UART_Print("\"\n\r"); } } keylen = valuelen = 0; state = STATE_WAITING_KEY; }else{ if(state == STATE_WAITING_KEY){ if(c=='#'){ state = STATE_IN_COMMENT; }else if(is_alpha(c)){ key[keylen++] = c; state = STATE_IN_KEY; } }else if(state == STATE_IN_KEY){ if(is_alpha(c)){ if(keylen<sizeof(key)) key[keylen++] = c; }else{ state = STATE_WAITING_VALUE; valuelen = 0; } }else if(state == STATE_WAITING_VALUE){ if(is_alpha(c)){ value[valuelen++] = c; state = STATE_IN_VALUE; } }else if(state == STATE_IN_VALUE){ if(valuelen<sizeof(value)) value[valuelen++] = c; } } }
// identifier = letter { letter | digit | '_' } static int parse_identifier(struct frozen *f) { EXPECT(is_alpha(cur(f)), JSON_STRING_INVALID); TRY(capture_ptr(f, f->cur, JSON_TYPE_STRING)); while (f->cur < f->end && (*f->cur == '_' || is_alpha(*f->cur) || is_digit(*f->cur))) { f->cur++; } capture_len(f, f->num_tokens - 1, f->cur); return 0; }
// выдает смещение, начиная с которого стоит знак морфологического словаря // если такого знака нет, то выдается -1 // [-+][:alpha:\?][:alpha:\?] int GetMorphSignPosition(const char* LineStr) { int LineLength= strlen(LineStr); for (int i = 0; i < LineLength - 3; i++) if( ( (LineStr [i] == '+') || (LineStr [i] == '-') || (LineStr [i] == '?')) && ( is_alpha((BYTE)LineStr [i+1]) || (LineStr [i+1] == '?') ) && ( is_alpha((BYTE)LineStr [i+2]) || (LineStr [i+2] == '?') ) ) return i; return -1; };
int NFAWordBoundaryUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const { int len = str.GetLength(); wchar_t c1 = (curInd - 1 < len && curInd > 0) ? str[curInd - 1] : '\n'; wchar_t c2 = (curInd < len) ? str[curInd] : '\n'; if (curInd == len) return next->match(str, matcher, curInd); bool ok = is_alpha(c1) != is_alpha(c2); if (ok && pos) return next->match(str, matcher, curInd); return -1; }
/* identifier = letter { letter | digit | '_' } */ static int parse_identifier(struct frozen *f) { EXPECT(is_alpha(cur(f)), JSON_STRING_INVALID); { SET_STATE(f, f->cur, JSON_TYPE_STRING, "", 0); while (f->cur < f->end && (*f->cur == '_' || is_alpha(*f->cur) || is_digit(*f->cur))) { f->cur++; } CALL_BACK(f); } return 0; }
int init_ptf_format(const char *format, int *i, t_ptf_format *ptf_format) { int flag_cp; int var_set; *i = *i + 1; var_set = 0; while (format && format[*i]) { init_flag(format[*i], &flag_cp, ptf_format, &var_set); skip_char(format, i, ' '); if (!init_field_width(format, i, &var_set, ptf_format)) return (0); init_precision(format, i, ptf_format); if (getchar_pos("hl", format[*i]) != -1) ptf_format->length_modifier = format[*i]; else if (is_alpha(format[*i], 0) || format[*i] == '%') { if (format[*i] == 'n' && (ptf_format->field_width = printf_my_itoa(g_prog.i)) == NULL) return (0); ptf_format->conv_char = format[*i]; return (1); } *i = *i + 1; } return (1); }
bool is_root_path(std::string const& f) { if (f.empty()) return false; #ifdef TORRENT_WINDOWS // match \\ form if (f == "\\\\") return true; int i = 0; // match the xx:\ or xx:/ form while (f[i] && is_alpha(f[i])) ++i; if (i == int(f.size()-2) && f[i] == ':' && (f[i+1] == '\\' || f[i+1] == '/')) return true; // match network paths \\computer_name\ form if (f.size() > 2 && f[0] == '\\' && f[1] == '\\') { // we don't care about the last character, since it's OK for it // to be a slash or a back slash bool found = false; for (int i = 2; i < f.size() - 1; ++i) { if (f[i] != '\\' && f[i] != '/') continue; // there is a directory separator in here, // i.e. this is not the root found = true; break; } if (!found) return true; } #else // as well as parent_path("/") should be "/". if (f == "/") return true; #endif return false; }
CSyntaxColorizer::CSyntaxColorizer() { for (int i = 0; i < 256; i++) Alphas[i] = is_alpha(i) || isdigit(i) || (i == '_'); ZeroMemory(&m_cfDefault,sizeof(m_cfDefault)); m_cfDefault.dwMask = CFM_CHARSET | CFM_FACE | CFM_SIZE | CFM_OFFSET | CFM_COLOR | CFM_BACKCOLOR; /* m_cfDefault.dwMask ^= CFM_ITALIC ^ CFM_BOLD ^ CFM_STRIKEOUT ^ CFM_UNDERLINE ^CFM_ANIMATION ^CFM_KERNING ^CFM_LCID ^CFM_REVAUTHOR ^CFM_SPACING ^CFM_STYLE ^CFM_UNDERLINETYPE ^CFM_WEIGHT; */ m_cfDefault.dwEffects = CFE_AUTOBACKCOLOR; m_cfDefault.yHeight = 200; //10pts * 20 twips/point = 200 twips m_cfDefault.bCharSet = ANSI_CHARSET; m_cfDefault.bPitchAndFamily = FIXED_PITCH | FF_MODERN; m_cfDefault.yOffset = 0; m_cfDefault.crTextColor = CLR_PLAIN; strcpy(m_cfDefault.szFaceName,"Courier New"); m_cfDefault.crBackColor = CLR_BKGRD; m_cfDefault.cbSize = sizeof(m_cfDefault); }
// Lexically analyze a single token. Token Lexer::scan() { while (!cs_.eof()) { space(); loc_ = cs_.location(); switch (cs_.peek()) { case '\0': return eof(); case '(': return symbol1(); case ')': return symbol1(); case '\\': return symbol1(); case '.': return symbol1(); case '=': return symbol1(); case ';': return symbol1(); default: // TODO: Unfold into cases. if (is_alpha(cs_.peek())) return identifier(); else error(); } } return {}; }
int cio_update_console(char c) { if (!is_number(c) && !is_alpha(c) && (c != 8) // backspace && (c != ' ') && (c != '\r') && (c != '\n')) { return E_FAIL; } if (c == 8) { if (command_buffer_idx > 0) { command_buffer_idx -= 1; } command_buffer[command_buffer_idx] = '\0'; } else if (c == COMMAND_CHAR_DONE_1) { cio_send_command(command_buffer, COMMAND_BUFFER_SIZE); cio_buffer_reset(); } else if (command_buffer_idx < COMMAND_BUFFER_SIZE) { command_buffer[command_buffer_idx++] = c; } pretty_print_command(command_buffer, COMMAND_BUFFER_SIZE); return SUCCESS; }
static bool start_ident (char c) { // Note: unlike Coq, we don't discriminate utf8 letters from symbols. See // http://coq.inria.fr/distrib/current/refman/Reference-Manual003.html#sec17 // for details. return is_alpha (c) || c == '_' || start_utf8_seq (c); }
token_type_t get_token(tokenizer_t* t) { if (t->token_value) { free(t->token_value); t->token_value = NULL; } eatwhitespace(t); stack_push(t->index_stack, &t->source_index); if ('\0' == t->source[t->source_index]) { t->token_type = TT_EOF; return TT_EOF; } if (is_digit(t->source[t->source_index])) { tokenize_number(t); return TT_NUMBER; } if (is_alpha(t->source[t->source_index])) { tokenize_identifier(t); return TT_IDENT; } if ('"' == t->source[t->source_index]) { tokenize_string(t); return TT_STRING; } return TT_UNKNOWN; }
float factor() { float value; float sign = 1.0; if (*look == '-') { sign = -1; } if (*look == '(') { match('('); value = expression(); match(')'); return value; } else if (is_alpha(*look)) { switch (*look) { case 'x': { value = env.x; } break; case 'y': { value = env.y; } break; } get_char(); skip_white(); } else { value = get_num(); } return sign*value; }
int is_valid_name(const char *token) { char c; c = token[0]; return c == '_' || is_alpha(c); }
static int get_cfg(void) { FILE *fp; int ret = 1; char buf[LINE_LENGTH] = {0}; memset(buf,0,sizeof(buf)); if((fp = fopen(I2C_DEVICE_CONFIG_PATH,"rb")) == NULL) { ALOGD("can't not open file!\n"); return 0; } while(fgets(buf, LINE_LENGTH , fp)){ #ifdef DEBUG ALOGD("buf:%s\n",buf); #endif if (!is_alpha(buf[0])){ if(!insmod_modules(buf)){ ALOGD("insmod fail !"); ret = 0; } } memset(buf,0,sizeof(buf)); } fclose(fp); return ret; }
static void abbrok(const char *const abbrp, const char *const zone) { const char *cp; const char *wp; if (warned) return; cp = abbrp; while (is_alpha(*cp) || is_digit(*cp) || *cp == '-' || *cp == '+') ++cp; if (cp - abbrp < 3) wp = _("has fewer than 3 characters"); else if (cp - abbrp > 6) wp = _("has more than 6 characters"); else if (*cp) wp = _("has characters other than ASCII alphanumerics, '-' or '+'"); else return; (void) fflush(stdout); (void) fprintf(stderr, _("%s: warning: zone \"%s\" abbreviation \"%s\" %s\n"), progname, zone, abbrp, wp); warned = errout = true; }
void my_put_pixel_img_wall(t_wolf *wo, int x, int y, t_wall *wall) { t_image *t; int i; t_f_point pw; int size_line; int ok; int omb; t_i_point pf; pf.x = x; pf.y = y; t = wall->texture; pw.x = (wall->y_shoot - (int)(wall->y_shoot)) * 512; if (wall->type_shoot == 2) pw.x = (wall->x_shoot - (int)(wall->x_shoot)) * 512; pw.y = y - ((WIDTH / 2) - wall->height_wall) + 100; pw.y = (512 / wall->height_wall) / 2 * pw.y; if (pw.y >= 512 || pw.y < 0) pw.y = 0; ok = is_alpha(&pw, wall, wo); i = 0; if (pf.y > 0 && ok == 0 && pf.x > 0 && pf.y < HEIGHT && pf.x < WIDTH) display_px(wall, &pw, wo, &pf); }
void parser_base::name(pstring& str) { size_t first = m_pos; char c = cur_char(); if (!is_alpha(c)) { ::std::ostringstream os; os << "name must begin with an alphabet, but got this instead '" << c << "'"; throw malformed_xml_error(os.str()); } while (is_alpha(c) || is_numeric(c) || is_name_char(c)) c = next_char_checked(); size_t size = m_pos - first; str = pstring(m_content+first, size); }
char get_name() { if (!is_alpha(*look)) expected("name"); char ret = *look; get_char(); skip_white(); return ret; }
Token Lexer::identifier() { letter(); while (is_alpha(cs_.peek())) letter(); return on_identifier(); }
size_t count_atom(buffer_reader *reader) { size_t size = 1; while(is_alpha(buffer_reader_read_rune(reader))) { size++; } return size; }
/** * squeeze (& strdup) */ char *sqzdup(const char *source) { char *rp, *p, *d; int lc = 0; rp = malloc(strlen(source) + 1); p = (char *) source; d = rp; while (*p != '\0' && is_wspace(*p)) p++; while (*p) { if (is_wspace(*p)) { if (!lc) { lc = 1; if (p > source) { if (is_alpha(*(p - 1)) || is_digit(*(p - 1))) *d++ = ' '; else { char *nc; nc = p; while (*nc != '\0' && is_wspace(*nc)) nc++; if (is_alpha(*nc) || is_digit(*nc) ) *d++ = ' '; } } } } else { (lc = 0, *d++ = *p); } p++; } *d = '\0'; if (d > rp) { if (is_wspace(*(d - 1))) { *(d - 1) = '\0'; } } return rp; }
void ReadOpeningSequences (short *pindex, const char* patternfile) { FILE *fd; char s[256]; short max_pattern = 0; short max_opening_sequence = 0; fd = fopen (patternfile, "r"); if (fd == NULL) { sprintf(s, "no pattern file '%s'", patternfile); dsp->ShowMessage(s); return; } *pindex = 0; while (fgets (s, 256, fd) != NULL) { if (*s == '#') { /* comment, skip line */ } else if (is_alpha(*s)) { if (max_opening_sequence++ > 0) { pattern_data[(*pindex)++] = END_OF_PATTERNS; } pattern_data[(*pindex)++] = ValueOfOpeningName(s); } else { if (ScanPattern(s, pindex)) { dsp->ShowMessage("error in pattern sequence..."); exit(1); } else { max_pattern++; } } } pattern_data[(*pindex)++] = END_OF_PATTERNS; pattern_data[(*pindex)++] = END_OF_SEQUENCES; sprintf(s, "Pattern: %d bytes for %d sequences with %d patterns.\n", *pindex, max_opening_sequence, max_pattern); dsp->ShowMessage(s); fclose(fd); }
int nbr_words(char *str) { int i; char *start; char *end; int nbr_words; nbr_words = 0; i = 0; start = get_next_alpha(str); while (i <= my_strlen(str)) { if (!is_alpha(str[i]) && is_alpha(str[i-1])) nbr_words = nbr_words + 1; i = i + 1; } return (nbr_words); }
char is_alphanum(char c) { char ret; ret = 0; if (is_num(c) == 1 || is_alpha(c) == 1) ret = 1; return (ret); }
// identifier = letter { letter | digit } static enum v7_err parse_identifier(struct v7 *v7) { CHECK(is_alpha(*v7->cursor) || *v7->cursor == '_', V7_SYNTAX_ERROR); v7->tok = v7->cursor; v7->cursor++; while (is_alnum(*v7->cursor) || *v7->cursor == '_') v7->cursor++; v7->tok_len = (unsigned long) (v7->cursor - v7->tok); skip_whitespaces_and_comments(v7); return V7_OK; }
void string_filter(char *str) { int i; for (i = 0; str[i]; i ++) { if (! is_alpha(str[i])) { str[i] = ' '; } } }