void BaseHTMLParser::readUntilEndTag(const std::string& tag_name) { // [42] ETag ::= '</' Name S? '>' bool found = false; std::string tmp; std::string lower_tagname = tag_name; to_lower(lower_tagname); while (not found ) { readUntilDelimiterMark("</"); tmp = std::string(text.current, tag_name.size()); if (to_lower(tmp) != lower_tagname) { // This is not the tag we are looking for... // Keep looking... continue; } text += tag_name.size(); readSpace(); if (*text != '>'){ std::string msg = "While looking for the EndTag for " +\ tag_name; throw ParserEOFError(msg); } consumeToken(std::string(">")); // Yeah! The EndTag was found. We are done found = true; } }
int verify_username_by_user_list(void *elem, void *comp) { char *user = (char*)comp; t_users *elemd = (t_users*)elem; return (strcmp(to_lower(elemd->username), to_lower(user)) == 0); }
/** * Allows to check that the source and target languages are proper, * as the ones that this server instance supports. * @param source_lang the source language string, from the job request. * @param target_lang the target language string, from the job request. * @throws uva_exception in case the source or target language do not match. */ void check_source_target_languages(string source_lang, string target_lang) { //Check for an exact match if (m_params.m_source_lang != source_lang) { LOG_DEBUG1 << m_params.m_source_lang << " != " << source_lang << END_LOG; //If no exact match then lowercase (void) to_lower(source_lang); //Check for a match again if (m_params.m_source_lang_lower != source_lang) { LOG_DEBUG1 << m_params.m_source_lang_lower << " != " << source_lang << END_LOG; //If there is still no match then throw THROW_EXCEPTION(string("Unsupported source language: '") + source_lang + string("' the server only supports: '") + m_params.m_source_lang + string("'")); } } //Check for an exact match if (m_params.m_target_lang != target_lang) { LOG_DEBUG1 << m_params.m_target_lang << " != " << target_lang << END_LOG; //If no exact match then lowercase (void) to_lower(target_lang); //Check for a match again if (m_params.m_target_lang_lower != target_lang) { LOG_DEBUG1 << m_params.m_target_lang_lower << " != " << target_lang << END_LOG; //If there is still no match then throw THROW_EXCEPTION(string("Unsupported target language: '") + target_lang + string("' the server only supports: '") + m_params.m_target_lang + string("'")); } } }
/*** *** User functions ***/ int verify_username(void *elem, void *comp) { char *user = (char*)comp; char *elemd = (char*)elem; return (strcmp(to_lower(elemd), to_lower(user)) == 0); }
int main(void){ for(char i = 'a'; i <= 'z'; ++i){ assert(is_alpha(i)); assert(!is_digit(i)); assert(is_lower(i)); assert(!is_upper(i)); assert(to_lower(i) == i); assert(to_upper(i) != i); } for(char i = 'A'; i <= 'Z'; ++i){ assert(is_alpha(i)); assert(!is_digit(i)); assert(!is_lower(i)); assert(is_upper(i)); assert(to_lower(i) != i); assert(to_upper(i) == i); } for(char i = '0'; i <= '9'; ++i){ assert(!is_alpha(i)); assert(is_digit(i)); assert(!is_lower(i)); assert(!is_upper(i)); assert(to_lower(i) == i); assert(to_upper(i) == i); } printf("TEST SUCEEDED\n"); return 0; }
int dircmp_incase(char *s1, char *s2) { char _s1[strlen(s1)+1]; char _s2[strlen(s2)+1]; to_lower(s1, _s1); to_lower(s2, _s2); return dircmp(_s1, _s2); }
ini_t read_ini(const std::string& filename) { ini_t ini; std::ifstream istr(filename.c_str()); if(!istr) return ini; std::vector<std::string> lines; std::string temp; while(true) { if(!std::getline(istr,temp)) { if(istr.eof()) break; else throw std::runtime_error("Error while reading \""+filename+"\"."); } else { lines.push_back(temp); } } istr.close(); for(size_t ii=0;ii<lines.size();++ii) { if(lines.size()>0&&lines[ii][0]=='#') continue; std::string key; for(size_t jj=0;jj<lines[ii].size();++jj) { if(lines[ii][jj]=='=') break; else key+=lines[ii][jj]; } std::string value; for(size_t jj=key.size()+1;jj<lines[ii].size();++jj) value+=lines[ii][jj]; key=to_lower(strip_whitespace(key)); value=to_lower(strip_whitespace(value)); if(value.size()>0) ini[key]=value; } return ini; }
std::vector<StatusEffect*>::iterator Character::getStatusEffectIterator(const std::string& status) { for (auto it = m_status.begin(); it != m_status.end(); ++it) { if (to_lower((*it)->name) == to_lower(status)) return it; } return m_status.end(); }
static int fstrcmp(const char *s1, ucell fstr) { char *s2 = (char*)cell2pointer(fstr); while (*s1) { if ( to_lower(*(s1++)) != to_lower(*(s2++)) ) return -1; } return 0; }
void fbLocaleManager::ReadSystemSettings() { string systemSettings = C_SYSTEM_SETTINGS; if(!FileExists(systemSettings.c_str())) { systemSettings = C_ROOTFS; systemSettings.append(C_SYSTEM_SETTINGS); if(!FileExists(systemSettings.c_str())) { systemSettings.erase(); } } if(!systemSettings.empty()) { FILE* fp; if ((fp = fopen(systemSettings.c_str(), "r")) != NULL) { string language; string country; uint16_t bufSize = 80; char buffer[bufSize]; while (fgets(buffer, bufSize, fp) != NULL && (country.empty() || language.empty())) { char* p = strrchr(buffer, '\n'); if (p) { *p = '\0'; } if (strlen(buffer)) { if (language.empty() && strstr(buffer, C_LOCALE_LANGUAGE_PATTERN) == buffer) { language = buffer + strlen(C_LOCALE_LANGUAGE_PATTERN); language = trim(language); } else if (country.empty() && strstr(buffer, C_LOCALE_COUNTRY_PATTERN) == buffer) { country = buffer + strlen(C_LOCALE_COUNTRY_PATTERN); country = trim(country); } } } if (!language.empty()) { m_language = to_lower(language); } if (!country.empty()) { m_country = to_lower(country); } SetLocale(NULL, NULL); fclose(fp); } } }
static int nocase_strncmp(const char *a, const char *b, size_t len) { size_t i; for (i = 0; i < len; ++i, ++a, ++b) { if (*a != *b && to_lower(*a) != to_lower(*b)) return *a - *b; if (*a == '\0') return *b == '\0' ? 0 : -1; } return *a != '\0' ? 1 : 0; }
bool string_equal_no_case(char const* s1, char const* s2) { while (to_lower(*s1) == to_lower(*s2)) { if (*s1 == 0) return true; ++s1; ++s2; } return false; }
bool string_begins_no_case(char const* s1, char const* s2) { while (*s1 != 0) { if (to_lower(*s1) != to_lower(*s2)) return false; ++s1; ++s2; } return true; }
bool end_with(string fileName, string ext) { fileName = to_lower(fileName); ext = to_lower(ext); if (ext.length() >= fileName.length()) return false; for (int i=1; i<=ext.length(); i++) if (fileName[fileName.length()-i] != ext[ext.length()-i]) { return false; } return true; }
std::string http_auth::generate_signature(const swarm::http_request &request, const std::string &key) { const auto &url = request.url(); const auto &query = url.query(); const auto &original_headers = request.headers().all(); std::vector<swarm::headers_entry> headers; for (auto it = original_headers.begin(); it != original_headers.end(); ++it) { std::string name = to_lower(it->first); if (name.compare(0, 6, "x-ell-") == 0) { headers.emplace_back(std::move(name), it->second); } } std::sort(headers.begin(), headers.end()); std::vector<std::pair<std::string, std::string> > query_items; for (size_t i = 0; i < query.count(); ++i) { const auto &item = query.item(i); query_items.emplace_back(to_lower(item.first), item.second); } std::sort(query_items.begin(), query_items.end()); swarm::url result_url; result_url.set_path(url.path()); for (auto it = query_items.begin(); it != query_items.end(); ++it) { result_url.query().add_item(it->first, it->second); } std::string text = request.method(); text += '\n'; text += result_url.to_string(); text += '\n'; for (auto it = headers.begin(); it != headers.end(); ++it) { text += it->first; text += ':'; text += it->second; text += '\n'; } check_hash(key); check_hash(text); dnet_raw_id signature; char signature_str[DNET_ID_SIZE * 2 + 1]; dnet_digest_auth_transform_raw(text.c_str(), text.size(), key.c_str(), key.size(), signature.id, DNET_ID_SIZE); dnet_dump_id_len_raw(signature.id, DNET_ID_SIZE, signature_str); return signature_str; }
void PlayerCharacter::equip(const std::string& equipmentSlot, const std::string& itemName) { if (itemName.empty()) { m_equipment.erase(to_lower(equipmentSlot)); } else { m_equipment[to_lower(equipmentSlot)] = create_item(itemName, 1); } }
void fbLocaleManager::Init() { m_language = C_DEFAULT_LANGUAGE; m_country = C_DEFAULT_COUNTRY; to_lower(m_language); to_lower(m_country); SetLocale(NULL, NULL); m_default = m_locale; ReadSystemSettings(); }
void JabberClient::element_start(const char *el, const char **attr) { string element = to_lower(el); const char *id = NULL; if (m_depth){ if (m_curRequest){ m_curRequest->element_start(element.c_str(), attr); }else{ if (element == "iq"){ string id = get_attr("id", attr); if (id.empty()){ m_curRequest = new IqRequest(this); m_curRequest->element_start(element.c_str(), attr); }else{ list<ServerRequest*>::iterator it; for (it = m_requests.begin(); it != m_requests.end(); ++it){ if ((*it)->m_id == id) break; } if (it != m_requests.end()){ m_curRequest = *it; m_requests.erase(it); m_curRequest->element_start(element.c_str(), attr); }else{ log(L_DEBUG, "Request ID %s not found", id.c_str()); } } }else if (element == "presence"){ m_curRequest = new PresenceRequest(this); m_curRequest->element_start(element.c_str(), attr); }else if (element == "message"){ m_curRequest = new MessageRequest(this); m_curRequest->element_start(element.c_str(), attr); }else{ log(L_DEBUG, "Bad tag %s", element.c_str()); } } }else{ if (element == "stream:stream"){ for (const char **p = attr; *p; ){ string tag = to_lower(*(p++)); if (tag == "id"){ id = *p; break; } } } handshake(id); } m_depth++; }
void robot_config_t::from_file(const std::string& filename) { ini_t ini=read_ini(filename); for(ini_t::const_iterator iter=ini.begin();iter!=ini.end();++iter) { if(keys_m.count(to_lower(iter->first))>0) keys_m[to_lower(iter->first)]=to_lower(iter->second); else throw std::runtime_error("Unrecognized ini argument \""+iter->first+"\".\n"); } validate(); }
bool Dictionary::DeleteAWord(string word){ vector<string> wordsVect; bool wordFound = false; word = to_lower(word); string nextWord; ifstream fin; ofstream fout; string file = fileName(word); fin.open(file.c_str()); fin >> nextWord; while(fin){ if(fin.eof()) break; wordsVect.push_back(to_lower(nextWord)); fin >> nextWord; } fin.close(); for(int x = 0; x < wordsVect.size(); x++){ //check if word exists in file if(wordsVect[x] == word){ cout << "ERASING: " << wordsVect[x] << endl; //erase word from vector wordsVect.erase(wordsVect.begin() + x); //decrement word counts numOfWordsInFile[toupper(fileName(word)[0]-65)]--; totalWordsInDict--; wordFound = true; } } //open file and discard previous contents fout.open(file.c_str(), ofstream::trunc); //write vector to file for(int x = 0; x < wordsVect.size(); x++){ if(x == wordsVect.size()) fout << wordsVect[x]; else fout << wordsVect[x] << " "; } fout.close(); if(wordFound == true) return(success); else return(failure); }
bool icompare(const std::string& str, const std::string& ref) { size_t s1 = str.size(); size_t s2 = ref.size(); if(s1 != s2) { return false; } const char* ch1 = str.c_str(); const char* ch2 = ref.c_str(); for(size_t i=0;i<s1;++i) { if(to_lower(ch1[i]) != to_lower(ch2[i])) { return false; } } return true; }
void makeName() { fName = "rotated_rects"; if (fAA) { fName.append("_aa"); } else { fName.append("_bw"); } switch (fColorType) { case kConstantOpaque_ColorType: fName.append("_same_opaque"); break; case kConstantTransparent_ColorType: fName.append("_same_transparent"); break; case kChangingOpaque_ColorType: fName.append("_changing_opaque"); break; case kChangingTransparent_ColorType: fName.append("_changing_transparent"); break; case kAlternatingOpaqueAndTransparent_ColorType: fName.append("_alternating_transparent_and_opaque"); break; } fName.appendf("_%s", to_lower(SkXfermode::ModeName(fMode)).c_str()); }
bool trie_tree_check_string(trie_tree* tree, tchar* str) { assert(tree); assert(str); int state_index, base_index = 0; bool is_replace = false; while( str[base_index] ) { trie_tree_clear_state(tree); state_index = base_index; while( str[state_index] ) { TRIE_STATE state = trie_tree_check_state(tree, to_lower(str[state_index])); if( state == STATE_NULL ) break; if( state == STATE_WORD ) { for(int replace_index = base_index; replace_index<=state_index; replace_index++) str[replace_index] = L'*'; is_replace = true; base_index = state_index; break; } if( state == STATE_WORD_PREFIX) { for(int replace_index = base_index; replace_index<=state_index; replace_index++) str[replace_index] = L'*'; is_replace = true; } state_index++; } base_index++; } return is_replace; }
CGOGN_IO_API std::string vtk_data_type_to_cgogn_name_of_type(const std::string& vtk_type_str) { const std::string& data_type = to_lower(vtk_type_str); static const std::map<std::string, std::string> type_map{ {"char", name_of_type(int8())}, {"int8", name_of_type(int8())}, {"unsigned_char", name_of_type(uint8())}, {"uint8", name_of_type(uint8())}, {"short", name_of_type(int16())}, {"int16", name_of_type(int16())}, {"unsigned_short", name_of_type(uint16())}, {"uint16", name_of_type(uint16())}, {"int", name_of_type(int32())}, {"int32", name_of_type(int32())}, {"unsigned_int", name_of_type(uint32())}, {"uint32", name_of_type(uint32())}, {"long", name_of_type(int64())}, {"int64", name_of_type(int64())}, {"unsigned_long", name_of_type(uint64())}, {"uint64", name_of_type(uint64())}, {"float", name_of_type(float32())}, {"float32", name_of_type(float32())}, {"double", name_of_type(float64())}, {"float64", name_of_type(float64())} }; const auto it = type_map.find(data_type); if ( it != type_map.end()) return it->second; cgogn_log_error("vtk_data_type_to_cgogn_name_of_type") << "Unknown vtk type \"" << vtk_type_str << "\"."; return std::string(); }
void robot_config_t::validate() { for(key_t::const_iterator iter=keys_m.begin();iter!=keys_m.end();++iter) keys_m[iter->first]=to_lower(iter->second); for(size_t ii=0;ii<keys_m["robot"].size();++ii) if(keys_m["robot"][ii]=='\\') keys_m["robot"][ii]='/'; if(to_bool(keys_m["sim"])) { keys_m["delay_ms"]="100"; keys_m["baudrate"]="0"; } if(to_bool(keys_m["local"])) keys_m["superstar"]="http://localhost:8081"; if(to_bool(keys_m["dev"])) keys_m["superstar"]="http://test.robotmoose.com"; // if(keys_m["superstar"].size()>0&&keys_m["superstar"][keys_m["superstar"].size()-1]!='/') // keys_m["superstar"]+='/'; size_t slashes=0; for(size_t ii=0;ii<keys_m["robot"].size();++ii) if(keys_m["robot"][ii]=='/') ++slashes; if(slashes!=2) throw std::runtime_error("Invalid robot name \""+keys_m["robot"]+"\" - should be in the format \"school/name\"."); }
void g_scanner_scope_add_symbol (GScanner *scanner, guint scope_id, const gchar *symbol, gpointer value) { GScannerKey *key; g_return_if_fail (scanner != NULL); g_return_if_fail (symbol != NULL); key = g_scanner_lookup_internal (scanner, scope_id, symbol); if (!key) { key = g_new (GScannerKey, 1); key->scope_id = scope_id; key->symbol = g_strdup (symbol); key->value = value; if (!scanner->config->case_sensitive) { gchar *c; c = key->symbol; while (*c != 0) { *c = to_lower (*c); c++; } } g_hash_table_insert (scanner->symbol_table, key, key); } else key->value = value; }
static inline GScannerKey* g_scanner_lookup_internal (GScanner *scanner, guint scope_id, const gchar *symbol) { GScannerKey *key_p; GScannerKey key; key.scope_id = scope_id; if (!scanner->config->case_sensitive) { gchar *d; const gchar *c; key.symbol = g_new (gchar, strlen (symbol) + 1); for (d = key.symbol, c = symbol; *c; c++, d++) *d = to_lower (*c); *d = 0; key_p = g_hash_table_lookup (scanner->symbol_table, &key); g_free (key.symbol); } else { key.symbol = (gchar*) symbol; key_p = g_hash_table_lookup (scanner->symbol_table, &key); } return key_p; }
uint32_t convert_string_to_hexadecimal(_IN_ const char *str) { uint32_t value = 0; uint32_t multiplier = 1; for (const char *p = str + strlen(str) - 1; p >= str; p --) { int c = *p; if (!is_xdigit(c)) { FDC_ASSERT(p == str + 1 && c == 'x' && str[0] == '0', str[0], str[1]); break; } if (is_digit(c)) { value += (c - '0') * multiplier; } else { value += (to_lower(c) - 'a' + 10) * multiplier; } multiplier *= 16; } return value; }
/** * Returns true if word is in dictionary else false. */ bool check(const char* word) { char* lower_case = to_lower((char*) word); // index into our hashtable int index = hash_function(lower_case); node* check = NULL; check = hashtable[index]; while(check != NULL) { if(strcmp((const char*) check->word, lower_case) == 0) { free(lower_case); return true; } else check = check->next; } free(lower_case); return false; }
void LinkExtractor::safeHandleStartTag(const std::string& tag_name, attr_list_t& attrs, bool empty_element_tag) { LinkExtractor::link_tag_map_t::const_iterator _i; std::string _attr; std::string name = tag_name; to_lower(name); // Base should be treat separately if ((name == "base") and (attrs.find("href") != attrs.end()) ) { this->base = attrs["href"].str(); } else if ( name == "meta" ){ this->handleMetaTag(tag_name, attrs); } // Extract Links // - Is this a tag link? // - If so, is the corresponding attribute of this tag present? _i = this->LINK_TAGS.find(name); if ( (_i != this->LINK_TAGS.end()) and ( attrs.find( _attr = _i->second ) != attrs.end() )) { this->links.insert( attrs[_attr].str() ); } }