inline CharAcceptor const& shell_quote_chars_iter(CharAcceptor const& chars, CharForwardIter i, CharForwardIter end, bool quote_empty=true) { if (i==end) { if (quote_empty) { chars('"'); chars('"'); } } else if (std::find_if(i, end, is_shell_special<char>)==end) { for(;i!=end;++i) chars(*i); } else { chars('"'); for(;i!=end;++i) { char c=*i; if (needs_shell_escape_in_quotes(c)) chars('\\'); chars(c); } chars('"'); } return chars; }
void alignedNormalizeUnicodeString(icu::UnicodeString const& u, IcuNormalizer2Ptr normalizer, ITakeAlignedChars& out) { // TODO: test Position start = 0; int32 len = u.length(), pos; UErrorCode err = U_ZERO_ERROR; int nfcPrefixLen = normalizer->spanQuickCheckYes(u, err); assert(U_SUCCESS(err)); assert(len >= 0 && nfcPrefixLen >= 0); TokenSpan span; span.first = 0; icu::StringCharacterIterator it(u); while ((pos = it.getIndex()) < nfcPrefixLen) { assert(it.hasNext()); Unicode c = it.next32PostInc(); span.second = span.first + 1; out.takeWithSpan(c, span); ++span.first; } icu::UnicodeString remainder(u.tempSubString(nfcPrefixLen)), normalized; CharsFromUnicodeStringImpl chars(remainder); // TODO: docs say normalizeSecondAndAppend IcuNormalizeByChunks<CharsFromUnicodeStringImpl> norm(chars, normalizer); norm.takeAllWithSpan(out); }
// write XPM image data static bool write_xpm_image(const QImage &sourceImage, QIODevice *device, const QString &fileName) { if (!device->isWritable()) return false; QImage image; if (sourceImage.depth() != 32) image = sourceImage.convertToFormat(QImage::Format_RGB32); else image = sourceImage; QMap<QRgb, int> colorMap; int w = image.width(), h = image.height(), ncolors = 0; int x, y; // build color table for(y=0; y<h; y++) { QRgb * yp = (QRgb *)image.scanLine(y); for(x=0; x<w; x++) { QRgb color = *(yp + x); if (!colorMap.contains(color)) colorMap.insert(color, ncolors++); } } // number of 64-bit characters per pixel needed to encode all colors int cpp = 1; for (int k = 64; ncolors > k; k *= 64) { ++cpp; // limit to 4 characters per pixel // 64^4 colors is enough for a 4096x4096 image if (cpp > 4) break; } QString line; // write header QTextStream s(device); s << "/* XPM */" << endl << "static char *" << fbname(fileName) << "[]={" << endl << '\"' << w << ' ' << h << ' ' << ncolors << ' ' << cpp << '\"'; // write palette QMap<QRgb, int>::Iterator c = colorMap.begin(); while (c != colorMap.end()) { QRgb color = c.key(); if (image.format() != QImage::Format_RGB32 && !qAlpha(color)) line.sprintf("\"%s c None\"", xpm_color_name(cpp, *c)); else line.sprintf("\"%s c #%02x%02x%02x\"", xpm_color_name(cpp, *c), qRed(color), qGreen(color), qBlue(color)); ++c; s << ',' << endl << line; } // write pixels, limit to 4 characters per pixel line.truncate(cpp*w); for(y=0; y<h; y++) { QRgb * yp = (QRgb *) image.scanLine(y); int cc = 0; for(x=0; x<w; x++) { int color = (int)(*(yp + x)); QByteArray chars(xpm_color_name(cpp, colorMap[color])); line[cc++] = QLatin1Char(chars[0]); if (cpp > 1) { line[cc++] = QLatin1Char(chars[1]); if (cpp > 2) { line[cc++] = QLatin1Char(chars[2]); if (cpp > 3) { line[cc++] = QLatin1Char(chars[3]); } } } } s << ',' << endl << '\"' << line << '\"'; } s << "};" << endl; return (s.status() == QTextStream::Ok); }
MyOstream & GBString::InstanceToOStream(MyOstream & os) const { os << chars(); return os; };
result_t ParseJsonNumber(v8::Local<v8::Value> &retVal) { bool negative = false; int32_t beg_pos = position_; if (c0_ == '-') { Advance(); negative = true; } if (c0_ == '0') { Advance(); if (IsDecimalDigit(c0_)) return ReportUnexpectedCharacter(); } else { int32_t i = 0; int32_t digits = 0; if (c0_ < '1' || c0_ > '9') return ReportUnexpectedCharacter(); do { i = i * 10 + c0_ - '0'; digits++; Advance(); } while (IsDecimalDigit(c0_)); if (c0_ != '.' && c0_ != 'e' && c0_ != 'E' && digits < 10) { SkipWhitespace(); retVal = v8::Int32::New(isolate->m_isolate, negative ? -i : i); return 0; } } if (c0_ == '.') { Advance(); if (!IsDecimalDigit(c0_)) return ReportUnexpectedCharacter(); do { Advance(); } while (IsDecimalDigit(c0_)); } if (AsciiAlphaToLower(c0_) == 'e') { Advance(); if (c0_ == '-' || c0_ == '+') Advance(); if (!IsDecimalDigit(c0_)) return ReportUnexpectedCharacter(); do { Advance(); } while (IsDecimalDigit(c0_)); } int32_t length = position_ - beg_pos; double number; std::string chars(source_ + beg_pos, length); number = atof(chars.c_str()); SkipWhitespace(); retVal = v8::Number::New(isolate->m_isolate, number); return 0; }
Bytes(const void * source, size_t size) : m_data(size) { const auto * sourceChars = reinterpret_cast<const Byte *>(source); std::copy(sourceChars, sourceChars + size, chars()); }
void copyTo(void * destination) const { std::copy(chars(), chars() + size(), static_cast<char*>(destination)); }
bool TeXCodes::contains(QString k) { return chars().contains(k); }
void SpellChecker::advanceToNextMisspelling(bool startBeforeSelection) { // The basic approach is to search in two phases - from the selection end to the end of the doc, and // then we wrap and search from the doc start to (approximately) where we started. // Start at the end of the selection, search to edge of document. Starting at the selection end makes // repeated "check spelling" commands work. VisibleSelection selection(m_frame.selection().selection()); RefPtr<Range> spellingSearchRange(rangeOfContents(m_frame.document())); bool startedWithSelection = false; if (selection.start().deprecatedNode()) { startedWithSelection = true; if (startBeforeSelection) { VisiblePosition start(selection.visibleStart()); // We match AppKit's rule: Start 1 character before the selection. VisiblePosition oneBeforeStart = start.previous(); setStart(spellingSearchRange.get(), oneBeforeStart.isNotNull() ? oneBeforeStart : start); } else { setStart(spellingSearchRange.get(), selection.visibleEnd()); } } Position position = spellingSearchRange->startPosition(); if (!isEditablePosition(position)) { // This shouldn't happen in very often because the Spelling menu items aren't enabled unless the // selection is editable. // This can happen in Mail for a mix of non-editable and editable content (like Stationary), // when spell checking the whole document before sending the message. // In that case the document might not be editable, but there are editable pockets that need to be spell checked. position = firstEditableVisiblePositionAfterPositionInRoot(position, m_frame.document()).deepEquivalent(); if (position.isNull()) return; Position rangeCompliantPosition = position.parentAnchoredEquivalent(); spellingSearchRange->setStart(rangeCompliantPosition.deprecatedNode(), rangeCompliantPosition.deprecatedEditingOffset(), IGNORE_EXCEPTION); startedWithSelection = false; // won't need to wrap } // topNode defines the whole range we want to operate on ContainerNode* topNode = highestEditableRoot(position); // FIXME: lastOffsetForEditing() is wrong here if editingIgnoresContent(highestEditableRoot()) returns true (e.g. a <table>) spellingSearchRange->setEnd(topNode, lastOffsetForEditing(topNode), IGNORE_EXCEPTION); // If spellingSearchRange starts in the middle of a word, advance to the next word so we start checking // at a word boundary. Going back by one char and then forward by a word does the trick. if (startedWithSelection) { VisiblePosition oneBeforeStart = startVisiblePosition(spellingSearchRange.get(), DOWNSTREAM).previous(); if (oneBeforeStart.isNotNull()) setStart(spellingSearchRange.get(), endOfWord(oneBeforeStart)); // else we were already at the start of the editable node } if (spellingSearchRange->collapsed()) return; // nothing to search in // We go to the end of our first range instead of the start of it, just to be sure // we don't get foiled by any word boundary problems at the start. It means we might // do a tiny bit more searching. Node* searchEndNodeAfterWrap = spellingSearchRange->endContainer(); int searchEndOffsetAfterWrap = spellingSearchRange->endOffset(); int misspellingOffset = 0; GrammarDetail grammarDetail; int grammarPhraseOffset = 0; RefPtr<Range> grammarSearchRange = nullptr; String badGrammarPhrase; String misspelledWord; bool isSpelling = true; int foundOffset = 0; String foundItem; RefPtr<Range> firstMisspellingRange = nullptr; if (unifiedTextCheckerEnabled()) { grammarSearchRange = spellingSearchRange->cloneRange(); foundItem = TextCheckingHelper(spellCheckerClient(), spellingSearchRange).findFirstMisspellingOrBadGrammar(isGrammarCheckingEnabled(), isSpelling, foundOffset, grammarDetail); if (isSpelling) { misspelledWord = foundItem; misspellingOffset = foundOffset; } else { badGrammarPhrase = foundItem; grammarPhraseOffset = foundOffset; } } else { misspelledWord = TextCheckingHelper(spellCheckerClient(), spellingSearchRange).findFirstMisspelling(misspellingOffset, false, firstMisspellingRange); grammarSearchRange = spellingSearchRange->cloneRange(); if (!misspelledWord.isEmpty()) { // Stop looking at start of next misspelled word CharacterIterator chars(grammarSearchRange.get()); chars.advance(misspellingOffset); grammarSearchRange->setEnd(chars.range()->startContainer(), chars.range()->startOffset(), IGNORE_EXCEPTION); } if (isGrammarCheckingEnabled()) badGrammarPhrase = TextCheckingHelper(spellCheckerClient(), grammarSearchRange).findFirstBadGrammar(grammarDetail, grammarPhraseOffset, false); } // If we found neither bad grammar nor a misspelled word, wrap and try again (but don't bother if we started at the beginning of the // block rather than at a selection). if (startedWithSelection && !misspelledWord && !badGrammarPhrase) { spellingSearchRange->setStart(topNode, 0, IGNORE_EXCEPTION); // going until the end of the very first chunk we tested is far enough spellingSearchRange->setEnd(searchEndNodeAfterWrap, searchEndOffsetAfterWrap, IGNORE_EXCEPTION); if (unifiedTextCheckerEnabled()) { grammarSearchRange = spellingSearchRange->cloneRange(); foundItem = TextCheckingHelper(spellCheckerClient(), spellingSearchRange).findFirstMisspellingOrBadGrammar(isGrammarCheckingEnabled(), isSpelling, foundOffset, grammarDetail); if (isSpelling) { misspelledWord = foundItem; misspellingOffset = foundOffset; } else { badGrammarPhrase = foundItem; grammarPhraseOffset = foundOffset; } } else { misspelledWord = TextCheckingHelper(spellCheckerClient(), spellingSearchRange).findFirstMisspelling(misspellingOffset, false, firstMisspellingRange); grammarSearchRange = spellingSearchRange->cloneRange(); if (!misspelledWord.isEmpty()) { // Stop looking at start of next misspelled word CharacterIterator chars(grammarSearchRange.get()); chars.advance(misspellingOffset); grammarSearchRange->setEnd(chars.range()->startContainer(), chars.range()->startOffset(), IGNORE_EXCEPTION); } if (isGrammarCheckingEnabled()) badGrammarPhrase = TextCheckingHelper(spellCheckerClient(), grammarSearchRange).findFirstBadGrammar(grammarDetail, grammarPhraseOffset, false); } } if (!badGrammarPhrase.isEmpty()) { // We found bad grammar. Since we only searched for bad grammar up to the first misspelled word, the bad grammar // takes precedence and we ignore any potential misspelled word. Select the grammar detail, update the spelling // panel, and store a marker so we draw the green squiggle later. ASSERT(badGrammarPhrase.length() > 0); ASSERT(grammarDetail.location != -1 && grammarDetail.length > 0); // FIXME 4859190: This gets confused with doubled punctuation at the end of a paragraph RefPtr<Range> badGrammarRange = TextIterator::subrange(grammarSearchRange.get(), grammarPhraseOffset + grammarDetail.location, grammarDetail.length); m_frame.selection().setSelection(VisibleSelection(badGrammarRange.get(), SEL_DEFAULT_AFFINITY)); m_frame.selection().revealSelection(); m_frame.document()->markers().addMarker(badGrammarRange.get(), DocumentMarker::Grammar, grammarDetail.userDescription); } else if (!misspelledWord.isEmpty()) { // We found a misspelling, but not any earlier bad grammar. Select the misspelling, update the spelling panel, and store // a marker so we draw the red squiggle later. RefPtr<Range> misspellingRange = TextIterator::subrange(spellingSearchRange.get(), misspellingOffset, misspelledWord.length()); m_frame.selection().setSelection(VisibleSelection(misspellingRange.get(), DOWNSTREAM)); m_frame.selection().revealSelection(); spellCheckerClient().updateSpellingUIWithMisspelledWord(misspelledWord); m_frame.document()->markers().addMarker(misspellingRange.get(), DocumentMarker::Spelling); } }
//credit for conversion function(with a minor tweak) http://stackoverflow.com/a/2687562 std::vector< bool > get_bits(unsigned long x, int numBits) { std::string chars(std::bitset< sizeof(long) * CHAR_BIT >(x) .to_string(char(0), char(1))); chars = chars.substr(chars.length()-numBits, chars.length()); return std::vector< bool >(chars.begin(), chars.end()); }
dInteger dString::hash() const { return uALGO::hashFromByteSequence((dByte*)chars(), length() * sizeof(TCHAR)); }
int String::endsWith(const char* szEnd) const { if (szStr_ == 0) { return 0; } String sSuffix = subString(chars() - UTF8_CharLen(szEnd)); return sSuffix == szEnd; }
void SnapshotLoader::load(ConcurrentTableSharedStore& s) { // This could share code with apc_load_impl_compressed, but that function // should go away together with the shared object format. { std::vector<KeyValuePair> ints(read32()); for (auto& item : ints) { item.key = readString().begin(); s.constructPrime(read64(), item); } s.prime(ints); } { std::vector<KeyValuePair> chars(read32()); for (auto& item : chars) { item.key = readString().begin(); switch (static_cast<SnapshotBuilder::CharBasedType>(read<char>())) { case SnapshotBuilder::kSnapFalse: s.constructPrime(false, item); break; case SnapshotBuilder::kSnapTrue: s.constructPrime(true, item); break; case SnapshotBuilder::kSnapNull: s.constructPrime(uninit_null(), item); break; default: assert(false); break; } } s.prime(chars); } auto numStringBased = read32(); CHECK(numStringBased == SnapshotBuilder::kNumStringBased); for (int i = 0; i < numStringBased; ++i) { auto type = static_cast<SnapshotBuilder::StringBasedType>(i); std::vector<KeyValuePair> items(read32()); for (auto& item : items) { item.key = readString().begin(); auto data = readString(); String value(data.begin(), data.size(), CopyString); switch (type) { case SnapshotBuilder::kSnapString: s.constructPrime(value, item, false); break; case SnapshotBuilder::kSnapObject: s.constructPrime(value, item, true); break; case SnapshotBuilder::kSnapThrift: { Variant success; Variant v = HHVM_FN(fb_unserialize)(value, ref(success)); if (same(success, false)) { throw Exception("bad apc archive, fb_unserialize failed"); } s.constructPrime(v, item); break; } case SnapshotBuilder::kSnapOther: { Variant v = unserialize_from_string(value); if (same(v, false)) { throw Exception("bad apc archive, unserialize_from_string failed"); } s.constructPrime(v, item); break; } default: assert(false); break; } } s.prime(items); } { const char* disk = m_begin + header().diskOffset; std::vector<KeyValuePair> items(read32()); for (auto& item : items) { item.key = readString().begin(); item.sSize = read32(); item.sAddr = const_cast<char*>(disk); disk += abs(item.sSize) + 1; // \0 } assert(disk == m_begin + m_size); s.prime(items); } assert(m_cur == m_begin + header().diskOffset); // Keys have been copied, so don't need that part any more. madvise(const_cast<char*>(m_begin), header().diskOffset, MADV_DONTNEED); }
Note* NoteFactory::dropNote(const QMimeData *source, Basket *parent, bool fromDrop, Qt::DropAction action, Note */*noteSource*/) { Note *note = 0L; QStringList formats = source->formats(); /* No data */ if (formats.size() == 0) { // TODO: add a parameter to say if it's from a clipboard paste, a selection paste, or a drop // To be able to say "The clipboard/selection/drop is empty". // KMessageBox::error(parent, i18n("There is no data to insert."), i18n("No Data")); return 0; } /* Debug */ if (Global::debugWindow) { *Global::debugWindow << "<b>Drop :</b>"; for (int i = 0; formats.size(); ++i) *Global::debugWindow << "\t[" + QString::number(i) + "] " + formats[i]; switch (action) { // The source want that we: case Qt::CopyAction: *Global::debugWindow << ">> Drop action: Copy"; break; case Qt::MoveAction: *Global::debugWindow << ">> Drop action: Move"; break; case Qt::LinkAction: *Global::debugWindow << ">> Drop action: Link"; break; default: *Global::debugWindow << ">> Drop action: Unknown"; // supported by Qt! } } /* Copy or move a Note */ if (NoteDrag::canDecode(source)) { bool moveFiles = fromDrop && action == Qt::MoveAction; bool moveNotes = moveFiles; return NoteDrag::decode(source, parent, moveFiles, moveNotes); // Filename will be kept } /* Else : Drop object to note */ QImage image = qvariant_cast<QImage>(source->imageData()) ; if ( !image.isNull() ) return createNoteImage(QPixmap::fromImage(image), parent); if (source->hasColor()){ return createNoteColor(qvariant_cast<QColor>(source->colorData()), parent); } // And then the hack (if provide color MIME type or a text that contains color), using createNote Color RegExp: QString hack; QRegExp exp("^#(?:[a-fA-F\\d]{3}){1,4}$"); hack = source->text(); if (source->hasFormat("application/x-color") || (!hack.isNull() && exp.exactMatch(hack)) ) { QColor color = qvariant_cast<QColor>(source->colorData()) ; if (color.isValid()) return createNoteColor(color, parent); // if ( (note = createNoteColor(color, parent)) ) // return note; // // Theorically it should be returned. If not, continue by dropping other things } KUrl::List urls = KUrl::List::fromMimeData(source); if ( !urls.isEmpty() ){ // If it's a Paste, we should know if files should be copied (copy&paste) or moved (cut&paste): if (!fromDrop && Tools::isAFileCut(source)) action = Qt::MoveAction; return dropURLs(urls, parent, action, fromDrop); } // FIXME: use dropURLs() also from Mozilla? /* * Mozilla's stuff sometimes uses utf-16-le - little-endian UTF-16. * * This has the property that for the ASCII subset case (And indeed, the * ISO-8859-1 subset, I think), if you treat it as a C-style string, * it'll come out to one character long in most cases, since it looks * like: * * "<\0H\0T\0M\0L\0>\0" * * A strlen() call on that will give you 1, which simply isn't correct. * That might, I suppose, be the answer, or something close. * * Also, Mozilla's drag/drop code predates the use of MIME types in XDnD * - hence it'll throw about STRING and UTF8_STRING quite happily, hence * the odd named types. * * Thanks to Dave Cridland for having said me that. */ if (source->hasFormat("text/x-moz-url")) { // FOR MOZILLA // Get the array and create a QChar array of 1/2 of the size QByteArray mozilla = source->data("text/x-moz-url"); QVector<QChar> chars( mozilla.count() / 2 ); // A small debug work to know the value of each bytes if (Global::debugWindow) for (int i = 0; i < mozilla.count(); i++) *Global::debugWindow << QString("'") + QChar(mozilla[i]) + "' " + QString::number(int(mozilla[i])); // text/x-moz-url give the URL followed by the link title and separed by OxOA (10 decimal: new line?) uint size = 0; QChar *name = 0L; // For each little endian mozilla chars, copy it to the array of QChars for (int i = 0; i < mozilla.count(); i += 2) { chars[i/2] = QChar(mozilla[i], mozilla[i+1]); if (mozilla.at(i) == 0x0A) { size = i/2; name = &(chars[i/2+1]); } } // Create a QString that take the address of the first QChar and a length if (name == 0L) { // We haven't found name (FIXME: Is it possible ?) QString normalHtml(&(chars[0]), chars.size()); return createNoteLink(normalHtml, parent); } else { QString normalHtml( &(chars[0]), size ); QString normalTitle( name, chars.size()-size-1); return createNoteLink(normalHtml, normalTitle, parent); } } if (source->hasFormat("text/html")) { QString html; QString subtype("html"); // If the text/html comes from Mozilla or GNOME it can be UTF-16 encoded: we need ExtendedTextDrag to check that ExtendedTextDrag::decode(source, html, subtype); return createNoteHtml(html, parent); } QString text; // If the text/plain comes from GEdit or GNOME it can be empty: we need ExtendedTextDrag to check other MIME types if ( ExtendedTextDrag::decode(source, text) ) return createNoteFromText(text, parent); /* Unsucceful drop */ note = createNoteUnknown(source, parent); QString message = i18n("<p>%1 doesn't support the data you've dropped.<br>" "It however created a generic note, allowing you to drag or copy it to an application that understand it.</p>" "<p>If you want the support of these data, please contact developer or visit the " "<a href=\"http://basket.kde.org/dropdb.php\">BasKet Drop Database</a>.</p>",KGlobal::mainComponent().aboutData()->programName()); KMessageBox::information(parent, message, i18n("Unsupported MIME Type(s)"), "unsupportedDropInfo", KMessageBox::AllowLink); return note; }
bool LauncherProfile(const wchar_t *cf,LauncherStructure &config) { std::wstring pfile; if(cf==nullptr){ std::wstring folder; if(!GetProcessImageFileFolder(folder)){ MessageBoxW(nullptr, L"GetModuleFileNameW Failed!", L"Internal System Error", MB_OK|MB_ICONERROR); return false; } pfile=folder+L"/launcher.toml"; if(!PathFileExistsW(pfile.c_str())){ pfile=folder+L"/launcher.exe.toml"; if(!PathFileExistsW(pfile.c_str())){ MessageBoxW(nullptr, folder.c_str(), L"Cannot open launcher.toml or launcher.exe.toml on this path", MB_OK|MB_ICONERROR); return false; } } }else{ pfile=cf; } Characters chars(pfile.c_str()); std::shared_ptr<cpptoml::table> g; try { g = cpptoml::parse_file(chars.Get()); std::cout << (*g) << std::endl; } catch (const cpptoml::parse_exception &e) { (void)e; MessageBoxW(nullptr, pfile.c_str(), L"Cannot parser toml-format profile!", MB_OK|MB_ICONERROR); return false; } auto Strings = [&](const char *key, const wchar_t *v, std::wstring &sv) { if (g->contains_qualified(key)) { std::string astr = g->get_qualified(key)->as<std::string>()->get(); WCharacters was(astr.c_str()); sv=was.Get(); return; } if(v){ sv = v; } }; auto Boolean = [&](const char *key, bool b) { if (g->contains_qualified(key)) { return g->get_qualified(key)->as<bool>()->get(); } return b; }; auto Vector = [&](const char *key, std::vector<std::wstring> &v) { if (g->contains_qualified(key) && g->get_qualified(key)->is_array()) { auto av = g->get_qualified(key)->as_array(); for (auto &e : av->get()) { WCharacters was(e->as<std::string>()->get().c_str()); v.push_back(was.Get()); } } }; Strings("Launcher.MSYSTEM",L"MINGW64",config.env); Strings("Launcher.Root",L"C:/MSYS2",config.root); Strings("Launcher.WD",L"C:/MSYS2/usr/bin",config.wd); Strings("Launcher.Mintty",L"C:/MSYS2/usr/bin/mintty.exe",config.mintty); Strings("Launcher.ICONPath",L"/msys2.ico",config.icon); Strings("Launcher.Shell",L"bash",config.otherShell); Strings("Launcher.AppendShellArgs",nullptr,config.shellArgs); Vector("Launcher.AppendPath",config.appendPath); config.enableZshell=Boolean("Launcher.EnableZshell",false); config.clearEnvironment=Boolean("Launcher.UseClearEnv",false); return true; }
QString TeXCodes::map(QString k) { if (contains(k)) return chars()[k]; else return ""; }
void walk(const TextRun& run, bool isVerticalText, const String& language, int from, int to) { // Should hold true for SVG text, otherwhise sth. is wrong ASSERT(to - from == run.length()); Vector<SVGGlyphIdentifier::ArabicForm> chars(charactersWithArabicForm(String(run.data(from), run.length()), run.rtl())); SVGGlyphIdentifier identifier; bool foundGlyph = false; int characterLookupRange; int endOfScanRange = to + m_walkerData.extraCharsAvailable; bool haveAltGlyph = false; SVGGlyphIdentifier altGlyphIdentifier; if (RenderObject* renderObject = run.referencingRenderObject()) { if (renderObject->element() && renderObject->element()->hasTagName(SVGNames::altGlyphTag)) { SVGGlyphElement* glyphElement = static_cast<SVGAltGlyphElement*>(renderObject->element())->glyphElement(); if (glyphElement) { haveAltGlyph = true; altGlyphIdentifier = glyphElement->buildGlyphIdentifier(); altGlyphIdentifier.isValid = true; altGlyphIdentifier.nameLength = to - from; } } } for (int i = from; i < to; ++i) { // If characterLookupRange is > 0, then the font defined ligatures (length of unicode property value > 1). // We have to check wheter the current character & the next character define a ligature. This needs to be // extended to the n-th next character (where n is 'characterLookupRange'), to check for any possible ligature. characterLookupRange = endOfScanRange - i; String lookupString(run.data(i), characterLookupRange); Vector<SVGGlyphIdentifier> glyphs; if (haveAltGlyph) glyphs.append(altGlyphIdentifier); else m_fontElement->getGlyphIdentifiersForString(lookupString, glyphs); Vector<SVGGlyphIdentifier>::iterator it = glyphs.begin(); Vector<SVGGlyphIdentifier>::iterator end = glyphs.end(); for (; it != end; ++it) { identifier = *it; if (identifier.isValid && isCompatibleGlyph(identifier, isVerticalText, language, chars, i, i + identifier.nameLength)) { ASSERT(characterLookupRange > 0); i += identifier.nameLength - 1; m_walkerData.charsConsumed += identifier.nameLength; m_walkerData.glyphName = identifier.glyphName; foundGlyph = true; SVGGlyphElement::inheritUnspecifiedAttributes(identifier, m_fontData); break; } } if (!foundGlyph) { ++m_walkerData.charsConsumed; if (SVGMissingGlyphElement* element = m_fontElement->firstMissingGlyphElement()) { // <missing-glyph> element support identifier = SVGGlyphElement::buildGenericGlyphIdentifier(element); SVGGlyphElement::inheritUnspecifiedAttributes(identifier, m_fontData); identifier.isValid = true; } else { // Fallback to system font fallback TextRun subRun(run); subRun.setText(subRun.data(i), 1); (*m_walkerMissingGlyphCallback)(subRun, m_walkerData); continue; } } if (!(*m_walkerCallback)(identifier, m_walkerData)) break; foundGlyph = false; } }
inline std::basic_ostream<Ch, Tr> & out_shell_quote(std::basic_ostream<Ch, Tr> &out, const C& data, bool quote_empty=true) { out_stream<Ch, Tr> chars(out); shell_quote_chars(chars, to_string(data), quote_empty); return out; }
String IndexInput::readModifiedUTF8String() { int32_t length = readVInt(); CharArray chars(CharArray::newInstance(length)); return String(chars.get(), readChars(chars.get(), 0, length)); }
TFiniteAutomaton TFiniteAutomaton::Minimized() const { // NOTE: automaton shoud be deterministic here TFiniteAutomaton result; vector<size_t> labels(Size()); vector< vector<size_t> > classes(2); // basis: divide states into final / not final for (size_t i = 0, size = Size(); i != size; ++i) classes[labels[i] = static_cast<size_t>(States[i].IsFinal)].push_back(i); if (classes[1].empty()) classes.pop_back(); if (classes[0].empty()) classes.erase(classes.begin()); // unite alphabets set<TChar> charSet; for (size_t i = 0, size = Size(); i != size; ++i) { const TTransitions& tran = States[i].Transitions; for (TTransitions::const_iterator trIt = tran.begin(), trEnd = tran.end(); trIt != trEnd; ++trIt) charSet.insert(trIt->first); } vector<TChar> chars(charSet.begin(), charSet.end()); charSet.clear(); // find equivalence classes bool modified = true; TBucketTable<size_t> buckets(Size() + 1); while (modified) { vector< vector<size_t> > newClasses; modified = false; for (size_t i = 0, size = classes.size(); i != size; ++i) { const vector<size_t>& cls = classes[i]; bool class_modified = false; for (size_t chInd = 0, chEnd = chars.size(); chInd != chEnd; ++chInd) { const TChar ch = chars[chInd]; buckets.Clear(); for (size_t j = 0, clsSize = cls.size(); j != clsSize; ++j) { const TTransitions& tran = States[cls[j]].Transitions; TTransitions::const_iterator it = tran.find(ch); size_t bucket = (it != tran.end() ? labels[*it->second.begin()] + 1 : 0); buckets.Push(cls[j], bucket); } if (buckets.UsedBuckets() != 1) { const TBucketTable<size_t>::TBuckets& bucks = buckets.GetBuckets(); const vector<size_t>& used = buckets.GetUsedBuckets(); for (size_t b = 0, usedSize = used.size(); b != usedSize; ++b) newClasses.push_back(bucks[used[b]]); class_modified = true; modified = true; break; } } if (!class_modified) newClasses.push_back(cls); } classes.swap(newClasses); for (size_t i = 0, size = classes.size(); i != size; ++i) { const vector<size_t>& cls = classes[i]; for (size_t j = 0, clsSize = cls.size(); j != clsSize; ++j) labels[cls[j]] = i; } } // construct resulting DFA using labels ang classes result.Resize(classes.size()); for (size_t i = 0, size = classes.size(); i != size; ++i) { // NOTE: it is guaranteed that classes are not empty size_t state = classes[i].front(); const TTransitions& tran = States[state].Transitions; for (TTransitions::const_iterator it = tran.begin(), end = tran.end(); it != end; ++it) result.AddTransition(labels[state], labels[*it->second.begin()], it->first); // NOTE: all labels by one char are equal } result.SetStartState(labels[StartState]); for (TStateIdSet::const_iterator it = FinalStates.begin(), end = FinalStates.end(); it != end; ++it) result.SetFinalState(labels[*it]); return result; }