static SearchCase inspect_case (const char *p, const char *pend) { gboolean is_upper = TRUE; gboolean is_capital = TRUE; gboolean has_letter = FALSE; gboolean expect_upper = TRUE; for (; p < pend; p = g_utf8_next_char (p)) { gunichar c = g_utf8_get_char (p); if (g_unichar_isalpha (c)) { has_letter = TRUE; if (!g_unichar_isupper (c)) { is_upper = FALSE; } if (expect_upper ? !g_unichar_isupper (c) : !g_unichar_islower (c)) { is_capital = FALSE; } expect_upper = FALSE; } else expect_upper = TRUE; } if (has_letter) { if (is_upper) return SC_Upper; if (is_capital) return SC_Capital; } return SC_Other; }
IdePatternSpec * ide_pattern_spec_new (const gchar *needle) { IdePatternSpec *self; const gchar *tmp; g_return_val_if_fail (needle, NULL); self = g_new0 (IdePatternSpec, 1); self->ref_count = 1; self->needle = g_strdup (needle); self->parts = g_strsplit (needle, " ", 0); self->case_sensitive = FALSE; for (tmp = needle; tmp; tmp = g_utf8_next_char (tmp)) { if (g_unichar_isupper (g_utf8_get_char (tmp))) { self->case_sensitive = TRUE; break; } } return self; }
static inline bool str_contains_upper(const char *s) { while (*s) { if(g_unichar_isupper(g_utf8_get_char(s))) return true; s = g_utf8_next_char(s); } return false; }
/* value is the match value suitable for exact match if required */ static int header_match(const char *value, const char *match, camel_search_match_t how) { const unsigned char *p; int vlen, mlen; gunichar c; if (how == CAMEL_SEARCH_MATCH_SOUNDEX) return header_soundex (value, match); vlen = strlen(value); mlen = strlen(match); if (vlen < mlen) return FALSE; /* from dan the man, if we have mixed case, perform a case-sensitive match, otherwise not */ p = (const unsigned char *)match; c = camel_utf8_getc (&p); while (c) { if (g_unichar_isupper(c)) { switch (how) { case CAMEL_SEARCH_MATCH_EXACT: return strcmp(value, match) == 0; case CAMEL_SEARCH_MATCH_CONTAINS: return strstr(value, match) != NULL; case CAMEL_SEARCH_MATCH_STARTS: return strncmp(value, match, mlen) == 0; case CAMEL_SEARCH_MATCH_ENDS: return strcmp(value + vlen - mlen, match) == 0; default: break; } return FALSE; } c = camel_utf8_getc (&p); } switch (how) { case CAMEL_SEARCH_MATCH_EXACT: return camel_ustrcasecmp(value, match) == 0; case CAMEL_SEARCH_MATCH_CONTAINS: return camel_ustrstrcase(value, match) != NULL; case CAMEL_SEARCH_MATCH_STARTS: return camel_ustrncasecmp(value, match, mlen) == 0; case CAMEL_SEARCH_MATCH_ENDS: return camel_ustrcasecmp(value + vlen - mlen, match) == 0; default: break; } return FALSE; }
gchar * mousepad_util_utf8_strcapital (const gchar *str) { gunichar c; const gchar *p; gchar *buf; GString *result; gboolean upper = TRUE; g_return_val_if_fail (g_utf8_validate (str, -1, NULL), NULL); /* create a new string */ result = g_string_sized_new (strlen (str)); /* walk though the string */ for (p = str; *p != '\0'; p = g_utf8_next_char (p)) { /* get the unicode char */ c = g_utf8_get_char (p); /* only change the case of alpha chars */ if (g_unichar_isalpha (c)) { /* check case */ if (upper ? g_unichar_isupper (c) : g_unichar_islower (c)) { /* currect case is already correct */ g_string_append_unichar (result, c); } else { /* convert the case of the char and append it */ buf = upper ? g_utf8_strup (p, 1) : g_utf8_strdown (p, 1); g_string_append (result, buf); g_free (buf); } /* next char must be lowercase */ upper = FALSE; } else { /* append the char */ g_string_append_unichar (result, c); /* next alpha char uppercase after a space */ upper = g_unichar_isspace (c); } } /* return the result */ return g_string_free (result, FALSE); }
static inline gboolean contains_uppercase_letters (const gchar *str, gint len) { const gchar *p; for (p = str; len == -1 ? *p : p < str + len; p = g_utf8_next_char (p)) { if (g_unichar_isupper (g_utf8_get_char (p))) return TRUE; } return FALSE; }
static gboolean str_has_uppercase (const char *str) { while (str != NULL && *str != '\0') { gunichar c; c = g_utf8_get_char (str); if (g_unichar_isupper (c)) return TRUE; str = g_utf8_next_char (str); } return FALSE; }
static gdouble quality_func (MatePasswordDialog *dialog, const char *text, gpointer ptr) { const char *p; gsize length; int uppercase = 0, symbols = 0, numbers = 0, strength; gunichar uc; if (text == NULL) return 0.0; /* Get the length */ length = g_utf8_strlen (text, -1); /* Count the number of number, symbols and uppercase chars */ for (p = text; *p; p = g_utf8_find_next_char (p, NULL)) { uc = g_utf8_get_char (p); if (g_unichar_isdigit (uc)) { numbers++; } else if (g_unichar_isupper (uc)) { uppercase++; } else if (g_unichar_islower (uc)) { /* Not counted */ } else if (g_unichar_isgraph (uc)) { symbols++; } } if (length > 5) length = 5; if (numbers > 3) numbers = 3; if (symbols > 3) symbols = 3; if (uppercase > 3) uppercase = 3; strength = (length * 10 - 20) + (numbers * 10) + (symbols * 15) + (uppercase * 10); strength = CLAMP (strength, 0, 100); return (double) strength / 100.0; }
gchar * mousepad_util_utf8_stropposite (const gchar *str) { gunichar c; const gchar *p; gchar *buf; GString *result; g_return_val_if_fail (g_utf8_validate (str, -1, NULL), NULL); /* create a new string */ result = g_string_sized_new (strlen (str)); /* walk though the string */ for (p = str; *p != '\0'; p = g_utf8_next_char (p)) { /* get the unicode char */ c = g_utf8_get_char (p); /* only change the case of alpha chars */ if (g_unichar_isalpha (c)) { /* get the opposite case of the char */ if (g_unichar_isupper (c)) buf = g_utf8_strdown (p, 1); else buf = g_utf8_strup (p, 1); /* append to the buffer */ g_string_append (result, buf); g_free (buf); } else { /* append the char */ g_string_append_unichar (result, c); } } /* return the result */ return g_string_free (result, FALSE); }
static void uspell_dict_add_to_session (EnchantDict * me, const char *const word, size_t len) { uSpell *manager; wide_t buf[MAXCHARS]; utf8_t myWord[MAXCHARS]; int length, index; manager = reinterpret_cast<uSpell *>(me->user_data); manager->acceptWord((const utf8_t *)word); if (len >= MAXCHARS) return; // too long; can't reasonably convert // see if we want to acceptWord(uppercase(myWord)) if (!(manager->theFlags & uSpell::upperLower)) return; // non-case language length = utf8_wide(buf, (const utf8_t *)word, MAXCHARS); for (index = 0; index < length; index++) { if (g_unichar_isupper(buf[index])) return; // case-sensitive word buf[index] = g_unichar_toupper(buf[index]); } wide_utf8(myWord, MAXCHARS, buf, length); manager->acceptWord(myWord); } // uspell_dict_add_to_session
void CheckCapitalization::check_suspicious_capitalization(ustring & text) /* Checks on suspicious capitalization, like "bOat" or "BOat". There are exceptions to this check. */ { // Load text into buffer. ustring text2(text); text2.append(" "); GtkTextBuffer *textbuffer; textbuffer = gtk_text_buffer_new(NULL); gtk_text_buffer_set_text(textbuffer, text2.c_str(), -1); // Iterators. GtkTextIter startiter, enditer; // Check all separate words. gtk_text_buffer_get_start_iter(textbuffer, &enditer); while (gtk_text_iter_forward_word_end(&enditer)) { startiter = enditer; gtk_text_iter_backward_word_start(&startiter); vector < bool > capspattern; unsigned int capscount = 0; GtkTextIter iter = startiter; while (gtk_text_iter_in_range(&iter, &startiter, &enditer)) { bool upper = g_unichar_isupper(gtk_text_iter_get_char(&iter)); capspattern.push_back(upper); if (upper) capscount++; gtk_text_iter_forward_char(&iter); } // No further checking if words are too short. if (capspattern.size() < 2) continue; // No further checking if only small letters. if (capscount == 0) continue; // No further checking if all capitals. if (capscount == capspattern.size()) continue; // No further checking if first letter capitalized only. if ((capspattern[0]) && (capscount == 1)) continue; // Ok, there could be a problem of mixed capitalization. // Get the prefix before the first capital, and the suffix after it. ustring word = gtk_text_iter_get_text(&startiter, &enditer); ustring uncapitalized_prefix; ustring capitalized_suffix; for (unsigned int i = 1; i < capspattern.size(); i++) { if (capspattern[i]) { uncapitalized_prefix = word.substr(0, i); capitalized_suffix = word.substr(i, word.length() - i); break; } } // See whether the suffix is properly capitalized. unsigned int suffix_capital_count = 0; for (unsigned int i = 0; i < capitalized_suffix.length(); i++) { if (g_unichar_isupper(g_utf8_get_char(capitalized_suffix.substr(i, 1).c_str()))) suffix_capital_count++; } bool suffix_properly_capitalized = false; if (suffix_capital_count == 1) suffix_properly_capitalized = true; if (suffix_capital_count == capitalized_suffix.length()) suffix_properly_capitalized = true; // Give message and continue if capitalization error in suffix, but only // if this so-called wrongly capitalized suffix has not been approved af. if (!suffix_properly_capitalized) { if (capitalized_suffixes.find(capitalized_suffix) == capitalized_suffixes.end()) { mixed_capitalization_message(word); continue; } } // No further checking if this uncapitalized prefix is in the list, // or any is allowed. if (uncapitalized_prefixes.find(uncapitalized_prefix) != uncapitalized_prefixes.end()) continue; if (allow_any_uncapitalized_prefixes) continue; // Ok, not in the list. Try again with lower case initial. ustring initial = uncapitalized_prefix.substr(0, 1); initial = initial.casefold(); uncapitalized_prefix.replace(0, 1, initial); if (uncapitalized_prefixes.find(uncapitalized_prefix) != uncapitalized_prefixes.end()) continue; // No further checking if the suffix is in the list of approved suffixes. if (capitalized_suffixes.find(capitalized_suffix) != capitalized_suffixes.end()) continue; // Ok, not found, but it could be this suffix is in all capitals. Handle that. initial = capitalized_suffix.substr(0, 1); capitalized_suffix.erase(0, 1); capitalized_suffix = capitalized_suffix.casefold(); capitalized_suffix.insert(0, initial); if (capitalized_suffixes.find(capitalized_suffix) != capitalized_suffixes.end()) continue; // Ok, it appears we've got an error here -> give message. mixed_capitalization_message(word); } // Free memory g_object_unref(textbuffer); }
void CheckCapitalization::check_capitalization(vector < int >&chapters, vector < ustring > &verses, ustring & text, vector < size_t > &pointers, bool end_check) /* Check capitalization in text. If "end_check" is true, it also check for final sentence closing. */ { /* Note that this at first used gtk_text_iter_starts_sentence (&iter) and gtk_text_iter_ends_sentence (&iter), but these functions are not good enough, because do not work in several cases, like e.g. in the following line, it does not indicate the end of the sentence: As soon as the leaders of the tribes of Israel took their places, the Israelites said, “How could such a horrible thing happen?" Therefore we use other means to check sentences. */ // No check if there's no text. if (trim(text).empty()) return; // Some variables needed. bool expect_capital_now = false; bool expect_capital_caused_by_reference = false; gunichar previous_char = 0; int localchapter = 0; ustring localverse = "0"; GtkTextBuffer *textbuffer; textbuffer = gtk_text_buffer_new(NULL); gtk_text_buffer_set_text(textbuffer, text.c_str(), -1); GtkTextIter iter; gtk_text_buffer_get_start_iter(textbuffer, &iter); bool going = true; while (going) { // Get the unicode character. gunichar unichar = gtk_text_iter_get_char(&iter); // See whether to expect a capital now. if (punctuation_followed_by_capitals_set.find(unichar) != punctuation_followed_by_capitals_set.end()) { // Ok, expect capital. expect_capital_now = true; expect_capital_caused_by_reference = false; // Was this expectation caused by a reference? if (is_reference(iter)) expect_capital_caused_by_reference = true; } // If we expect a capital, and we find one, no longer look for one. if (expect_capital_now) { if (g_unichar_isupper(unichar)) { expect_capital_now = false; } } // If we expect a capital, and we get lower case, that might be trouble. if (expect_capital_now) { if (g_unichar_islower(unichar)) { // There is no trouble if it follows a character after which to ignore lower case. if (ignore_lower_case_following_set.find(previous_char) != ignore_lower_case_following_set.end()) { expect_capital_now = false; } // If the lowercase character follows an abbreviation, there is no trouble either. GtkTextIter iter2 = iter; gtk_text_iter_backward_word_start(&iter2); GtkTextIter iter3 = iter2; gtk_text_iter_forward_word_end(&iter3); gtk_text_iter_forward_char(&iter3); ustring abbreviation = gtk_text_iter_get_text(&iter2, &iter3); if (abbreviations.find(abbreviation) != abbreviations.end()) { expect_capital_now = false; } // If it follows a reference, there is no trouble. if (expect_capital_caused_by_reference) expect_capital_now = false; // Ok, give message. if (expect_capital_now) { // Determine chapter and verse. get_chapter_and_verse(chapters, verses, pointers, iter, localchapter, localverse); message(book, localchapter, localverse, _("Capital expected: ") + get_context(iter)); } // Only give one message about missing capitals in this context. expect_capital_now = false; } } // Store this characters as the previous characters for the next round. if (g_unichar_isgraph(unichar)) previous_char = unichar; // Next round. going = gtk_text_iter_forward_char(&iter); } // The sentence should be ended with proper punctuation. if (end_check) { if (expect_capital_now) if (g_unichar_isdigit(previous_char)) expect_capital_now = false; if (!expect_capital_now) { message(book, chapter, verse, _("Unended sentence: ") + get_context(iter)); } } // Free memory g_object_unref(textbuffer); }