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