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