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);
}
