bool isAlAnd(char c) { return isAlpha(c) || isAnd(c); }
/* The lexer is in charge of reading the file. * Some of sub-lexer (like eatComment) also read file. * lexing is finished when the lexer return Tok_EOF */ static ocamlKeyword lex (lexingState * st) { int retType; /* handling data input here */ while (st->cp == NULL || st->cp[0] == '\0') { st->cp = fileReadLine (); if (st->cp == NULL) return Tok_EOF; } if (isAlpha (*st->cp)) { readIdentifier (st); retType = lookupKeyword (vStringValue (st->name), Lang_Ocaml); if (retType == -1) /* If it's not a keyword */ { return OcaIDENTIFIER; } else { return retType; } } else if (isNum (*st->cp)) return eatNumber (st); else if (isSpace (*st->cp)) { eatWhiteSpace (st); return lex (st); } /* OCaml permit the definition of our own operators * so here we check all the consecuting chars which * are operators to discard them. */ else if (isOperator[*st->cp]) return eatOperator (st); else switch (*st->cp) { case '(': if (st->cp[1] == '*') /* ergl, a comment */ { eatComment (st); return lex (st); } else { st->cp++; return Tok_PARL; } case ')': st->cp++; return Tok_PARR; case '[': st->cp++; return Tok_BRL; case ']': st->cp++; return Tok_BRR; case '{': st->cp++; return Tok_CurlL; case '}': st->cp++; return Tok_CurlR; case '\'': st->cp++; return Tok_Prime; case ',': st->cp++; return Tok_comma; case '=': st->cp++; return Tok_EQ; case ';': st->cp++; return Tok_semi; case '"': eatString (st); return Tok_Val; case '_': st->cp++; return Tok_Val; case '#': st->cp++; return Tok_Sharp; case '\\': st->cp++; return Tok_Backslash; default: st->cp++; break; } /* default return if nothing is recognized, * shouldn't happen, but at least, it will * be handled without destroying the parsing. */ return Tok_Val; }
/* Match one character. Doesn't modify txtIt, returns length of regexp char in *length */ bool matchcharacter(char *regexp, JsvStringIterator *txtIt, int *length, matchInfo *info) { *length = 1; char ch = jsvStringIteratorGetChar(txtIt); if (regexp[0]=='.') return true; if (regexp[0]=='[') { // Character set (any char inside '[]') info->rangeMatch = true; bool inverted = regexp[1]=='^'; if (inverted) (*length)++; bool matchAny = false; while (regexp[*length] && regexp[*length]!=']') { int matchLen; matchAny |= matchcharacter(®exp[*length], txtIt, &matchLen, info); (*length) += matchLen; } if (regexp[*length]==']') { (*length)++; } else { jsExceptionHere(JSET_ERROR, "Unfinished character set in RegEx"); return false; } info->rangeMatch = false; return matchAny != inverted; } char cH = regexp[0]; if (cH=='\\') { // escape character *length = 2; // fallback to the quoted character (e.g. /,-,? etc.) cH = regexp[1]; // missing quite a few here // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions if (cH=='d') return isNumeric(ch); if (cH=='D') return !isNumeric(ch); if (cH=='f') { cH=0x0C; goto haveCode; } if (cH=='n') { cH=0x0A; goto haveCode; } if (cH=='r') { cH=0x0D; goto haveCode; } if (cH=='s') return isWhitespace(ch); if (cH=='S') return !isWhitespace(ch); if (cH=='t') { cH=0x09; goto haveCode; } if (cH=='v') { cH=0x0B; goto haveCode; } if (cH=='w') return isNumeric(ch) || isAlpha(ch) || ch=='_'; if (cH=='W') return !(isNumeric(ch) || isAlpha(ch) || ch=='_'); if (cH>='0' && cH<='9') { cH-='0'; goto haveCode; } if (cH=='x' && regexp[2] && regexp[3]) { *length = 4; cH = (char)((chtod(regexp[2])<<4) | chtod(regexp[3])); goto haveCode; } } haveCode: if (info->rangeMatch && regexp[*length] == '-') { // Character set range start info->rangeFirstChar = cH; (*length)++; int matchLen; bool match = matchcharacter(®exp[*length], txtIt, &matchLen, info); (*length)+=matchLen; return match; } if (info->ignoreCase) { ch = jsvStringCharToLower(ch); cH = jsvStringCharToLower(cH); } if (info->rangeFirstChar != NO_RANGE) { // Character set range char cL = (char)info->rangeFirstChar; if (info->ignoreCase) { cL = jsvStringCharToLower(cL); } info->rangeFirstChar = NO_RANGE; return (ch >= cL && ch <= cH && cL < cH); } return cH==ch; }
int CommonLanguageAnalyzer::analyze_impl(const Term& input, void* data, HookType func) { parse(input.text_); unsigned char topAndOrBit = Term::AND; int tempOffset = 0; int lastWordOffset = -1; while (nextToken()) { if (len_ == 0) continue; if (bRemoveStopwords_ && isStopword()) continue; /* { UString foo(token_, len_); string bar; foo.convertString(bar, UString::UTF_8); cout << "(" << bar << ") --<> " << isIndex_ << "," << offset_ << "," << isRaw_ << "," << level_ << endl; }*/ if (bChinese_) { int curWordOffset = offset_; if (curWordOffset == lastWordOffset) topAndOrBit = Term::OR; else topAndOrBit = Term::AND; lastWordOffset = curWordOffset; } if (isIndex_) { if (isSpecialChar()) { func(data, token_, len_, offset_, Term::SpecialCharPOS, Term::AND, level_, true); tempOffset = offset_; continue; } if (isRaw_) { func(data, token_, len_, offset_, pos_, Term::OR, level_, false); tempOffset = offset_; continue; } // foreign language, e.g. English if (isAlpha()) { UString::CharT* lowercaseTermUstr = lowercase_ustring_buffer_; bool lowercaseIsDifferent = UString::toLowerString(token_, len_, lowercase_ustring_buffer_, term_ustring_buffer_limit_); char* lowercaseTerm = lowercase_string_buffer_; UString::convertString(UString::UTF_8, lowercaseTermUstr, len_, lowercase_string_buffer_, term_string_buffer_limit_); UString::CharT* stemmingTermUstr = NULL; size_t stemmingTermUstrSize = 0; UString::CharT * synonymResultUstr = NULL; size_t synonymResultUstrLen = 0; if (bExtractEngStem_) { /// TODO: write a UCS2 based stemmer string stem_term; pStemmer_->stem(lowercaseTerm, stem_term); if (strcmp(stem_term.c_str(), lowercaseTerm)) { stemmingTermUstr = stemming_ustring_buffer_; stemmingTermUstrSize = UString::toUcs2(UString::UTF_8, stem_term.c_str(), stem_term.size(), stemming_ustring_buffer_, term_ustring_buffer_limit_); } } // if (false /*bExtractSynonym_, preprocessed*/) // { // pSynonymContainer_ = uscSPtr_->getSynonymContainer(); // pSynonymContainer_->searchNgetSynonym(lowercaseTerm, pSynonymResult_); // char * synonymResult = pSynonymResult_->getHeadWord(0); // if (synonymResult) // { // size_t synonymResultLen = strlen(synonymResult); // if (synonymResultLen <= term_ustring_buffer_limit_) // { // synonymResultUstr = synonym_ustring_buffer_; // synonymResultUstrLen = UString::toUcs2(synonymEncode_, // synonymResult, synonymResultLen, synonym_ustring_buffer_, term_ustring_buffer_limit_); // } // } // } if (stemmingTermUstr || synonymResultUstr || (bCaseSensitive_ && bContainLower_ && lowercaseIsDifferent)) { /// have more than one output if (bCaseSensitive_) { func(data, token_, len_, offset_, Term::EnglishPOS, Term::OR, level_+1, false); tempOffset = offset_; } else { func(data, lowercaseTermUstr, len_, offset_, Term::EnglishPOS, Term::OR, level_+1, false); tempOffset = offset_; } if (stemmingTermUstr) { func(data, stemmingTermUstr, stemmingTermUstrSize, offset_, Term::EnglishPOS, Term::OR, level_+1, false); tempOffset = offset_; } if (synonymResultUstr) { func(data, synonymResultUstr, synonymResultUstrLen, offset_, NULL, Term::OR, level_+1, false); tempOffset = offset_; } if (bCaseSensitive_ && bContainLower_ && lowercaseIsDifferent) { func(data, lowercaseTermUstr, len_, offset_, Term::EnglishPOS, Term::OR, level_+1, false); tempOffset = offset_; } } else { /// have only one output if (bCaseSensitive_) { func(data, token_, len_, offset_, Term::EnglishPOS, Term::AND, level_, false); tempOffset = offset_; } else { func(data, lowercaseTermUstr, len_, offset_, Term::EnglishPOS, Term::AND, level_, false); tempOffset = offset_; } } } else { // if (false /*bExtractSynonym_, preprocessed*/) // { // UString::CharT * synonymResultUstr = NULL; // size_t synonymResultUstrLen = 0; // pSynonymContainer_ = uscSPtr_->getSynonymContainer(); // pSynonymContainer_->searchNgetSynonym(nativeToken_, pSynonymResult_); // bool hasSynonym = false; // for (int i =0; i<pSynonymResult_->getSynonymCount(0); i++) // { // char * synonymResult = pSynonymResult_->getWord(0, i); // if (synonymResult) // { // if (strcmp(nativeToken_, synonymResult) == 0) // { // //cout << "synonym self: "<<string(synonymResult) <<endl; // continue; // } // //cout << "synonym : "<<string(synonymResult) <<endl; // size_t synonymResultLen = strlen(synonymResult); // if (synonymResultLen <= term_ustring_buffer_limit_) // { // synonymResultUstr = synonym_ustring_buffer_; // synonymResultUstrLen = UString::toUcs2(synonymEncode_, // synonymResult, synonymResultLen, synonym_ustring_buffer_, term_ustring_buffer_limit_); // } // hasSynonym = true; // func(data, synonymResultUstr, synonymResultUstrLen, offset_, NULL, Term::OR, level_+1, false); // } // } // if (hasSynonym) // { // func(data, token_, len_, offset_, pos_, Term::OR, level_+1, false); // } // else // { // func(data, token_, len_, offset_, pos_, topAndOrBit, level_, false); // } // } // else { func(data, token_, len_, offset_, pos_, topAndOrBit, level_, false); tempOffset = offset_; } } } } return tempOffset + 1; }
QString Highlighter::parseToke( QString &text,QColor &color ){ if( !text.length() ) return ""; int i=0,n=text.length(); QChar c=text[i++]; bool monkeyFile=_editor->isMonkey(); if( c<=' ' ){ while( i<n && text[i]<=' ' ) ++i; }else if( isAlpha(c) ){ while( i<n && isIdent(text[i]) ) ++i; color=_identifiersColor; if( monkeyFile && _keyWords.contains( text.left(i).toLower() ) ) color=_keywordsColor; }else if( c=='0' && !monkeyFile ){ if( i<n && text[i]=='x' ){ for( ++i;i<n && isHexDigit( text[i] );++i ){} }else{ for( ;i<n && isOctDigit( text[i] );++i ){} } color=_numbersColor; }else if( isDigit(c) || (c=='.' && i<n && isDigit(text[i])) ){ bool flt=(c=='.'); while( i<n && isDigit(text[i]) ) ++i; if( !flt && i<n && text[i]=='.' ){ ++i; flt=true; while( i<n && isDigit(text[i]) ) ++i; } if( i<n && (text[i]=='e' || text[i]=='E') ){ flt=true; if( i<n && (text[i]=='+' || text[i]=='-') ) ++i; while( i<n && isDigit(text[i]) ) ++i; } color=_numbersColor; }else if( c=='%' && monkeyFile && i<n && isBinDigit( text[i] ) ){ for( ++i;i<n && isBinDigit( text[i] );++i ){} color=_numbersColor; }else if( c=='$' && monkeyFile && i<n && isHexDigit( text[i] ) ){ for( ++i;i<n && isHexDigit( text[i] );++i ){} color=_numbersColor; }else if( c=='\"' ){ if( monkeyFile ){ for( ;i<n && text[i]!='\"';++i ){} }else{ for( ;i<n && text[i]!='\"';++i ){ if( text[i]=='\\' && i+1<n && text[i+1]=='\"' ) ++i; } } if( i<n ) ++i; color=_stringsColor; }else if( !monkeyFile && c=='/' && i<n && text[i]=='/' ){ for( ++i;i<n && text[i]!='\n';++i ){} if( i<n ) ++i; color=_commentsColor; }else if( c=='\'' ){ if( monkeyFile ){ for( ;i<n && text[i]!='\n';++i ){} if( i<n ) ++i; color=_commentsColor; }else{ for( ;i<n && text[i]!='\'';++i ){ if( text[i]=='\\' && i+1<n && text[i+1]=='\'' ) ++i; } if( i<n ) ++i; color=_stringsColor; } }else{ color=_defaultColor; } QString t=text.left(i); text=text.mid(i); return t; }
/* consume all alpha characters */ char* allAlphas(char *p) { if (p==NULL || *p=='\0') return NULL; if (!isAlpha(p)) return p; return allAlphas(p+1); }
void SRExpressionsParser::parse(void) { type = VT_UNKNOWN; token.reset(); while(isspace(*expression)) expression++; if(isDelim(*expression)) { // parse for valid ops type = VT_DEL; char op=*expression; token.add(*expression++); switch(op) { case '|': if (*expression == '|') token.add(*expression++); break; case '*': if (*expression == '*') token.add(*expression++);// power... break; case '&': if (*expression == '&') token.add(*expression++); break; case '!': if (*expression == '=') token.add(*expression++); break; case '=': if (*expression == '=') token.add(*expression++); break; case '<': if (*expression == '=') token.add(*expression++); if (*expression == '<') token.add(*expression++); break; case '>': if (*expression == '=') token.add(*expression++); if (*expression == '>') token.add(*expression++); break; } } else if((expression[0]=='0') && (expression[1]=='x')) // hex value { type = VT_NUM; token.add(*expression++); token.add(*expression++); while(isxdigit(*expression)) { token.add(*expression++); } } else if(isNumeric(*expression)) { type = VT_NUM; while(isNumeric(*expression) || (*expression=='e')) // floating point, scientific { if (*expression=='e') { token.add(*expression++); if (*expression=='-') token.add(*expression++); } else { token.add(*expression++); } } switch(*expression) { case 'o': case 'b': case 'd': token.add(*expression++); break; } } else if(isAlpha(*expression) || ((unsigned char)*expression>=0x80)) { type = VT_VAR; while(isAlpha(*expression) || ((unsigned char)*expression>=0x80)) { token.add(*expression++); } } else if(*expression) { token.add(*expression++); throw(E_SYNTAX); } if((*expression==':')&&(expression[1]=='=')) { expression++; type = VT_DEF; } else if((*expression=='=') && (expression[1]!='=')) { type = VT_VAR; } while(isspace(*expression)) expression++; }
static bool isAlphaNumSpec(const char c) { return isAlpha(c) || (c >= '0' && c <= '9') || c == '-' || c == '.' || (((unsigned char)c) >= 0x80 && ((unsigned char)c) <= 0xFF); }
Int16u FNSplit (const char * pathP, char * driveP, char * dirP, char * nameP, char * extP) { Int16u Ret; //Set all string to default value zero Ret = 0; if (driveP) *driveP = 0; if (dirP) *dirP = 0; if (nameP) *nameP = 0; if (extP) *extP = 0; if (pathP == 0) return 0; const char * cursor = pathP, * dirStart = 0, * lastSlash = 0; // if (StartsWithAnsi (cursor) && _istalpha (*cursor) && if (StartsWithAnsi (cursor) && isAlpha (*cursor) && StartsWithAnsiChar (cursor + 1, ':')) { // A drive letter presents. if (driveP != 0) StrCpyN (driveP, cursor, MAXDRIVE); cursor += 2; Ret |= DRIVE; } dirStart = cursor; // now find the last slash while (*cursor != '\0') { if (StartsWithAnsiChar (cursor, '/') || StartsWithAnsiChar (cursor, '\\')) lastSlash = cursor; cursor = AnsiNext (cursor); } if (lastSlash != 0) { // a slash was seen if (dirP != 0) { Int16u bytesToCopy = lastSlash - dirStart + 1 // for '/' + 1; // for '\0' if (bytesToCopy > MAXDIR) bytesToCopy = MAXDIR; StrCpyN (dirP, dirStart, bytesToCopy); } cursor = lastSlash + 1; Ret |= DIRECTORY; } else cursor = dirStart; // cursor now points to the start of the filename // check for wildcards if (AnsiStrChr (cursor, '*') != 0 || AnsiStrChr (cursor, '?') != 0) Ret |= WILDCARDS; // now see if there's an extension const char * period = 0; for (const char * ptr = cursor; *ptr != '\0'; ptr = AnsiNext (ptr)) { if (StartsWithAnsiChar (ptr, '.')) period = ptr; } if (period != 0) { Int16u bytesToCopy = period - cursor + 1; // for '\0' if (bytesToCopy > MAXFILE) bytesToCopy = MAXFILE; if (bytesToCopy > 0) { if (nameP != 0) StrCpyN (nameP, cursor, bytesToCopy); Ret |= FILENAME; } if (extP != 0) StrCpyN (extP, period, MAXEXT); Ret |= EXTENSION; } else { if (*cursor != '\0') { if (nameP != 0) StrCpyN (nameP, cursor, MAXFILE); Ret |= FILENAME; } } #if defined (DEBUG_FNSPLIT) static char buffer [MAXPATH + MAXPATH + 32]; wsprintf (buffer, "pathP:[%s] driveP:[%s] dirP:[%s] nameP:[%s] extP:[%s]", pathP, driveP != NULL ? driveP : "<NULL>", dirP != NULL ? dirP : "<NULL>", nameP != NULL ? nameP : "<NULL>", extP != NULL ? extP : "<NULL>"); MessageBox (GetActiveWindow (), buffer, "FNSplit", MB_OK); #endif //(DEBUG_FNSPLIT) return Ret; }
bool isAlphaNum(char c){ return (isAlpha(c) or isNum(c)); }
/** A hint is formed by * 1. an insertion of a parameter, <param-..>...</param->. * 2. a <hint-1> or <hint-2> tag * * Hints have the following meaning: * - "<hint-1>xxx(yyy)zzz" ---> "xxxzzz" (singular) * - "<hint-2>xxx(yyy)zzz" ---> "xxxyyyzzz" (plural) * - "[^., ]a <param-..>[aeiou]" ---> "\1 an \2" (articla 'an', case insensitive) * - "<hint-?>" ---> "" (remove <hint>s afterwards) * * Note: there is no close tags for hints */ String process_english_hints(const String& str) { String ret; ret.reserve(str.size()); // have we seen a <hint-1/2>? // 1 for singular, 2 for plural int singplur = 0; for (size_t i = 0 ; i < str.size() ; ) { Char c = str.GetChar(i); if (is_substr(str, i, _("<hint-"))) { Char h = str.GetChar(i + 6); // hint code if (h == _('1')) { singplur = 1; } else if (h == _('2')) { singplur = 2; } i = skip_tag(str, i); } else if (is_substr(str, i, _("<param-"))) { size_t after = skip_tag(str, i); if (after != String::npos) { Char c = str.GetChar(after); if (singplur == 1 && is_substr(str, after, _("a</param-"))) { // a -> an, where the a originates from english_number_a(1) size_t after_end = skip_tag(str,after+1); if (after_end == String::npos) { throw Error(_("Incomplete </param> tag")); } if (after_end != String::npos && after_end + 1 < str.size() && isSpace(str.GetChar(after_end)) && is_vowel(str.GetChar(after_end+1))) { ret.append(str,i,after-i); ret += _("an"); i = after + 1; continue; } } else if (is_vowel(c) && ret.size() >= 2) { // a -> an? // is there "a" before this? String last = ret.substr(ret.size() - 2); if ( (ret.size() == 2 || !isAlpha(ret.GetChar(ret.size() - 3))) && (last == _("a ") || last == _("A ")) ) { ret.insert(ret.size() - 1, _('n')); } } else if (is_substr(str, after, _("</param-")) && ret.size() >= 1 && ret.GetChar(ret.size() - 1) == _(' ')) { // empty param, drop space before it ret.resize(ret.size() - 1); } } ret.append(str,i,min(after,str.size())-i); i = after; } else if (is_substr(str, i, _("<singular>"))) { // singular -> keep, plural -> drop size_t start = skip_tag(str, i); size_t end = match_close_tag(str, start); if (singplur == 1 && end != String::npos) { ret += str.substr(start, end - start); } singplur = 0; i = skip_tag(str, end); } else if (is_substr(str, i, _("<plural>"))) { // singular -> drop, plural -> keep size_t start = skip_tag(str, i); size_t end = match_close_tag(str, start); if (singplur == 2 && end != String::npos) { ret += str.substr(start, end - start); } singplur = 0; i = skip_tag(str, end); } else if (c == _('(') && singplur) { // singular -> drop (...), plural -> keep it size_t end = str.find_first_of(_(')'), i); if (end != String::npos) { if (singplur == 2) { ret += str.substr(i + 1, end - i - 1); } i = end + 1; } else { // handle like normal ret += c; ++i; } singplur = 0; } else if (c == _('<')) { size_t after = skip_tag(str, i); ret.append(str,i,min(after,str.size())-i); i = after; } else { ret += c; ++i; } } return ret; }
Token* AnnotationLexer::nextToken() { Token* token = 0; int tokenLine = getCurrentLineNumber(); int tokenStart = getCurrentCharNumberInLine(); try { do { if (readingString_) { readChar(); if (peek_ == '"') { readingString_ = false; return new Token(AnnotationTerminals::ID_QUOTE); } else { std::string str; do { str += peek_; if (nextChar() != '"') readChar(); else break; } while (true); return new StringToken(AnnotationTerminals::ID_STRING, str); } } // Skip whitespace including newlines // do { readChar(); } while (isWhitespace(peek_)); switch (peek_) { case '@': token = new Token(AnnotationTerminals::ID_AT); break; case '=': token = new Token(AnnotationTerminals::ID_EQUAL); break; case '[': token = new Token(AnnotationTerminals::ID_LBRACKET); break; case ']': token = new Token(AnnotationTerminals::ID_RBRACKET); break; case ',': token = new Token(AnnotationTerminals::ID_COMMA); break; case '\"': token = new Token(AnnotationTerminals::ID_QUOTE); readingString_ = true; break; case '\'': token = new Token(AnnotationTerminals::ID_APOSTROPHE); break; } // switch (peek_) if (token == 0) { if (isAlpha(peek_)) token = scanIdentifier(AnnotationTerminals::ID_IDENTIFIER); else if (isDigit(peek_) || (peek_ == '.')) token = scanNumber(); } } while (token == 0); } catch (std::runtime_error&) { if (token != 0) { token->setLineNumber(tokenLine); token->setCharNumber(tokenStart); } return token; } if (token != 0) { token->setLineNumber(tokenLine); token->setCharNumber(tokenStart); } return token; }
// private methods // Token* PlotFunctionLexer::nextToken() { Token* token = 0; int tokenLine = getCurrentLineNumber(); int tokenStart = getCurrentCharNumberInLine(); try { do { // Skip whitespace including newlines // do { readChar(); } while (isWhitespace(peek_)); switch (peek_) { case '.': if (isDigit(nextChar())) token = scanNumber(); else token = new Token(PlotFunctionTerminals::ID_DOT); break; // case '.' case '+': token = new OperatorToken(PlotFunctionTerminals::ID_PLUS,peek_); break; // case '+' case '-': token = new OperatorToken(PlotFunctionTerminals::ID_DASH,peek_); break; // case '-' case '/': token = new OperatorToken(PlotFunctionTerminals::ID_SLASH,peek_); break; // case '/' case '*': token = new OperatorToken(PlotFunctionTerminals::ID_STAR,peek_); break; // case '*' case '[': token = new BracketToken(PlotFunctionTerminals::ID_LBRACKET,peek_); break; // case '[' case ']': token = new BracketToken(PlotFunctionTerminals::ID_RBRACKET,peek_); break; // case ']' case '(': token = new BracketToken(PlotFunctionTerminals::ID_LPAREN,peek_); break; // case '(' case ')': token = new BracketToken(PlotFunctionTerminals::ID_RPAREN,peek_); break; // case ')' case '^': token = new OperatorToken(PlotFunctionTerminals::ID_CARET,peek_); break; // case '^' case ':': token = new IsolatorToken(PlotFunctionTerminals::ID_COLON,peek_); break; // case ':' case ';': token = new IsolatorToken(PlotFunctionTerminals::ID_SEMICOLON,peek_); break; // case ';' case ',': token = new IsolatorToken(PlotFunctionTerminals::ID_COMMA,peek_); break; // case ',' case '|': token = new IsolatorToken(PlotFunctionTerminals::ID_VERTICAL_BAR,peek_); break; // case '|' } // switch (peek_) if (token == 0) { if (isAlpha(peek_)) token = scanIdentifier(); else if (isDigit(peek_) || (peek_ == '.')) token = scanNumber(); } } while (token == 0); } catch (std::runtime_error&) { if (token != 0) { token->setLineNumber(tokenLine); token->setCharNumber(tokenStart); } else if (tokenStart == 0) token = new IdentifierToken(PlotFunctionTerminals::ID_EMPTY,""); // EMPTY Expression return token; } if (token != 0) { token->setLineNumber(tokenLine); token->setCharNumber(tokenStart); } return token; }
bool isAlNumDot(char c){ return isAlpha(c) || isNum(c) || isDot(c); }
static bool isAlphaNum(const QChar c) { return isAlpha(c) || (c >= '0' && c <= '9'); }
int finalSanitation(int * vectorMap, char **argv, int bFlag, Array *Employees, Array *Guests) { char *curr = NULL; if (vectorMap[1] != 0) { // -K sanitize curr = argv[vectorMap[1]]; while (*curr != 0) { if (!(isAlpha(curr) || isNum(curr))) { if (DEBUG) printf("-K value error! Only alphanumeric chars allowed!\n"); //REMOVE error(bFlag); return 0; } curr++; } } int iter = 0; for (iter; iter < Employees->used; ++iter) { if (DEBUG) printf("Sanitizing Employee number %d: %s\n", iter+1, argv[Employees->array[iter]]); curr = argv[Employees->array[iter]]; while (*curr != 0) { if (!isAlpha(curr)) { if (DEBUG) printf("-E value error! Only alphabets chars allowed!\n"); //REMOVE error(bFlag); return 0; } curr++; } } iter = 0; for (iter; iter < Guests->used; ++iter) { if (DEBUG) printf("Sanitizing Guest number %d: %s\n", iter+1, argv[Guests->array[iter]]); curr = argv[Guests->array[iter]]; while (*curr != 0) { if (!isAlpha(curr)) { if (DEBUG) printf("-G value error! Only alphabets chars allowed!\n"); //REMOVE error(bFlag); return 0; } curr++; } } if (vectorMap[5] != 0) { // <log> sanitize curr = argv[vectorMap[5]]; while (*curr != 0) { if (!(isAlpha(curr) || isNum(curr) || isUnderscore(curr) || *curr == '.' || *curr == '/')) { if (DEBUG) printf("<log> error! Only alphanumeric chars allowed and underscore(_)!\n"); //REMOVE error(bFlag); return 0; } curr++; } } return 1; }
FSM_BlockState FSM::transition(char c){ if(c == EOF && state != STATE_START && state != STATE_COMMENT && state != STATE_HALT_EOF && state != STATE_HALT_OUT_BRACE && state != STATE_HALT_SEMICOLON){ THROW_ERROR("Unexpected end of file"); } switch(state){ case STATE_START: if(isWhiteSpace(c)){ //Ignore whitespace. //Do nothing. state = STATE_START; } else if(isNumeric(c)){ //Start integer intVal = atoi(&c); state = STATE_HALT_INTEGER; } else { //Handle special characters switch(c){ case '+': state = STATE_HALT_PLUS; break; case '-': state = STATE_HALT_MINUS; break; case '*': state = STATE_HALT_MULT; break; case '/': state = STATE_HALT_DIVIDE; break; case '(': state = STATE_HALT_IN_PAREN; break; case ')': state = STATE_HALT_OUT_PAREN; break; case '{': state = STATE_HALT_IN_BRACE; break; case '}': state = STATE_HALT_OUT_BRACE; break; case '=': state = STATE_HALT_EQUALS; break; case '>': state = STATE_HALT_GT; break; case '<': state = STATE_HALT_LT; break; case '!': state = STATE_HALT_BANG; break; case ';': state = STATE_HALT_SEMICOLON; break; case ',': state = STATE_HALT_COMMA; break; case '\"': state = STATE_STRING_READ; break; case '|': state = STATE_OR; break; case '&': state = STATE_AND; break; case EOF: state = STATE_HALT_EOF; break; default: //Nothing special, must be an identifier if its valid. if(isAlpha(c)){ state = STATE_HALT_IDENTIFIER; currentString<<c; }else{ return FSM_BLOCK; } } } break; case STATE_HALT_INTEGER: if(isNumeric(c)){ //Continue reading the int. state = STATE_HALT_INTEGER; if(intVal > (INT_MAX - atoi(&c))/10){ THROW_ERROR("Constant too large!"); } intVal = 10*intVal + atoi(&c); } else if(isAlpha(c)) { state = STATE_FAIL; THROW_ERROR("Variable starting with numeric characters detected!!") } else { return FSM_BLOCK; } break; case STATE_HALT_IDENTIFIER: if(isAlpha(c) || isNumeric(c)){ currentString<<c; state = STATE_HALT_IDENTIFIER; }else{ return FSM_BLOCK; } break; case STATE_HALT_EQUALS: if(c == '='){ state = STATE_HALT_EQUIVALENCE; }else{ return FSM_BLOCK; } break; case STATE_HALT_GT: if(c == '='){ state = STATE_HALT_GTE; }else{ return FSM_BLOCK; } break; case STATE_HALT_LT: if(c == '='){ state = STATE_HALT_LTE; }else{ return FSM_BLOCK; } break; case STATE_HALT_BANG: if(c == '='){ state = STATE_HALT_NE; }else{ return FSM_BLOCK; } break; case STATE_HALT_DIVIDE: if(c == '/'){ state = STATE_COMMENT; }else if(c == '*'){ state = STATE_COMMENT_BLOCK; }else{ return FSM_BLOCK; } break; case STATE_COMMENT: //Keep reading and ignoring input untill a new line comes up. if(c == '\n' || c == EOF){ state = STATE_START; } break; case STATE_COMMENT_BLOCK: //Keep reading and ignoring input until a star comes up. if(c == '*' || c == EOF){ state = STATE_COMMENT_BLOCK_STAR; } break; case STATE_COMMENT_BLOCK_STAR: if(c == '/'){ state = STATE_START; }else{ state = STATE_COMMENT_BLOCK; } break; case STATE_STRING_READ: if(c == '\\'){ state = STATE_STRING_ESCAPE; }else if(c == '\"'){ state = STATE_HALT_STRING_FINISH; }else{ currentString<<c; } break; case STATE_STRING_ESCAPE: state = STATE_STRING_READ; currentString<<convertEscapeChar(c); break; case STATE_OR: if(c != '|'){ return FSM_BLOCK; } state = STATE_HALT_OR; break; case STATE_AND: if(c != '&'){ return FSM_BLOCK; } state = STATE_HALT_AND; break; //States which block on all input case STATE_HALT_SEMICOLON: case STATE_HALT_IN_PAREN: case STATE_HALT_OUT_PAREN: case STATE_HALT_IN_BRACE: case STATE_HALT_OUT_BRACE: case STATE_HALT_COMMA: case STATE_HALT_EQUIVALENCE: case STATE_HALT_GTE: case STATE_HALT_LTE: case STATE_HALT_NE: case STATE_HALT_MINUS: case STATE_HALT_MULT: case STATE_HALT_PLUS: case STATE_HALT_STRING_FINISH: case STATE_HALT_AND: case STATE_HALT_OR: case STATE_HALT_EOF: return FSM_BLOCK; default: THROW_ERROR("My tummy has got the rumblies!!"); }
bool getLogic(int x, int y, Direction direction) { #ifdef DEBUG printf("Position: x %d, y %d Direction: %d\n",x,y,direction); #endif switch(logicMap[x][y]) { case '?': if(logicMap[x][y-1] == '-') { return getLogic(x,y-1,LEFT); } else if(logicMap[x][y+1] == '-') { return getLogic(x,y+1,RIGHT); } else if(logicMap[x-1][y] == '|') { return getLogic(x-1,y,UP); } else { return getLogic(x+1,y,DOWN); } break; case '-': if(direction == LEFT) { return getLogic(x,y-1,LEFT); } else { return getLogic(x,y+1,RIGHT); } break; case '|': if(direction == UP) { return getLogic(x-1,y,UP); } else { return getLogic(x+1,y,DOWN); } break; case '+': if(direction == UP || direction == DOWN) { if(logicMap[x][y-1] == '-') { return getLogic(x,y-1,LEFT); } else { return getLogic(x,y+1,RIGHT); } } else { if(logicMap[x-1][y] == '|') { return getLogic(x-1,y,UP); } else { return getLogic(x+1,y,DOWN); } } break; case 'o': if((logicMap[x][y-1] == '-' || logicMap[x][y-1] == ')' || logicMap[x][y-1] == '>') && direction!=RIGHT) { return !getLogic(x,y-1,LEFT); } else if(logicMap[x][y+1] == '-' && direction!=LEFT) { return !getLogic(x,y+1,RIGHT); } else if(logicMap[x-1][y] == '|' && direction!=DOWN) { return !getLogic(x-1,y,UP); } else { return !getLogic(x+1,y,DOWN); } break; case ')': return getLogic(x-1,y-3,LEFT) && getLogic(x+1,y-3,LEFT); case '>': return getLogic(x-1,y-3,LEFT) || getLogic(x+1,y-3,LEFT); default: if(isAlpha(logicMap[x][y])) { return logicAlpha[logicMap[x][y] - 'A'] == '1'; } } }
/* consume all alphas or digits */ char* allAlphasOrDigit(char *p) { if (p==NULL || *p=='\0') return NULL; if (!(isAlpha(p) || isDigit(p))) return p; return allAlphasOrDigit(p+1); }
bool CMatch::FindRangeStart(int& crFrom/*[In/Out]*/, int& crTo/*[In/Out]*/, bool& bUrlMode, LPCWSTR pszBreak, LPCWSTR pszUrlDelim, LPCWSTR pszSpacing, LPCWSTR pszUrl, LPCWSTR pszProtocol, LPCWSTR pChar, int nLen) { bool lbRc = false; // Курсор над скобкой "(3): ..." из текста "abc.py (3): ..." //if ((crFrom > 2) && wcschr(L"([", pChar[crFrom]) && wcschr(pszSpacing, pChar[crFrom-1]) && !wcschr(pszSpacing, pChar[crFrom-2])) // crFrom--; int iAlphas = 0; // Курсор над комментарием? // Попробуем найти начало имени файла // 131026 Allows '?', otherwise links like http://go.com/fwlink/?LinkID=1 may fail while ((crFrom > 0) && ((pChar[crFrom-1]==L'?') || !wcschr(bUrlMode ? pszUrlDelim : pszBreak, pChar[crFrom-1]))) { // Check this before pszSpacing comparison because otherwise we'll fail on smth like // Bla-bla-bla C:\your-file.txt // if the mouse was over "C:\" if (isAlpha(pChar[crFrom])) { iAlphas++; } if (iAlphas > 0) { TODO("Если вводить поддержку powershell 'Script.ps1:35 знак:23' нужно будет не прерываться перед национальными словами 'знак'"); // Disallow leading spaces if (wcschr(pszSpacing, pChar[crFrom-1])) break; } if (!bUrlMode && pChar[crFrom] == L'/') { if ((crFrom >= 2) && ((crFrom + 1) < nLen) && ((pChar[crFrom+1] == L'/') && (pChar[crFrom-1] == L':') && wcschr(pszUrl, pChar[crFrom-2]))) // как минимум одна буква на протокол { crFrom++; } if ((crFrom >= 3) && ((pChar[crFrom-1] == L'/') // как минимум одна буква на протокол && (((pChar[crFrom-2] == L':') && wcschr(pszUrl, pChar[crFrom-3])) // http://www.ya.ru || ((crFrom >= 4) && (pChar[crFrom-2] == L'/') && (pChar[crFrom-3] == L':') && wcschr(pszUrl, pChar[crFrom-4])) // file:///c:\file.html )) ) { bUrlMode = true; crTo = crFrom-2; crFrom -= 3; while ((crFrom > 0) && wcschr(pszProtocol, pChar[crFrom-1])) crFrom--; break; } else if ((pChar[crFrom] == L'/') && (crFrom >= 1) && (pChar[crFrom-1] == L'/')) { crFrom++; break; // Комментарий в строке? } } crFrom--; if (pChar[crFrom] == L':') { if (pChar[crFrom+1] == L' ') { // ASM - подсвечивать нужно "test.asasm(1,1)" // [email protected](1239): test.asasm(1,1): crFrom += 2; break; } else if (bUrlMode && pChar[crFrom+1] != L'\\' && pChar[crFrom+1] != L'/') { goto wrap; // Не оно } } } while (((crFrom+1) < nLen) && wcschr(pszSpacing, pChar[crFrom])) crFrom++; if (crFrom > crTo) { goto wrap; // Fail? } lbRc = true; wrap: return lbRc; }
void jslGetNextToken(JsLex *lex) { jslGetNextToken_start: // Skip whitespace while (isWhitespace(lex->currCh)) jslGetNextCh(lex); // Search for comments if (lex->currCh=='/') { // newline comments if (jslNextCh(lex)=='/') { while (lex->currCh && lex->currCh!='\n') jslGetNextCh(lex); jslGetNextCh(lex); goto jslGetNextToken_start; } // block comments if (jslNextCh(lex)=='*') { while (lex->currCh && !(lex->currCh=='*' && jslNextCh(lex)=='/')) jslGetNextCh(lex); if (!lex->currCh) { lex->tk = LEX_UNFINISHED_COMMENT; return; /* an unfinished multi-line comment. When in interactive console, detect this and make sure we accept new lines */ } jslGetNextCh(lex); jslGetNextCh(lex); goto jslGetNextToken_start; } } lex->tk = LEX_EOF; lex->tokenl = 0; // clear token string if (lex->tokenValue) { jsvUnLock(lex->tokenValue); lex->tokenValue = 0; } // record beginning of this token lex->tokenLastStart = jsvStringIteratorGetIndex(&lex->tokenStart.it) - 1; /* we don't lock here, because we know that the string itself will be locked * because of lex->sourceVar */ lex->tokenStart.it = lex->it; lex->tokenStart.currCh = lex->currCh; // tokens if (((unsigned char)lex->currCh) < jslJumpTableStart || ((unsigned char)lex->currCh) > jslJumpTableEnd) { // if unhandled by the jump table, just pass it through as a single character jslSingleChar(lex); } else { switch(jslJumpTable[((unsigned char)lex->currCh) - jslJumpTableStart]) { case JSLJT_ID: { while (isAlpha(lex->currCh) || isNumeric(lex->currCh) || lex->currCh=='$') { jslTokenAppendChar(lex, lex->currCh); jslGetNextCh(lex); } lex->tk = LEX_ID; // We do fancy stuff here to reduce number of compares (hopefully GCC creates a jump table) switch (lex->token[0]) { case 'b': if (jslIsToken(lex,"break", 1)) lex->tk = LEX_R_BREAK; break; case 'c': if (jslIsToken(lex,"case", 1)) lex->tk = LEX_R_CASE; else if (jslIsToken(lex,"catch", 1)) lex->tk = LEX_R_CATCH; else if (jslIsToken(lex,"continue", 1)) lex->tk = LEX_R_CONTINUE; break; case 'd': if (jslIsToken(lex,"default", 1)) lex->tk = LEX_R_DEFAULT; else if (jslIsToken(lex,"delete", 1)) lex->tk = LEX_R_DELETE; else if (jslIsToken(lex,"do", 1)) lex->tk = LEX_R_DO; else if (jslIsToken(lex,"debugger", 1)) lex->tk = LEX_R_DEBUGGER; break; case 'e': if (jslIsToken(lex,"else", 1)) lex->tk = LEX_R_ELSE; break; case 'f': if (jslIsToken(lex,"false", 1)) lex->tk = LEX_R_FALSE; else if (jslIsToken(lex,"finally", 1)) lex->tk = LEX_R_FINALLY; else if (jslIsToken(lex,"for", 1)) lex->tk = LEX_R_FOR; else if (jslIsToken(lex,"function", 1)) lex->tk = LEX_R_FUNCTION; break; case 'i': if (jslIsToken(lex,"if", 1)) lex->tk = LEX_R_IF; else if (jslIsToken(lex,"in", 1)) lex->tk = LEX_R_IN; else if (jslIsToken(lex,"instanceof", 1)) lex->tk = LEX_R_INSTANCEOF; break; case 'n': if (jslIsToken(lex,"new", 1)) lex->tk = LEX_R_NEW; else if (jslIsToken(lex,"null", 1)) lex->tk = LEX_R_NULL; break; case 'r': if (jslIsToken(lex,"return", 1)) lex->tk = LEX_R_RETURN; break; case 's': if (jslIsToken(lex,"switch", 1)) lex->tk = LEX_R_SWITCH; break; case 't': if (jslIsToken(lex,"this", 1)) lex->tk = LEX_R_THIS; else if (jslIsToken(lex,"throw", 1)) lex->tk = LEX_R_THROW; else if (jslIsToken(lex,"true", 1)) lex->tk = LEX_R_TRUE; else if (jslIsToken(lex,"try", 1)) lex->tk = LEX_R_TRY; else if (jslIsToken(lex,"typeof", 1)) lex->tk = LEX_R_TYPEOF; break; case 'u': if (jslIsToken(lex,"undefined", 1)) lex->tk = LEX_R_UNDEFINED; break; case 'w': if (jslIsToken(lex,"while", 1)) lex->tk = LEX_R_WHILE; break; case 'v': if (jslIsToken(lex,"var", 1)) lex->tk = LEX_R_VAR; else if (jslIsToken(lex,"void", 1)) lex->tk = LEX_R_VOID; break; default: break; } break; case JSLJT_NUMBER: { // TODO: check numbers aren't the wrong format bool canBeFloating = true; if (lex->currCh=='.') { jslGetNextCh(lex); if (isNumeric(lex->currCh)) { // it is a float lex->tk = LEX_FLOAT; jslTokenAppendChar(lex, '.'); } else { // it wasn't a number after all lex->tk = '.'; break; } } else { if (lex->currCh=='0') { jslTokenAppendChar(lex, lex->currCh); jslGetNextCh(lex); if ((lex->currCh=='x' || lex->currCh=='X') || (lex->currCh=='b' || lex->currCh=='B') || (lex->currCh=='o' || lex->currCh=='O')) { canBeFloating = false; jslTokenAppendChar(lex, lex->currCh); jslGetNextCh(lex); } } lex->tk = LEX_INT; while (isNumeric(lex->currCh) || (!canBeFloating && isHexadecimal(lex->currCh))) { jslTokenAppendChar(lex, lex->currCh); jslGetNextCh(lex); } if (canBeFloating && lex->currCh=='.') { lex->tk = LEX_FLOAT; jslTokenAppendChar(lex, '.'); jslGetNextCh(lex); } } // parse fractional part if (lex->tk == LEX_FLOAT) { while (isNumeric(lex->currCh)) { jslTokenAppendChar(lex, lex->currCh); jslGetNextCh(lex); } } // do fancy e-style floating point if (canBeFloating && (lex->currCh=='e'||lex->currCh=='E')) { lex->tk = LEX_FLOAT; jslTokenAppendChar(lex, lex->currCh); jslGetNextCh(lex); if (lex->currCh=='-' || lex->currCh=='+') { jslTokenAppendChar(lex, lex->currCh); jslGetNextCh(lex); } while (isNumeric(lex->currCh)) { jslTokenAppendChar(lex, lex->currCh); jslGetNextCh(lex); } } } break; case JSLJT_STRING: { char delim = lex->currCh; lex->tokenValue = jsvNewFromEmptyString(); if (!lex->tokenValue) { lex->tk = LEX_EOF; return; } JsvStringIterator it; jsvStringIteratorNew(&it, lex->tokenValue, 0); // strings... jslGetNextCh(lex); while (lex->currCh && lex->currCh!=delim) { if (lex->currCh == '\\') { jslGetNextCh(lex); char ch = lex->currCh; switch (lex->currCh) { case 'n' : ch = 0x0A; jslGetNextCh(lex); break; case 'b' : ch = 0x08; jslGetNextCh(lex); break; case 'f' : ch = 0x0C; jslGetNextCh(lex); break; case 'r' : ch = 0x0D; jslGetNextCh(lex); break; case 't' : ch = 0x09; jslGetNextCh(lex); break; case 'v' : ch = 0x0B; jslGetNextCh(lex); break; case 'u' : case 'x' : { // hex digits char buf[5] = "0x??"; if (lex->currCh == 'u') { // We don't support unicode, so we just take the bottom 8 bits // of the unicode character jslGetNextCh(lex); jslGetNextCh(lex); } jslGetNextCh(lex); buf[2] = lex->currCh; jslGetNextCh(lex); buf[3] = lex->currCh; jslGetNextCh(lex); ch = (char)stringToInt(buf); } break; default: if (lex->currCh>='0' && lex->currCh<='7') { // octal digits char buf[5] = "0"; buf[1] = lex->currCh; int n=2; jslGetNextCh(lex); if (lex->currCh>='0' && lex->currCh<='7') { buf[n++] = lex->currCh; jslGetNextCh(lex); if (lex->currCh>='0' && lex->currCh<='7') { buf[n++] = lex->currCh; jslGetNextCh(lex); } } buf[n]=0; ch = (char)stringToInt(buf); } else { // for anything else, just push the character through jslGetNextCh(lex); } break; } jslTokenAppendChar(lex, ch); jsvStringIteratorAppend(&it, ch); } else { jslTokenAppendChar(lex, lex->currCh); jsvStringIteratorAppend(&it, lex->currCh); jslGetNextCh(lex); } } jsvStringIteratorFree(&it); jslGetNextCh(lex); lex->tk = LEX_STR; } break; case JSLJT_EXCLAMATION: jslSingleChar(lex); if (lex->currCh=='=') { // != lex->tk = LEX_NEQUAL; jslGetNextCh(lex); if (lex->currCh=='=') { // !== lex->tk = LEX_NTYPEEQUAL; jslGetNextCh(lex); } } break; case JSLJT_PLUS: jslSingleChar(lex); if (lex->currCh=='=') { lex->tk = LEX_PLUSEQUAL; jslGetNextCh(lex); } else if (lex->currCh=='+') { lex->tk = LEX_PLUSPLUS; jslGetNextCh(lex); } break; case JSLJT_MINUS: jslSingleChar(lex); if (lex->currCh=='=') { lex->tk = LEX_MINUSEQUAL; jslGetNextCh(lex); } else if (lex->currCh=='-') { lex->tk = LEX_MINUSMINUS; jslGetNextCh(lex); } break; case JSLJT_AND: jslSingleChar(lex); if (lex->currCh=='=') { lex->tk = LEX_ANDEQUAL; jslGetNextCh(lex); } else if (lex->currCh=='&') { lex->tk = LEX_ANDAND; jslGetNextCh(lex); } break; case JSLJT_OR: jslSingleChar(lex); if (lex->currCh=='=') { lex->tk = LEX_OREQUAL; jslGetNextCh(lex); } else if (lex->currCh=='|') { lex->tk = LEX_OROR; jslGetNextCh(lex); } break; case JSLJT_TOPHAT: jslSingleChar(lex); if (lex->currCh=='=') { lex->tk = LEX_XOREQUAL; jslGetNextCh(lex); } break; case JSLJT_STAR: jslSingleChar(lex); if (lex->currCh=='=') { lex->tk = LEX_MULEQUAL; jslGetNextCh(lex); } break; case JSLJT_FORWARDSLASH: jslSingleChar(lex); if (lex->currCh=='=') { lex->tk = LEX_DIVEQUAL; jslGetNextCh(lex); } break; case JSLJT_PERCENT: jslSingleChar(lex); if (lex->currCh=='=') { lex->tk = LEX_MODEQUAL; jslGetNextCh(lex); } break; case JSLJT_EQUAL: jslSingleChar(lex); if (lex->currCh=='=') { // == lex->tk = LEX_EQUAL; jslGetNextCh(lex); if (lex->currCh=='=') { // === lex->tk = LEX_TYPEEQUAL; jslGetNextCh(lex); } } break; case JSLJT_LESSTHAN: jslSingleChar(lex); if (lex->currCh=='=') { // <= lex->tk = LEX_LEQUAL; jslGetNextCh(lex); } else if (lex->currCh=='<') { // << lex->tk = LEX_LSHIFT; jslGetNextCh(lex); if (lex->currCh=='=') { // <<= lex->tk = LEX_LSHIFTEQUAL; jslGetNextCh(lex); } } break; case JSLJT_GREATERTHAN: jslSingleChar(lex); if (lex->currCh=='=') { // >= lex->tk = LEX_GEQUAL; jslGetNextCh(lex); } else if (lex->currCh=='>') { // >> lex->tk = LEX_RSHIFT; jslGetNextCh(lex); if (lex->currCh=='=') { // >>= lex->tk = LEX_RSHIFTEQUAL; jslGetNextCh(lex); } else if (lex->currCh=='>') { // >>> jslGetNextCh(lex); if (lex->currCh=='=') { // >>>= lex->tk = LEX_RSHIFTUNSIGNEDEQUAL; jslGetNextCh(lex); } else { lex->tk = LEX_RSHIFTUNSIGNED; } } } break; case JSLJT_SINGLECHAR: jslSingleChar(lex); break; default: assert(0);break; } } } }
void TinyXML::processChar(uint8_t ch) { uint16_t chToParse; boolean bMatch=false; while (!bMatch) { chToParse = pgm_read_word(&(pTable[currentState].charToParse)); switch ( chToParse ) { case whiteSpace: if (ch == ' ' || ch == '\t' || ch == '\n' | ch == '\r') bMatch=true; break; case alpha: if (isAlpha(ch)) bMatch=true; break; case alphanum: if (isAlpha(ch) || isNumeric(ch) || (ch == ':') || (ch == '_') || (ch == '-')) bMatch=true; break; case quote: if (ch == '"' || ch == '\'') { matchQuote = ch; bMatch=true; } break; case matchingquote: if (ch == matchQuote) bMatch=true; break; case anychar: bMatch=true; break; default: if (ch == chToParse) bMatch=true; break; } if (!bMatch) { #if DEBUG > 3 Serial.print("Non-matching state:"); Serial.print(currentState,DEC); Serial.print(" ch:"); Serial.print(ch,HEX); Serial.print(" match criteria:"); Serial.print(chToParse,HEX); Serial.print(" new state:"); Serial.println(currentState+1,DEC); #endif currentState++; } } // as every table enry must end in anychar we must get out of here #if DEBUG > 2 Serial.print("Matching state:"); Serial.print(currentState,DEC); Serial.print(" ch:"); Serial.print(ch,HEX); Serial.print(" match criteria:"); Serial.print(chToParse,HEX); Serial.print(" tagBufferPtr:"); Serial.print(tagBufferPtr,DEC); Serial.print(" new state:"); Serial.println(pgm_read_byte(&(pTable[currentState].nextState)),DEC); #endif action(ch, pgm_read_byte(&(pTable[currentState].actionNumber))); action(ch, pgm_read_byte(&(pTable[currentState].actionNumber2))); currentState=pgm_read_byte(&(pTable[currentState].nextState)); }
inline bool isAlphaNumeric(char c) { return isAlpha(c) || isNumeric(c); }
symbol_t readSym(){ char *s, tch; symtype_t i; while(isBlank())nextchar(); if(isAlpha()){ s = ccstring(); s = ccstrcat(s,ch); nextchar(); while(isAlpha() || isDigital()){ s = ccstrcat(s,ch); nextchar(); } for(i = CONST; i<=RETURN; i ++) if(ccstrcmp(s,keywords[i-1])==0){ return Symbol(i, 0); } return Symbol(ID, (int)s); }else if(isDigital()){ return readNumLit(0); }else if(ch=='\''){ nextchar(); if(isAlpha() || isDigital() || ch=='+' || ch=='-' || ch=='*' || ch=='/'){ tch = ch; nextchar(); if(ch=='\''){ nextchar(); return Symbol(CHARLIT, (int)tch); } } msg(ERR, "a wrong char literal",lineno+1); }else if(ch=='\"'){ nextchar(); s = ccstring(); while(ch!='\"' && ch!=EOF){ s = ccstrcat(s, ch); nextchar(); } if(ch!=EOF){ nextchar(); return Symbol(STRLIT, (int)s); } msg(ERR, "a wrong string literal",lineno+1); }else if(ch=='+'){ nextchar(); //if(isDigital()) // return readNumLit(0); //else return Symbol(PLUS, 0); }else if(ch=='-'){ nextchar(); //if(isDigital()) // return readNumLit(1); //else return Symbol(MINUS, 0); }else if(ch=='*'){ nextchar(); return Symbol(MULTI, 0); }else if(ch=='/'){ nextchar(); return Symbol(DIVIDE, 0); }else if(ch=='<'){ nextchar(); if(ch=='='){ nextchar(); return Symbol(LEQU, 0); }else return Symbol(LESS, 0); }else if(ch=='>'){ nextchar(); if(ch=='='){ nextchar(); return Symbol(GEQU, 0); }else return Symbol(GREATER, 0); }else if(ch=='!'){ nextchar(); if(ch=='='){ nextchar(); return Symbol(UNEQU, 0); } msg(ERR, "unexpected char \'!\'",lineno+1); }else if(ch=='='){ nextchar(); if(ch=='='){ nextchar(); return Symbol(EQU, 0); }else return Symbol(ASN, 0); }else if(ch=='('){ nextchar(); return Symbol(LPAREN, 0); }else if(ch==')'){ nextchar(); return Symbol(RPAREN, 0); }else if(ch=='{'){ nextchar(); return Symbol(LBRACE, 0); }else if(ch=='}'){ nextchar(); return Symbol(RBRACE, 0); }else if(ch==';'){ nextchar(); return Symbol(SEMIC, 0); }else if(ch==':'){ nextchar(); return Symbol(COLON, 0); }else if(ch==','){ nextchar(); return Symbol(COMMA, 0); }else if(ch==EOF){ return Symbol(SEOF, 0); } msg(ERR, "unknown lexer error",lineno+1); return 0; }
static boolean isIdent (char c) { return isNum (c) || isAlpha (c) || c == '_' || c == '\''; }
bool Scanner::isAlphaNumeric(char c) const { return isAlpha(c) || isDigit(c); }
void loop( void ) { // Serial.write( '\n' ) ; // send a char // Serial.write( '\r' ) ; // send a char // Serial5.write( '-' ) ; // send a char // adding a constant integer to a string: stringThree = stringOne + 123; Serial.println(stringThree); // prints "stringThree = 123" // adding a constant long interger to a string: stringThree = stringOne + 123456789; Serial.println(stringThree); // prints " You added 123456789" // adding a constant character to a string: stringThree = stringOne + 'A'; Serial.println(stringThree); // prints "You added A" // adding a constant string to a string: stringThree = stringOne + "abc"; Serial.println(stringThree); // prints "You added abc" stringThree = stringOne + stringTwo; Serial.println(stringThree); // prints "You added this string" // adding a variable integer to a string: int sensorValue = analogRead(A0); stringOne = "Sensor value: "; stringThree = stringOne + sensorValue; Serial.println(stringThree); // prints "Sensor Value: 401" or whatever value analogRead(A0) has // adding a variable long integer to a string: long currentTime = millis(); stringOne = "millis() value: "; stringThree = stringOne + millis(); Serial.println(stringThree); // prints "The millis: 345345" or whatever value currentTime has // do nothing while true: while (true); #if 0 // get any incoming bytes: if (Serial.available() > 0) { int thisChar = Serial.read(); //////// int thisChar = 'a'; // say what was sent: Serial.print("You sent me: \'"); Serial.write(thisChar); Serial.print("\' ASCII Value: "); Serial.println(thisChar); // analyze what was sent: if (isAlphaNumeric(thisChar)) { Serial.println("it's alphanumeric"); } if (isAlpha(thisChar)) { Serial.println("it's alphabetic"); } if (isAscii(thisChar)) { Serial.println("it's ASCII"); } if (isWhitespace(thisChar)) { Serial.println("it's whitespace"); } if (isControl(thisChar)) { Serial.println("it's a control character"); } if (isDigit(thisChar)) { Serial.println("it's a numeric digit"); } if (isGraph(thisChar)) { Serial.println("it's a printable character that's not whitespace"); } if (isLowerCase(thisChar)) { Serial.println("it's lower case"); } if (isPrintable(thisChar)) { Serial.println("it's printable"); } if (isPunct(thisChar)) { Serial.println("it's punctuation"); } if (isSpace(thisChar)) { Serial.println("it's a space character"); } if (isUpperCase(thisChar)) { Serial.println("it's upper case"); } if (isHexadecimalDigit(thisChar)) { Serial.println("it's a valid hexadecimaldigit (i.e. 0 - 9, a - F, or A - F)"); } // add some space and ask for another byte: Serial.println(); Serial.println("Give me another byte:"); Serial.println(); } #endif #if 0 sensorValue = analogRead(A0); // apply the calibration to the sensor reading sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255); Serial.print("sensor = " ); Serial.print(sensorValue); // in case the sensor value is outside the range seen during calibration outputValue = constrain(sensorValue, 0, 255); // print the results to the serial monitor: Serial.print("\t output = "); Serial.println(outputValue); // fade the LED using the calibrated value: analogWrite(9/*ledPin*/, sensorValue); delay(1); #endif #if 0 // read the analog in value: sensorValue = analogRead(A0); // map it to the range of the analog out: outputValue = map(sensorValue, 0, 1023, 0, 255); // change the analog out value: analogWrite(9/*analogOutPin*/, outputValue); // print the results to the serial monitor: Serial.print("sensor = " ); Serial.print(sensorValue); Serial.print("\t output = "); Serial.println(outputValue); // wait 2 milliseconds before the next loop // for the analog-to-digital converter to settle // after the last reading: delay(2); // delay(1000); #endif #if 0 digitalWrite( 0, HIGH ) ; // set the red LED on digitalWrite( 0, LOW ) ; // set the red LED on digitalWrite( 1, HIGH ) ; // set the red LED on digitalWrite( 1, LOW ) ; // set the red LED on digitalWrite( 4, HIGH ) ; // set the red LED on digitalWrite( 4, LOW ) ; // set the red LED on digitalWrite( 5, HIGH ) ; // set the red LED on digitalWrite( 5, LOW ) ; // set the red LED on digitalWrite( 6, HIGH ) ; // set the red LED on digitalWrite( 6, LOW ) ; // set the red LED on digitalWrite( 7, HIGH ) ; // set the red LED on digitalWrite( 7, LOW ) ; // set the red LED on digitalWrite( 8, HIGH ) ; // set the red LED on digitalWrite( 8, LOW ) ; // set the red LED on digitalWrite( 9, HIGH ) ; // set the red LED on digitalWrite( 9, LOW ) ; // set the red LED on digitalWrite( 10, HIGH ) ; // set the red LED on digitalWrite( 10, LOW ) ; // set the red LED on digitalWrite( 11, HIGH ) ; // set the red LED on digitalWrite( 11, LOW ) ; // set the red LED on digitalWrite( 12, HIGH ) ; // set the red LED on digitalWrite( 12, LOW ) ; // set the red LED on digitalWrite( 13, HIGH ) ; // set the red LED on digitalWrite( 13, LOW ) ; // set the red LED on #endif #if 0 // int a = 123; // Serial.print(a, DEC); // for ( uint32_t i = A0 ; i <= A0+NUM_ANALOG_INPUTS ; i++ ) for ( uint32_t i = 0 ; i <= NUM_ANALOG_INPUTS ; i++ ) { int a = analogRead(i); // int a = 123; Serial.print(a, DEC); Serial.print(" "); // Serial.write( ' ' ) ; // send a char // Serial.write( 0x30 + i ) ; // send a char // Serial.write( 0x30 + ((a/1000)%10) ) ; // send a char // Serial.write( 0x30 + ((a/100)%10) ) ; // send a char // Serial.write( 0x30 + ((a/10)%10) ) ; // send a char // Serial.write( 0x30 + (a%10) ) ; // send a char // Serial.write( ' ' ) ; // send a char } Serial.println(); #endif #if 0 volatile int pin_value=0 ; static volatile uint8_t duty_cycle=0 ; static volatile uint16_t dac_value=0 ; // Test digitalWrite led_step1() ; delay( 500 ) ; // wait for a second led_step2() ; delay( 500 ) ; // wait for a second // Test Serial output Serial5.write( '-' ) ; // send a char Serial5.write( "test1\n" ) ; // send a string Serial5.write( "test2" ) ; // send another string // Test digitalRead: connect pin 2 to either GND or 3.3V. !!!! NOT on 5V pin !!!! pin_value=digitalRead( 2 ) ; Serial5.write( "pin 2 value is " ) ; Serial5.write( (pin_value == LOW)?"LOW\n":"HIGH\n" ) ; duty_cycle+=8 ;//=(uint8_t)(millis() & 0xff) ; analogWrite( 13, duty_cycle ) ; analogWrite( 12, duty_cycle ) ; analogWrite( 11, duty_cycle ) ; analogWrite( 10 ,duty_cycle ) ; analogWrite( 9, duty_cycle ) ; analogWrite( 8, duty_cycle ) ; dac_value += 64; analogWrite(A0, dac_value); Serial5.print("\r\nAnalog pins: "); for ( uint32_t i = A0 ; i <= A0+NUM_ANALOG_INPUTS ; i++ ) { int a = analogRead(i); Serial5.print(a, DEC); Serial5.print(" "); } Serial5.println(); Serial5.println("External interrupt pins:"); if ( ul_Interrupt_Pin3 == 1 ) { Serial5.println( "Pin 3 triggered (LOW)" ) ; ul_Interrupt_Pin3 = 0 ; } if ( ul_Interrupt_Pin4 == 1 ) { Serial5.println( "Pin 4 triggered (HIGH)" ) ; ul_Interrupt_Pin4 = 0 ; } if ( ul_Interrupt_Pin5 == 1 ) { Serial5.println( "Pin 5 triggered (FALLING)" ) ; ul_Interrupt_Pin5 = 0 ; } if ( ul_Interrupt_Pin6 == 1 ) { Serial5.println( "Pin 6 triggered (RISING)" ) ; ul_Interrupt_Pin6 = 0 ; } if ( ul_Interrupt_Pin7 == 1 ) { Serial5.println( "Pin 7 triggered (CHANGE)" ) ; ul_Interrupt_Pin7 = 0 ; } #endif }
void paragraph::PutHandlingWordWrap(const wint_t ch,flags & flgs) // Called from GetPut, GetPutBullet and doTheSegmentation { if(flgs.inhtmltag || !Option.wordUnwrap) { Segment.Put(file,ch,flgs); // // } else { if(isSentencePunct(ch)) { ++flgs.punctuationFound; } else if(isSemiPunct(ch)) { ++flgs.semiPunctuationFound; } else if(ch == '-') { ++flgs.hyphenFound; } if(ch == '\n' || ch == '\r') { switch(last) { case '\n': if(wait) { hyphenate(flgs); wait = 0; flgs.punctuationFound = 0; flgs.hyphenFound = 0; spaceAfterHyphen = false; } flgs.semiPunctuationFound = 0; Segment.Put(file,'\n',flgs); break; case '-': { int k; int nonSpaceCount = 0; bool nonAlphaFound = false; dropHyphen = false; int i; // skip previous spaces for( i = ind(lastWordIndex-1) ; i != lastWordIndex && isSpace(circularBuffer[ind(i)]) ; i = dec(i) ) ; allLower = allUpper = true; bool Upper = false; /* This variable introduces "lag" of one iteration in changing the value of allLower. In that way, the case of first character in the string (the one last checked) doesn't matter. Example: blah blah. Da- vid did it. */ for ( ; i != lastWordIndex && ( k = circularBuffer[ind(i)] , !isSpace(k) ) ; i = dec(i) ) // Look at casing of last word in retrograde fashion. { ++nonSpaceCount; if(Upper) allLower = false; if(isAlpha(k) && k != '-') { if(!isLower(k)) Upper = true; if(!isUpper(k)) allUpper = false; } else if(k != '-') { nonAlphaFound = true; break; } if(isVowel(k)) // We need at least one vowel to admit //interpretation of hyphen as the // effect of word wrap. dropHyphen = true; } if(dropHyphen && !allLower && !allUpper) dropHyphen = false; // Mixed case -> keep hyphen if(!nonAlphaFound && nonSpaceCount >= 2) { /**/ lastWordIndex = 0; wait = (sizeof(circularBuffer)/sizeof(circularBuffer[0])); waited = 0; } break; } default: { if(wait) { considerHyphenation(flgs); wait = 0; flgs.punctuationFound = 0; flgs.semiPunctuationFound = 0; flgs.hyphenFound = 0; spaceAfterHyphen = false; } Segment.Put(file,'\n',flgs); // Treat newline as a blank } } } else { if(wait) { if(!isFlatSpace(ch)) { if(waited == wait) { hyphenate(flgs); wait = 0; flgs.punctuationFound = 0; flgs.semiPunctuationFound = 0; flgs.hyphenFound = 0; spaceAfterHyphen = false; Segment.Put(file,ch,flgs); } else { circularBuffer[waited++] = (wchar_t)ch; } } else if(waited > 0) { considerHyphenation(flgs); wait = 0; flgs.punctuationFound = 0; flgs.semiPunctuationFound = 0; flgs.hyphenFound = 0; spaceAfterHyphen = false; Segment.Put(file,' ',flgs); } } else { if(!flgs.hyphenFound) Segment.Put(file,ch,flgs); } } } if(!isFlatSpace(ch)) { if(ch != '\n' && !isSentencePunct(ch) && !wait) flgs.punctuationFound = 0; if(ch != '\n' && !isSemiPunct(ch) && !wait) flgs.semiPunctuationFound = 0; if(ch != '\n' && ch != '-' && flgs.hyphenFound && !wait) // A-bomb { int k; for(k = 0;k < flgs.hyphenFound;++k) Segment.Put(file,'-',flgs); if(spaceAfterHyphen) Segment.Put(file,' ',flgs); spaceAfterHyphen = false; flgs.hyphenFound = 0; Segment.Put(file,ch,flgs); } last = ch; /// } else if(flgs.hyphenFound && last != '\n') { spaceAfterHyphen = true; } if(!wait) { if( !isFlatSpace(ch) || !isFlatSpace(circularBuffer[ind(lastWordIndex-1)]) ) { circularBuffer[lastWordIndex] = (wchar_t)ch; lastWordIndex = inc(lastWordIndex); } } }
/* also called later, if charset-affecting modes change, for instance */ void vl_ctype_init(int print_lo, int print_hi) { #if OPT_LOCALE char *save_ctype = setlocale(LC_CTYPE, NULL); #endif int c; TRACE((T_CALLED "vl_ctype_init() lo=%d, hi=%d\n", print_lo, print_hi)); /* If we're using the locale functions, set our flags based on its * tables. Note that just because you have 'setlocale()' doesn't mean * that the tables are present or correct. But this is a start. * * NOTE: Solaris8 and some versions of M$ incorrectly classify tab as a * printable character (ANSI C says control characters are not printable). * Ignore that (the former fixes it in Solaris9). */ #if OPT_LOCALE TRACE(("wide_locale:%s\n", NonNull(vl_wide_enc.locale))); TRACE(("narrow_locale:%s\n", NonNull(vl_narrow_enc.locale))); TRACE(("current_locale:%s\n", NonNull(save_ctype))); if (vl_narrow_enc.locale) setlocale(LC_CTYPE, vl_narrow_enc.locale); else if (vl_wide_enc.locale) setlocale(LC_CTYPE, vl_wide_enc.locale); for (c = 0; c < N_chars; c++) { if (print_hi > 0 && c > print_hi) { vlCTYPE(c) = 0; } else if (okCTYPE2(vl_narrow_enc)) { vlCTYPE(c) = vl_ctype_bits(c, -TRUE); vl_uppercase[c] = (char) toupper(c); vl_lowercase[c] = (char) tolower(c); } else { /* fallback to built-in character tables */ if (okCTYPE2(vl_wide_enc)) { vlCTYPE(c) = vl_ctype_latin1[c]; } else { vlCTYPE(c) = vl_ctype_ascii[c]; } vl_uppercase[c] = (char) c; vl_lowercase[c] = (char) c; if (isAlpha(c)) { if (isUpper(c)) { vl_lowercase[c] = (char) (c ^ DIFCASE); } else { vl_uppercase[c] = (char) (c ^ DIFCASE); } } } } #else /* ! OPT_LOCALE */ (void) memset((char *) vl_chartypes_, 0, sizeof(vl_chartypes_)); /* control characters */ for (c = 0; c < ' '; c++) vlCTYPE(c) |= vl_cntrl; vlCTYPE(127) |= vl_cntrl; /* lowercase */ for (c = 'a'; c <= 'z'; c++) vlCTYPE(c) |= vl_lower; #if OPT_ISO_8859 for (c = 0xc0; c <= 0xd6; c++) vlCTYPE(c) |= vl_lower; for (c = 0xd8; c <= 0xde; c++) vlCTYPE(c) |= vl_lower; #endif /* uppercase */ for (c = 'A'; c <= 'Z'; c++) vlCTYPE(c) |= vl_upper; #if OPT_ISO_8859 for (c = 0xdf; c <= 0xf6; c++) vlCTYPE(c) |= vl_upper; for (c = 0xf8; c <= 0xff; c++) vlCTYPE(c) |= vl_upper; #endif /* * If you want to do this properly, compile-in locale support. */ for (c = 0; c < N_chars; c++) { vl_uppercase[c] = (char) c; vl_lowercase[c] = (char) c; if (isAlpha(c)) { if (isUpper(c)) { vl_lowercase[c] = (char) (c ^ DIFCASE); } else { vl_uppercase[c] = (char) (c ^ DIFCASE); } } } /* digits */ for (c = '0'; c <= '9'; c++) vlCTYPE(c) |= vl_digit; #ifdef vl_xdigit /* hex digits */ for (c = '0'; c <= '9'; c++) vlCTYPE(c) |= vl_xdigit; for (c = 'a'; c <= 'f'; c++) vlCTYPE(c) |= vl_xdigit; for (c = 'A'; c <= 'F'; c++) vlCTYPE(c) |= vl_xdigit; #endif /* punctuation */ for (c = '!'; c <= '/'; c++) vlCTYPE(c) |= vl_punct; for (c = ':'; c <= '@'; c++) vlCTYPE(c) |= vl_punct; for (c = '['; c <= '`'; c++) vlCTYPE(c) |= vl_punct; for (c = L_CURLY; c <= '~'; c++) vlCTYPE(c) |= vl_punct; #if OPT_ISO_8859 for (c = 0xa1; c <= 0xbf; c++) vlCTYPE(c) |= vl_punct; #endif /* printable */ for (c = ' '; c <= '~'; c++) vlCTYPE(c) |= vl_print; /* whitespace */ vlCTYPE(' ') |= vl_space; #if OPT_ISO_8859 vlCTYPE(0xa0) |= vl_space; #endif vlCTYPE('\t') |= vl_space; vlCTYPE('\r') |= vl_space; vlCTYPE('\n') |= vl_space; vlCTYPE('\f') |= vl_space; #endif /* OPT_LOCALE */ /* legal in pathnames */ vlCTYPE('.') |= vl_pathn; vlCTYPE('_') |= vl_pathn; vlCTYPE('~') |= vl_pathn; vlCTYPE('-') |= vl_pathn; vlCTYPE('/') |= vl_pathn; /* legal in "identifiers" */ vlCTYPE('_') |= vl_ident | vl_qident; vlCTYPE(':') |= vl_qident; #if SYS_VMS vlCTYPE('$') |= vl_ident | vl_qident; #endif c = print_lo; /* * Guard against setting printing-high before printing-low while we have a * buffer which may be repainted and possibly trashing the display. */ if (c == 0 && print_hi >= 254) c = 160; if (c < HIGHBIT) c = HIGHBIT; TRACE(("Forcing printable for [%d..min(%d,%d)]\n", c, print_hi - 1, N_chars - 1)); while (c <= print_hi && c < N_chars) vlCTYPE(c++) |= vl_print; #if DISP_X11 for (c = 0; c < N_chars; c++) { if (isPrint(c) && !gui_isprint(c)) { vlCTYPE(c) &= ~vl_print; } } #endif /* backspacers: ^H, rubout */ vlCTYPE('\b') |= vl_bspace; vlCTYPE(127) |= vl_bspace; /* wildcard chars for most shells */ vlCTYPE('*') |= vl_wild; vlCTYPE('?') |= vl_wild; #if !OPT_VMS_PATH #if SYS_UNIX vlCTYPE('~') |= vl_wild; #endif vlCTYPE(L_BLOCK) |= vl_wild; vlCTYPE(R_BLOCK) |= vl_wild; vlCTYPE(L_CURLY) |= vl_wild; vlCTYPE(R_CURLY) |= vl_wild; vlCTYPE('$') |= vl_wild; vlCTYPE('`') |= vl_wild; #endif /* ex mode line specifiers */ vlCTYPE(',') |= vl_linespec; vlCTYPE('%') |= vl_linespec; vlCTYPE('-') |= vl_linespec; vlCTYPE('+') |= vl_linespec; vlCTYPE(';') |= vl_linespec; vlCTYPE('.') |= vl_linespec; vlCTYPE('$') |= vl_linespec; vlCTYPE('\'') |= vl_linespec; /* fences */ vlCTYPE(L_CURLY) |= vl_fence; vlCTYPE(R_CURLY) |= vl_fence; vlCTYPE(L_PAREN) |= vl_fence; vlCTYPE(R_PAREN) |= vl_fence; vlCTYPE(L_BLOCK) |= vl_fence; vlCTYPE(R_BLOCK) |= vl_fence; #if OPT_VMS_PATH vlCTYPE(L_BLOCK) |= vl_pathn; vlCTYPE(R_BLOCK) |= vl_pathn; vlCTYPE(L_ANGLE) |= vl_pathn; vlCTYPE(R_ANGLE) |= vl_pathn; vlCTYPE('$') |= vl_pathn; vlCTYPE(':') |= vl_pathn; vlCTYPE(';') |= vl_pathn; #endif #if OPT_MSDOS_PATH vlCTYPE(BACKSLASH) |= vl_pathn; vlCTYPE(':') |= vl_pathn; #endif #if OPT_WIDE_CTYPES /* scratch-buffer-names (usually superset of vl_pathn) */ vlCTYPE(SCRTCH_LEFT[0]) |= vl_scrtch; vlCTYPE(SCRTCH_RIGHT[0]) |= vl_scrtch; vlCTYPE(' ') |= vl_scrtch; /* ...to handle "[Buffer List]" */ #endif for (c = 0; c < N_chars; c++) { if (!(isSpace(c))) vlCTYPE(c) |= vl_nonspace; if (isDigit(c)) vlCTYPE(c) |= vl_linespec; if (isAlpha(c) || isDigit(c)) vlCTYPE(c) |= vl_ident | vl_pathn | vl_qident; #if OPT_WIDE_CTYPES if (isSpace(c) || isPrint(c)) vlCTYPE(c) |= vl_shpipe; if (ispath(c)) vlCTYPE(c) |= vl_scrtch; #endif } #if OPT_LOCALE if (save_ctype != 0) (void) setlocale(LC_CTYPE, save_ctype); #endif returnVoid(); }
bool isAlNumAnd(char c) { return isAlpha(c) || isNum(c) || isAnd(c); }