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] = ' ';
}
}
}
