void DataValue::parse(const ustring &text, DataType type, void *value) { switch(type) { case data_int: case data_combo: case data_flags: case data_comboEx: *(int *)value = atoi(text.c_str()); break; case data_str: if(text[0] == '"') ((ustring*)value)->assign(text, 1, text.length() - 2); else if(text[0] == '#') parseStrList(text, value); else *(ustring*)value = text; break; case data_stock: case data_element: if(text[0] == '"') ((ustring*)value)->assign(text, 1, text.length() - 2); else *(ustring*)value = text; break; case data_real: *(double *)value = atof(text.c_str()); break; case data_data: { int i; static const int dtypes[] = { data_int, data_str, data_real }; for(int t = 0; t < 3; t++) if(strncmp(text.c_str(), dataNames[dtypes[t]], i = strlen(dataNames[dtypes[t]])) == 0) { ustring s = ustring(text, i+1, text.length() - i - 2); switch(t) { case 0: *(TData*)value = atoi(s.c_str()); break; case 1: *(TData*)value = s; break; case 2: *(TData*)value = atof(s.c_str()); break; } } break; } case data_list: parseStrList(text, value); break; case data_pixbuf: parsePixbuf(text, value); break; case data_array: parseArray(text, value); break; case data_color: ((TypeColor*)value)->set(text); break; case data_font: parseFont(text, value); break; default: ; } }
void CDate::Import(ustring a) { do { int dem = 0; int dk = 0; int j = 0; char** temp = new char*[3]; //Tạo con trỏ hai chiều kiểu char for(int i = 0; i < 3; i++) //Vòng lặp khởi tạo vùng nhớ cho biến temp[i] = new char[a.length()]; for(int i = 0; i < a.length(); i++) //Vòng lặp chạy từ cuối chuỗi { if(a[i] >= '0' && a[i] <= '9') //Nếu gặp phần tử là số thì thêm vào biến tạm thứ dem. { temp[dem][j] = a[i]; j++; } else //Nếu gặp thì tăng dem lên 1 để chuyển biến tạm và j = 0 để trở về vị trí ban đầu của biến tạm mới { dem++; j = 0; } } this->m_day = atoi(temp[0]); //Chuyển giá trị trong chuỗi thành kiểu nguyên và gán cho thuộc tính của con trỏ this this->m_month = atoi(temp[1]); //Tương tự this->m_year = atoi(temp[2]); //Tương tự } while(this->m_year < 0 || this->m_month < 0 || this->m_month > 12 || (CheckYear(this->m_year) == 0 && this->m_day > SizeMonth[this->m_month - 1] || this->m_day < 0) || (CheckYear(this->m_year) == 1 && this->m_day > _SizeMonth[this->m_month - 1] || this->m_day < 0)); //Điều kiện dùng của vòng lặp nhập thời gian }
void WindowsOutpost::send_line(const ustring & command) // Sends "command" to the windows outpost. { int result = 0; if (connected) { // Discard any previous reply. char buf[1024]; #ifdef WIN32 if (recv(sock, buf, sizeof(buf), 0)) ; if (send(sock, command.c_str(), command.length(), 0)) ; result = send(sock, "\n", 1, 0); #else if (read(sock, buf, sizeof(buf))) ; if (write(sock, command.c_str(), command.length())) ; result = write(sock, "\n", 1); #endif // Give some time to allow the reply to come back. g_usleep(1000000); } if (result < 0) { connected = false; #ifndef WIN32 perror(NULL); #endif log(_("Error sending data")); clear(); } }
void Highlight::searchwords_find_fast(GtkTextBuffer * textbuffer, GtkTextIter * beginbound, GtkTextIter * endbound, const ustring & searchword, bool casesensitive, vector < GtkTextIter > &wordstart, vector < GtkTextIter > &wordend) // Searches for words to highlight. For simple highligthing. // Is much faster than the slow routine, see there fore more information. { // Variable. GtkTextIter begin; GtkTextIter end; // Extract the line. ustring line = gtk_text_buffer_get_slice(textbuffer, beginbound, endbound, false); // Deal with case sensitivity. ustring case_considerate_search_word(searchword); if (!casesensitive) case_considerate_search_word = case_considerate_search_word.casefold(); // Go through the line looking for matches. for (unsigned int i = 0; i < line.length(); i++) { if (interrupt_thread) continue; ustring compareline(line.substr(i, searchword.length())); // Deal with case sensitivity. if (!casesensitive) compareline = compareline.casefold(); // Now compare. if (case_considerate_search_word == compareline) { // Get the iterators in the textbuffer that belong to this possible match. begin = *beginbound; gtk_text_iter_forward_chars(&begin, i); end = begin; gtk_text_iter_forward_chars(&end, searchword.length()); // Add the boundaries of the word to highlight. wordstart.push_back(begin); wordend.push_back(end); } } }
void TextSupervisor::Draw(const ustring &text, const TextStyle &style) { if(text.empty()) { IF_PRINT_WARNING(VIDEO_DEBUG) << "empty string was passed to function" << std::endl; return; } if(IsFontValid(style.font) == false) { IF_PRINT_WARNING(VIDEO_DEBUG) << "failed because font was invalid: " << style.font << std::endl; return; } FontProperties *fp = _font_map[style.font]; VideoManager->PushState(); // Break the string into lines and render the shadow and text for each line uint16 buffer[2048]; const uint16 NEWLINE = '\n'; size_t last_line = 0; do { // Find the next new line character in the string and save the line size_t next_line; for(next_line = last_line; next_line < text.length(); next_line++) { if(text[next_line] == NEWLINE) break; buffer[next_line - last_line] = text[next_line]; } buffer[next_line - last_line] = 0; last_line = next_line + 1; // If this line is empty, skip on to the next one if(buffer[0] == 0) { VideoManager->MoveRelative(0, -fp->line_skip * VideoManager->_current_context.coordinate_system.GetVerticalDirection()); continue; } // Save the draw cursor position before drawing this text VideoManager->PushMatrix(); // If text shadows are enabled, draw the shadow first if(style.shadow_style != VIDEO_TEXT_SHADOW_NONE) { VideoManager->PushMatrix(); const float dx = VideoManager->_current_context.coordinate_system.GetHorizontalDirection() * style.shadow_offset_x; const float dy = VideoManager->_current_context.coordinate_system.GetVerticalDirection() * style.shadow_offset_y; VideoManager->MoveRelative(dx, dy); _DrawTextHelper(buffer, fp, _GetTextShadowColor(style)); VideoManager->PopMatrix(); } // Now draw the text itself, restore the position of the draw cursor, and move the draw cursor one line down _DrawTextHelper(buffer, fp, style.color); VideoManager->PopMatrix(); VideoManager->MoveRelative(0, -fp->line_skip * VideoManager->_current_context.coordinate_system.GetVerticalDirection()); } while(last_line < text.length()); VideoManager->PopState(); } // void TextSupervisor::Draw(const ustring& text)
bool replace_text(ustring & line, const ustring & look_for, const ustring & replace_with) // Replaces some text. Returns true if any replacement was done. { bool replacements_done = false; size_t offposition = line.find (look_for); while (offposition != string::npos) { line.replace (offposition, look_for.length (), replace_with); offposition = line.find (look_for, offposition + replace_with.length ()); replacements_done = true; } return replacements_done; }
bool PubAddr::loadKeys(ustring Skey, ustring Ekey, int nonce, int extra) { std::unique_lock<std::shared_timed_mutex> mlock(this->mutex_); this->extra_bytes = extra; this->nonce_trials = nonce; this->pubEncryptionKey.clear(); this->pubSigningKey.clear(); int length = Ekey.length(); if (length == 64) { this->pubEncryptionKey += 0x04; this->pubEncryptionKey += Ekey; } else if (length == 65) { if (Ekey.c_str()[0] != 0x04) { mlock.unlock(); return false; } this->pubEncryptionKey += Ekey; } length = Skey.length(); if (length == 64) { this->pubSigningKey += 0x04; this->pubSigningKey += Skey; } else if (length == 65) { if (Skey.c_str()[0] != 0x04) { mlock.unlock(); return false; } this->pubSigningKey += Skey; } this->empty = false; mlock.unlock(); return true; }
bool replace_text_between(ustring & line, const ustring & start, const ustring & end, const ustring & replacement) // Replaces text that starts with "start" and ends with "end" with "replacement". // Returns true if replacement was done. { bool replacements_done = false; size_t beginpos = line.find(start); size_t endpos = line.find(end); while ((beginpos != string::npos) && (endpos != string::npos) && (endpos > beginpos)) { line.replace(beginpos, endpos - beginpos + end.length(), replacement); beginpos = line.find(start, beginpos + replacement.length()); endpos = line.find(end, beginpos + replacement.length()); replacements_done = true; } return replacements_done; }
int strtol(long &value, ustring str, long &value2, ustring str2, int base) { const char *nptr = str.c_str(); const char *nptr2 = str.c_str(); char *eptr, *eptr2; value = ::strtol(nptr, &eptr, base); value2 = ::strtol(nptr2, &eptr2, base); if ( (nptr==eptr) || (nptr2==eptr2) ) return -1; else if ( (eptr<(char*)nptr+str.length()) && (eptr2<(char*)nptr2+str2.length()) ) return 0; else return 1; }
ustringArrayT analyseWord (ustring str) { typedef bool (*_TrivialPointerToFunctions_) (ustring); ustringArrayT res(3); _TrivialPointerToFunctions_ testFuncs[3] = { isConsonant, isVowel, isConsonant }; // First part: Consonant 1 // Second part: Vowel // Third part: Consonant 2 for (int part = 0; part < 3; part++) { res[part] = ""; // This is safe due to short-circuit logic while (str.length () > 0 && testFuncs[part] (_(str[0]))) { res[part] += _(str[0]); str.replace (0, 1, ""); } } // Special case: "qu" and "gi" are considered consonants if (analyseWordCheckSpecialConsonants (res, "qu") || analyseWordCheckSpecialConsonants (res, "gi")) { res[0] += _(res[1][0]); res[1] = res[1].replace (0, 1, ""); } return res; }
float CFont::GetStringWidth( const ustring& text, bool offsetFirstCharacter /*= false*/ ) { float totalW = 0; uchar lastChar = 0; for ( int i = 0; i < text.length(); ++i ) { uchar c = text[i]; auto descIt = m_chars.find(c); if ( descIt == m_chars.end() ) { descIt = m_chars.find( -1 ); } auto & desc = descIt->second; if (i != 0 || offsetFirstCharacter) { totalW += desc.offset.x; } totalW += desc.xAdvance; auto kernIt = m_kernings.find( std::make_pair( lastChar, c ) ); if ( kernIt != m_kernings.end() ) { totalW += kernIt->second; } lastChar = c; } return totalW; }
ustring string_reverse(const ustring & s) { ustring returnvalue; for (int i = s.length() - 1; i >= 0; i--) returnvalue.append(s.substr(i, 1)); return returnvalue; }
// Heavy lifting of OSL regex operations. OSL_SHADEOP int osl_regex_impl2 (OSL::ShadingContext *ctx, ustring subject_, int *results, int nresults, ustring pattern, int fullmatch) { const std::string &subject (subject_.string()); boost::match_results<std::string::const_iterator> mresults; const boost::regex ®ex (ctx->find_regex (pattern)); if (nresults > 0) { std::string::const_iterator start = subject.begin(); int res = fullmatch ? boost::regex_match (subject, mresults, regex) : boost::regex_search (subject, mresults, regex); int *m = (int *)results; for (int r = 0; r < nresults; ++r) { if (r/2 < (int)mresults.size()) { if ((r & 1) == 0) m[r] = mresults[r/2].first - start; else m[r] = mresults[r/2].second - start; } else { m[r] = pattern.length(); } } return res; } else { return fullmatch ? boost::regex_match (subject, regex) : boost::regex_search (subject, regex); } }
int Dictionary::get_document_index (ustring dictionaryname) { DocMap::iterator dm = m_document_map.find(dictionaryname); int dindex; if (dm == m_document_map.end()) { dindex = m_documents.size(); m_document_map[dictionaryname] = dindex; pugi::xml_document *doc = new pugi::xml_document; m_documents.push_back (doc); pugi::xml_parse_result parse_result; if (boost::ends_with (dictionaryname.string(), ".xml")) { // xml file -- read it parse_result = doc->load_file (dictionaryname.c_str()); } else { // load xml directly from the string parse_result = doc->load_buffer (dictionaryname.c_str(), dictionaryname.length()); } if (! parse_result) { m_context->error ("XML parsed with errors: %s, at offset %d", parse_result.description(), parse_result.offset); m_document_map[dictionaryname] = -1; return -1; } } else { dindex = dm->second; } DASSERT (dindex < (int)m_documents.size()); return dindex; }
ustring lowerCase(const ustring & s) { // Make a lowercase copy of s string lower(s); for (size_t i = 0; i < s.length(); ++i) lower[i] = tolower(lower[i]); return lower; }
ustring upperCase(const ustring & s) { // Make an uppercase copy of s string upper(s); for (size_t i = 0; i < s.length(); ++i) upper[i] = toupper(upper[i]); return upper; }
void CGlobalRecords::wide2str16(const ustring& str1, u16string& str2) { ustring::const_iterator cBegin, cEnd; size_t len; str2.clear(); len = str1.length(); str2.reserve(len); cBegin = str1.begin(); cEnd = str1.end(); while(cBegin != cEnd) { str2.push_back((unsigned16_t)*cBegin++); } XL_ASSERT(str2.length() == str1.length()); }
uint64_t StringTable::addString (ustring str, ustring var_name) { ASSERT (m_ptr && "StringTable has not been initialized"); // The strings are laid out in the table as a struct: // // struct TableRep { // size_t len; // size_t hash; // char str[len+1]; // }; // Compute the size of the entry before adding it to the table size_t size = sizeof(size_t) + sizeof(size_t) + str.size() + 1; if (((m_offset + size) >= m_size)) { reallocTable(); } // It should be hard to trigger this assert, unless the table size is // very small and the string is very large. ASSERT (m_offset + size <= m_size && "String table allocation error"); int offset = getOffset(str.string()); if (offset < 0) { // Place the hash and length of the string before the characters size_t hash = str.hash(); cudaMemcpy (m_ptr + m_offset, (void*)&hash, sizeof(size_t), cudaMemcpyHostToDevice); m_offset += sizeof(size_t); size_t len = str.length(); cudaMemcpy (m_ptr + m_offset, (void*)&len, sizeof(size_t), cudaMemcpyHostToDevice); m_offset += sizeof(size_t); offset = m_offset; m_offset_map [str] = offset; m_name_map [str] = var_name; // Copy the raw characters to the table cudaMemcpy (m_ptr + m_offset, str.c_str(), str.size() + 1, cudaMemcpyHostToDevice); m_offset += str.size() + 1; // Align the offset for the next entry to 8-byte boundaries m_offset = (m_offset + 0x7u) & ~0x7u; } uint64_t addr = reinterpret_cast<uint64_t>(m_ptr + offset); // Optionally create an OptiX variable for the string. It's not necessary to // create a variable for strings that do not appear by name in compiled code // (in either the OSL library functions or in the renderer). if (! var_name.empty()) { m_optix_ctx [var_name.string()]->setUserData (8, &addr); } return addr; }
ustring replace(ustring source, ustring fromStr, ustring toStr, int offset, int times) { int total = 0; ustring::size_type pos=offset; while ( ( (pos = source.find(fromStr, pos)) < Glib::ustring::npos) && ( (times==0) || (total++<times) ) ) { source.replace(pos, fromStr.length(), toStr); pos+=toStr.size(); } return source; }
float CFont::GetLineWidth(const ustring& text, size_t start /*= 0*/) { size_t count = text.length()-start; for (int i = 0; i+start < text.size(); ++i) { if (text[i+start] == '\n') { count = i; break; } } return GetStringWidth(text.substr(start, count)); }
void Text::append_next( const ustring& ustr ) { data.push_back( ustr ); height = font_height * data.size(); int new_length = ustr.length(); if( new_length > width ) { width = new_length; } }
int strtod(double &value, ustring str) { const char *nptr = str.c_str(); char *eptr; value = ::strtod(nptr, &eptr); if (nptr==eptr) return -1; else if (eptr<(char*)nptr+str.length()) return 0; else return 1; }
int strtol(long &value, ustring str, int base) { const char *nptr = str.c_str(); char *eptr; value = ::strtol(nptr, &eptr, base); if (nptr==eptr) return -1; else if (eptr<(char*)nptr+str.length()) return 0; else return 1; }
/** Search the page for some text. \param text the text to search \param[in,out] r the area where to start search, which will be set to the area of the match (if any) \param direction in which direction search for text \param case_sensitivity whether search in a case sensitive way \param rotation the rotation assumed for the page */ bool page::search(const ustring &text, rectf &r, search_direction_enum direction, case_sensitivity_enum case_sensitivity, rotation_enum rotation) const { const size_t len = text.length(); std::vector<Unicode> u(len); for (size_t i = 0; i < len; ++i) { u[i] = text[i]; } const GBool sCase = case_sensitivity == case_sensitive ? gTrue : gFalse; const int rotation_value = (int)rotation * 90; bool found = false; double rect_left = r.left(); double rect_top = r.top(); double rect_right = r.right(); double rect_bottom = r.bottom(); TextOutputDev td(NULL, gTrue, 0, gFalse, gFalse); d->doc->doc->displayPage(&td, d->index + 1, 72, 72, rotation_value, false, true, false); TextPage *text_page = td.takeText(); switch (direction) { case search_from_top: found = text_page->findText(&u[0], len, gTrue, gTrue, gFalse, gFalse, sCase, gFalse, gFalse, &rect_left, &rect_top, &rect_right, &rect_bottom); break; case search_next_result: found = text_page->findText(&u[0], len, gFalse, gTrue, gTrue, gFalse, sCase, gFalse, gFalse, &rect_left, &rect_top, &rect_right, &rect_bottom); break; case search_previous_result: found = text_page->findText(&u[0], len, gFalse, gTrue, gTrue, gFalse, sCase, gTrue, gFalse, &rect_left, &rect_top, &rect_right, &rect_bottom); break; } text_page->decRefCnt(); r.set_left(rect_left); r.set_top(rect_top); r.set_right(rect_right); r.set_bottom(rect_bottom); return found; }
void DataValue::parseArray(const ustring &text, void *value) { ArrayValue *arr = (ArrayValue*)value; int i = 1; // skip [ while (text[i] != ']') { i++; // skip ' int p = text.find('\'', i); void *v = arr->add(ustring(text, i, p - i)); i = p + 2; // skip = p = text.find(',', i); if(p == -1) p = text.length() - 1; parse(ustring(text, i, p - i), arr->type, v); i = p; if(text[i] == ',') i++; } }
InputMethodT makeIMFromString (ustring imStr) { InputMethodT im; _size_t_ eolPos; ustring transPortion; ustring specialToken = (imStr.find (" -> ") != ustring::npos) ? _(" -> ") : _(" "); while (imStr.length () > 1) { eolPos = imStr.find ("\n"); transPortion = imStr.substr (0, eolPos); imStr = imStr.replace (0, eolPos + 1, ""); im = addTransformation (im, transPortion.replace (1, specialToken.length (), "")); } return standardizeIM (im); }
void findCommon(vector<ustring>& vec, const ustring& search, unsigned int& atchar) { if (atchar > search.length()) return; for (vector<ustring>::const_iterator i = vec.begin(); i != vec.end(); ++i) { if (atchar > i->length() || search.substr(0, atchar).lowercase() != i->substr(0, atchar).lowercase()) { atchar--; return; } } findCommon(vec, search, ++atchar); }
sstring base64_encode(ustring const& input) { BIO* b64 = BIO_new(BIO_f_base64()); BIO* bmem = BIO_new(BIO_s_mem()); b64 = BIO_push(b64, bmem); BIO_write(b64, input.c_str(), input.length()); BIO_flush(b64); BUF_MEM* bptr; BIO_get_mem_ptr(b64, &bptr); sstring buffer(bptr->data, bptr->length - 1); BIO_free_all(b64); return buffer; }
void CategorizeLine::clear_out_any_marker(ustring & line) { size_t startpos = 0; startpos = line.find("\\", startpos); while (startpos != string::npos) { ustring marker; size_t endpos = line.find_first_of(" *", startpos); if (endpos == string::npos) { marker = line.substr(startpos + 1, line.length() - startpos); } else { marker = line.substr(startpos + 1, endpos - startpos - 1); } line.erase(startpos, marker.length() + 2); startpos++; startpos = line.find("\\", startpos); } }
void CheckMatchingPairs::check_matched_pairs(ustring & text) // Checks on matched pairs. Output any problems found. { for (unsigned int i = 0; i < text.length(); i++) { // Get the unicode character; gunichar unichar; unichar = g_utf8_get_char(text.substr(i, 1).c_str()); // If we found a mirror character, investigate further. gunichar mirror; if (g_unichar_get_mirror_char(unichar, &mirror)) { // Do we ignore this one? if (ignores.find(unichar) != ignores.end()) continue; // See whether this one opens or closes a pair. if (gopeners.find(unichar) != gopeners.end()) { // It opens: Add data. MatchingPairOpener opener(text.substr(i, 1), unichar, book, chapter, verse, get_context(text, i)); openers.push_back(opener); continue; } else { // It closes: check for previously seen opener. bool give_message = false; if (openers.empty()) { give_message = true; } if (!give_message) { if (openers[openers.size() - 1].unichar == mirror) { // Remove last one. openers.pop_back(); } else { // Flag message. give_message = true; } } if (give_message) { // Give message; message(book, chapter, verse, _("Pair not opened: ") + get_context(text, i)); } } } } }