char *MYRTLEXP StrCase( char *str,msCaseTypes type ) { int n; if ( !str || *str == 0 ) return str; switch( type ){ case mscLower: StrLwr( str ); break; case mscUpper: StrUpr( str ); break; case mscCapitalize: StrLwr( str ); str[0] = ToUpper(str[0]); break; case mscUpLower: for ( n = 0; str[n]; n++ ) if ( isLower(str[n]) ) return str; return StrCase( str,mscLower ); case mscLoUpper: for ( n = 0; str[n]; n++ ) if ( isUpper(str[n]) ) return str; return StrCase( str,mscUpper ); case mscInvert: for ( n = 0; str[n]; n++ ) if ( isUpper(str[n]) ) str[n] = ToLower(str[n]); else str[n] = ToUpper(str[n]); break; } return str; }
static bool differentSeparated(register char *s1, register char *s2) { register char c1, c2; if ( *s1 != *s2 || *s1 == EOS ) fail; c1 = *++s1, c2 = *++s2; while(c1 && c1 == c2) { if ((c1 = *++s1) == '_') { c1 = *++s1; } else { if (isLower(s1[-1]) && isUpper(c1)) c1 = makeLower(c1); } if ((c2 = *++s2) == '_') { c2 = *++s2; } else { if (isLower(s2[-1]) && isUpper(c2)) c2 = makeLower(c2); } } if (c1 == EOS && c2 == EOS) succeed; fail; }
void sh_htoi(char* params){ int len = strLen(params)-1; if(len < 3 || params[0] != '0' || params[1] != 'x'){ ttprintln("htoi param must start with `0x`"); return; } reverseInPlace(params+2); len -= 2; int i; int sum = 0; for(i = 0; i < len; i++){ if(isAlpha(params[i+2])){ if(isLower(params[i+2]) && params[i+2] <= 'f'){ sum += pow(16,i) * (params[i+2]-'a'+10); } else if(isUpper(params[i+2]) && params[i+2] <= 'F'){ sum += pow(16,i) * (params[i+2]-'A'+10); } else { ttprintln("improperly formed hex"); return; } } else sum += pow(16,i) * (params[i+2]-'0'); } ttprintIntln(sum); }
int Unicode::toLower(int ch) { if (isUpper(ch)) return static_cast<int>(UCD_OTHERCASE(static_cast<unsigned>(ch))); else return ch; }
char shiftChar(char c, int n){ int cLower = isLower(c); int cUpper = isUpper(c); while(n >= 26) { n -= 26; } while(n <0) { n += 26; } if (cLower == 1) { if ((c + n) > 'z') { char diff = 'z' - c; c = 'a' + n - 1 - diff; return c; } else { return c + n; } } else if (cUpper == 1) { if ((c+n) > 'Z') { char diff = 'Z' - c; c = 'A' + n - 1 - diff; return c; } else { return c + n; } } else { return c; } }
int Unicode::toLower(int ch) { if (isUpper(ch)) return static_cast<int>(_pcre_ucp_othercase(static_cast<unsigned>(ch))); else return ch; }
// // Check if string is entirely in lowerCase // bool STR_String::IsLower() const { for (int i=0; i<Len; i++) if (isUpper(pData[i])) return false; return true; }
// // Check if string is entirely in lowerCase // bool STR_String::IsLower() const { for (int i = 0; i < this->m_len; i++) if (isUpper(this->m_data[i])) return false; return true; }
std::string toLower(std::string s) { int i; for (i = 0; i < s.length(); ++i) { if (isUpper(s[i])) { s[i] += ASCII_DELTA; } } return s; }
//大小写分开 void func1(char a[], int low, int high) { while (low < high) { while (isUpper(a[high]) && low < high) high--; while (isLower(a[low]) && low < high) low++; swap(a[low], a[high]); } }
void paragraph::considerHyphenation(flags & flgs) { bool vowel = false; bool nonAlphaFound = false; int cnt = 0; int j = 0; int punkpos = -1; bool locAllLower = true; bool locAllUpper = true; for(j = 0;j != waited && isFlatSpace(circularBuffer[j]);++j) circularBuffer[j] = ' '; for(;j != waited;++j) { ++cnt; int k = circularBuffer[j]; if(isAlpha(k)) { if(!isLower(k)) locAllLower = false; if(!isUpper(k)) locAllUpper = false; } else if(k != '-') { if(punkpos < 0 && isPunct(k)) punkpos = cnt; else if(!isSemiPunct(k)) nonAlphaFound = true; break; } if(isVowel(k)) vowel = true; } if(dropHyphen) { // Require agreement of case if(allLower) { if(!locAllLower) dropHyphen = false; } else { if(!locAllUpper) dropHyphen = false; } } if((!nonAlphaFound && cnt >= 2 && punkpos < 0) || punkpos == cnt) { if(!dropHyphen || !vowel) Segment.Put(file,'-',flgs); for(j = 0;j != waited;++j) Segment.Put(file,circularBuffer[j],flgs); } else hyphenate(flgs); }
u_int32_t MrfData_LCD::pos2LCD( const int& p ) { // upper line starts with 128, lower one with 192 u_int32_t value = ( isUpper() ) ? 128 : 192; if ( p > 0 && p < 16 ) { value += p; } return value; }
char *lowerCase(char *s) { char *tmp; tmp = s; while (s && *s) { if (isUpper(*s)) *s += 32; s++; } return (tmp); }
std::string CostFactory::camelCasedToUnderscored(const std::string& name) { std::string result; for (int i=0; i<name.size(); i++) { if (i && isUpper(name[i])) result += std::string("_") + toLower(name[i]); else result += toLower(name[i]); } return result; }
int main (int argc, char *argv[]){ //int c = sizeof("one"); int a = isUpper('a'); int b = isLower('a'); int c = isUpper('Z'); int d = isLower('Z'); char r = shiftChar('.', 1); printf("%d %d %d %d\n", a,b,c,d); printf("%c\n", r); char *message = strdup("M! K fobi pkcd, iod kd dswoc pbecdbkdsxq vkxqekqo."); printf("message : %s\n", message); encryptInPlace(message,-10); printf("ciphertext : %s\n\n", message); char *message1 = strdup("M! K fobi pkcd, iod kd dswoc pbecdbkdsxq vkxqekqo."); printf("message : %s\n", message1); char *ciphertext = encrpytNewMemory(message1,-10); printf("ciphertext : %s\n", ciphertext); free(ciphertext); printf("ciphertext : %s\n", ciphertext); test(); return 0; }
int main(int argc, char* argv[]) { char c; c = getchar(); while ( c != EOF) { if (isUpper(c) == 0) c = c + 32; printf("%c",c); c = getchar(); } return 0; }
/* * Lower case region. Zap all of the upper * case characters in the region to lower case. Use * the region code to set the limits. Scan the buffer, * doing the changes. Call "lineSetChanged" to ensure that * redisplay is done in all buffers. Bound to * "C-X C-L". */ int lowerRegion(int f, int n) { meLine *line ; int loffs ; meInt lline ; register meUByte c; register int s; meRegion region; if((s=getregion(®ion)) <= 0) return (s); if((s=bufferSetEdit()) <= 0) /* Check we can change the buffer */ return s ; line = frameCur->windowCur->dotLine ; loffs = frameCur->windowCur->dotOffset ; lline = frameCur->windowCur->dotLineNo ; frameCur->windowCur->dotLine = region.line ; frameCur->windowCur->dotOffset = region.offset ; frameCur->windowCur->dotLineNo = region.lineNo ; while (region.size--) { if((c = meLineGetChar(frameCur->windowCur->dotLine, frameCur->windowCur->dotOffset)) == '\0') { frameCur->windowCur->dotLine = meLineGetNext(frameCur->windowCur->dotLine); frameCur->windowCur->dotOffset = 0; frameCur->windowCur->dotLineNo++ ; } else { if(isUpper(c)) { lineSetChanged(WFMAIN); #if MEOPT_UNDO meUndoAddRepChar() ; #endif c = toggleCase(c) ; meLineSetChar(frameCur->windowCur->dotLine, frameCur->windowCur->dotOffset, c); } (frameCur->windowCur->dotOffset)++ ; } } frameCur->windowCur->dotLine = line ; frameCur->windowCur->dotOffset = loffs ; frameCur->windowCur->dotLineNo = lline ; return meTRUE ; }
void LSystem::buildSentence() { int count = 0; sentence = startSymbol; while ( count < levels ) { string new_sentence; for (unsigned int i = 0; i < sentence.size(); ++i) { char ch = sentence[i]; if ( isUpper(ch) ) { new_sentence += grammar.find(ch)->second; } else if ( ch == '+' || ch == '-' ) new_sentence+= ch; else if ( ch == '[' || ch == ']' ) new_sentence+= ch; else if ( ch == 'f' ) new_sentence+= ch; } sentence = new_sentence; ++count; } }
int main() { //a = 97 //z = 122 //A = 65 //Z = 90 char input[50]; puts("Enter type a single letter"); gets(input); if (isLower(input[0]) == true) { input[0] -= 32; } else if (isUpper(input[0]) == true) { input[0] += 32; } puts(input); }
static char * subWord(register char *s, register char *store) { *store++ = makeLower(*s); s++; for(;;) { if (*s == EOS) { *store = EOS; return s; } if (*s == '_') { *store = EOS; return ++s; } if (isLower(s[-1]) && isUpper(s[0]) ) { *store = EOS; return s; } *store++ = *s++; } }
CapitalisationAlgorithms::CapitalisationAlgorithms() { add({ "Upper", "Capitalisation", [](std::string input, std::vector<std::string> /*params*/, bool /*ignoreCase*/, bool /*reverseOutput*/) -> std::string { return boost::locale::to_upper(input); } }); add({ "Lower", "Capitalisation", [](std::string input, std::vector<std::string> /*params*/, bool /*ignoreCase*/, bool /*reverseOutput*/) -> std::string { return boost::locale::to_lower(input); } }); add({ "Title", "Capitalisation", [](std::string input, std::vector<std::string> /*params*/, bool /*ignoreCase*/, bool /*reverseOutput*/) -> std::string { return boost::locale::to_title(input); } }); add({ "Toggle", "Capitalisation", [](std::string input, std::vector<std::string> /*params*/, bool /*ignoreCase*/, bool /*reverseOutput*/) -> std::string { std::stringstream stream; boost::locale::boundary::ssegment_index segmentIndex(boost::locale::boundary::character, std::begin(input), std::end(input)); for (const auto& segment : segmentIndex) { stream << (isUpper(segment.str()) ? boost::locale::to_lower(segment.str()) : boost::locale::to_upper(segment.str())); } return stream.str(); } }); }
int digitValue(int b, int c) { int v; if ( b == 0 ) return c; /* 0'c */ if ( b == 1 ) return -1; if ( b <= 10 ) { v = c - '0'; if ( v < b ) return v; return -1; } if ( c <= '9' ) return c - '0'; if (isUpper(c)) c = toLower(c); c = c - 'a' + 10; if ( c < b && c >= 10 ) return c; return -1; }
static int regDecodeMode (int *modep, meUByte *modeStr) { int mode = *modep; /* The mode */ int ii, jj ; /* Local loop counter */ meUByte *ss, cc ; /* Get the mode out */ if (modeStr != NULL) { for (ii = 0; (cc=modeStr[ii]) != '\0'; ii++) { if((ss=meStrchr(meRegModeList,toLower(cc))) == NULL) return mlwrite(MWABORT|MWPAUSE,(meUByte *)"Illegal Registry mode [%c]",cc) ; jj = (1 << ((int)(ss - meRegModeList))) ; if(isUpper(cc)) mode &= ~jj ; else mode |= jj ; } } *modep = mode; return meTRUE; }
void CheckNullPointer::nullPointerByCheckAndDeRef() { // Check if pointer is NULL and then dereference it.. // used to check if a variable is a pointer. // TODO: Use isPointer? std::set<unsigned int> pointerVariables; for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) { if (Token::Match(tok, "* %var% [;,)=]")) pointerVariables.insert(tok->next()->varId()); else if (Token::simpleMatch(tok, "if (")) { // TODO: investigate false negatives: // - handle "while"? // - if there are logical operators // - if (x) { } else { ... } // If the if-body ends with a unknown macro then bailout { // goto the end parenthesis const Token *endpar = tok->next()->link(); const Token *endbody = Token::simpleMatch(endpar, ") {") ? endpar->next()->link() : 0; if (endbody && Token::Match(endbody->tokAt(-3), "[;{}] %var% ;") && isUpper(endbody->tokAt(-2)->str())) continue; } // vartok : token for the variable const Token *vartok = 0; if (Token::Match(tok, "if ( ! %var% )|&&")) vartok = tok->tokAt(3); else if (Token::Match(tok, "if|while ( %var% )|&&")) vartok = tok->tokAt(2); else continue; // variable id for pointer const unsigned int varid(vartok->varId()); if (varid == 0) continue; const unsigned int linenr = vartok->linenr(); // Check if variable is a pointer. TODO: Use isPointer? if (pointerVariables.find(varid) == pointerVariables.end()) continue; // if this is true then it is known that the pointer is null bool null = true; // start token = inside the if-body const Token *tok1 = tok->next()->link()->tokAt(2); // indentlevel inside the if-body is 1 unsigned int indentlevel = 1; if (Token::Match(tok, "if|while ( %var% )|&&")) { // pointer might be null null = false; // start token = first token after the if/while body tok1 = tok1->previous()->link(); tok1 = tok1 ? tok1->next() : NULL; if (!tok1) continue; // indentlevel at the base level is 0 indentlevel = 0; } // Name of the pointer const std::string &pointerName = vartok->str(); // Count { and } for tok2 for (const Token *tok2 = tok1; tok2; tok2 = tok2->next()) { if (tok2->str() == "{") ++indentlevel; else if (tok2->str() == "}") { if (indentlevel == 0) break; --indentlevel; if (null && indentlevel == 0) { // skip all "else" blocks because they are not executed in this execution path while (Token::simpleMatch(tok2, "} else {")) tok2 = tok2->tokAt(2)->link(); null = false; } } if (Token::Match(tok2, "goto|return|continue|break|throw|if|switch")) { if (Token::Match(tok2, "return * %varid%", varid)) nullPointerError(tok2, tok->strAt(3), linenr); break; } // parameters to sizeof are not dereferenced if (Token::Match(tok2, "decltype|sizeof (")) { tok2 = tok2->next()->link(); continue; } // calling unknown function (abort/init).. if (Token::simpleMatch(tok2, ") ;") && (Token::Match(tok2->link()->tokAt(-2), "[;{}] %var% (") || Token::Match(tok2->link()->tokAt(-5), "[;{}] ( * %var% ) ("))) { break; } if (tok2->varId() == varid) { // unknown: this is set to true by isPointerDeRef if // the function fails to determine if there // is a dereference or not bool unknown = false; if (Token::Match(tok2->previous(), "[;{}=] %var% = 0 ;")) ; else if (CheckNullPointer::isPointerDeRef(tok2, unknown)) nullPointerError(tok2, pointerName, linenr); else break; } } } } }
char SimpleString::ToLower(char ch) { return isUpper(ch) ? (char)((int)ch + ('a' - 'A')) : ch; }
bool isAlpha(char c){ return (isLower(c) or isUpper(c)); }
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(); }
/* static bool testRoman(const char * rom) { int result; parseRoman(128); for(const char * p = rom;*p;++p) { result = parseRoman(*p); if(result == T) return true; else if(result == F) return false; } result = parseRoman(0); if(result == T) return true; else return false; } static void testRomans() { const char * numbers[] = {"" ,"i" ,"ii" ,"iii" ,"iv" ,"v" ,"vi" ,"vii" ,"viii" ,"ix" ,"x" ,"xi" ,"xiv" ,"xix" ,"mmcdxcviii" ,"MMCDXCVIII" ,"ci" ,"mi" ,"viv" ,"viiii" ,"xxc" ,"ic" ,"lil" ,"mil" ,"MMMCDXLIV" ,"MMMCDxliv" ,0 }; for(const char ** q = numbers;*q;++q) { printf("%s\t:",*q); if(testRoman(*q)) printf("OK\n"); else printf("..\n"); } } */ void textSource::updateFlags(wint_t ch,flags & flgs) { if(ch == '-') hyphens++; else hyphens = 0; if(!nrNonSpaceBytes) { if(!isUpper(ch) && !allNumber) /* 1. omejitev odvisno od. ==> 1 . omejitev odvisno od . because the 'header' 1. seems to be a list (or section) number. It is not likely starting a sentence, even though the first character is lower case. */ WriteParAfterHeadingOrField = false; wordComing = true; lastCharIsSemipunct = false; //evidently trivial: nrNonSpaceBytes = 0; nrNoStartCaps = 0; if( flgs.hyphenFound || flgs.semiPunctuationFound || ( ( ( !flgs.punctuationFound && !isUpper(ch) ) || flgs.in_abbreviation || flgs.person_name == initial ) && flgs.writtentoline ) ) { /* h har netop været vært for en institut- dag på Institut for Medier, Erkendelse */ nrStartCaps = -10; // Smaller chance that line starting here is a headline. allcaps = false; } else { nrStartCaps = 0; allcaps = true; } allNumber = !isFlatSpace(ch); lowerRoman = false; upperRoman = false; arabic = false; parseRoman(128); } if(isFlatSpace(ch)) { wordComing = true; int result = parseRoman(0); if(result == F) { upperRoman = false; lowerRoman = false; } parseRoman(128); } else { lastCharIsSemipunct = isSemiPunct(ch); if(!isLower(ch)) { if(wordComing) { if(isUpper(ch)) ++nrStartCaps; } if(allNumber) { if(!lowerRoman && !arabic && strchr("IVXLCDM",ch)) { int result = parseRoman(ch); allNumber = upperRoman = (result != F); } else { allNumber = false; } } } else { if(!strchr("ivxlcdm-/().:0123456789",ch)) allNumber = false; if(allNumber) { if(strchr("-/().:",ch)) { lowerRoman = false; upperRoman = false; arabic = false; } else { if(upperRoman) { allNumber = false; } else if(!arabic && strchr("ivxlcdm",ch)) { int result = parseRoman(ch); allNumber = lowerRoman = (result != F); } else if(!lowerRoman && strchr("0123456789",ch)) { arabic = true; } else { allNumber = false; } } } if(wordComing && !allNumber) // 'iv. The Big Dipper' should be o.k. { if(!isUpper(ch)) ++nrNoStartCaps; } if(!allNumber) allcaps = false; // 'iv. THE BIG DIPPER' should be o.k. } nrNonSpaceBytes++; wordComing = false; } }
/* Never was great formulating =P */ bool CWordFilter::apply(CPlayer *pPlayer, CBuffer &pBuffer, int pCheck) { bool logsave = false, rctell = false; CBuffer start; CStringList found; int pos = 0, wc = 0; for (int i = 0; i < WordList.count(); i++) { WordMatch *word = (WordMatch *)WordList[i]; if (!word->check[pCheck]) continue; for (int j = 0; j < pBuffer.length(); j++) { for (int k = 0; k < word->match.length(); k++) { char c1 = pBuffer[j + k]; char c2 = word->match[k]; if (c2 != '?' && (isUpper(c2) && c2 != c1) || (isLower(c2) && toLower(c2) != toLower(c1))) { if (wc >= word->precision) { found.add(start); for (int l = 0; l < (int)sizeof(word->action); l++) { if (!word->action[l]) continue; switch (l) { case FILTERA_LOG: if (logsave) break; logsave = true; if (pPlayer != NULL) errorOut("wordfilter.txt", CBuffer() << pPlayer->accountName << " has used rude words while chatting: " << start); break; case FILTERA_REPLACE: pos = pBuffer.find(' ', j); pos = (pos == -1 ? start.length() : pos-j+1); for (int m = 0; m < pos; m++) pBuffer.replace(j + m, '*'); break; case FILTERA_TELLRC: if (rctell) break; rctell = true; if (pPlayer != NULL) sendRCPacket(CPacket() << (char)DRCLOG << pPlayer->accountName << " has used rude words while chatting: " << start); break; case FILTERA_WARN: pBuffer = (word->warnmessage.length() > 0 ? word->warnmessage : warnmessage); break; case FILTERA_JAIL: // kinda useless...? break; case FILTERA_BAN: if (pPlayer != NULL) { CBuffer pLog = CBuffer() << "\n" << getTimeStr(0) << "\n" << pPlayer->accountName << " has used rude words while chatting: " << start; pPlayer->setBan(pLog, true); } break; } } } start.clear(); wc = 0; break; } start.writeChar(c1); wc++; } } } return (found.count() > 0); }