static void findGrammaticalErrors(TextCheckerClient& client, StringView text, Vector<TextCheckingResult>& results)
{
for (unsigned checkLocation = 0; checkLocation < text.length(); ) {
int badGrammarLocation = -1;
int badGrammarLength = 0;
Vector<GrammarDetail> badGrammarDetails;
client.checkGrammarOfString(text.substring(checkLocation), badGrammarDetails, &badGrammarLocation, &badGrammarLength);
if (!badGrammarLength)
break;
ASSERT(badGrammarLocation >= 0);
ASSERT(static_cast<unsigned>(badGrammarLocation) <= text.length() - checkLocation);
ASSERT(badGrammarLength > 0);
ASSERT(static_cast<unsigned>(badGrammarLength) <= text.length() - checkLocation - badGrammarLocation);
TextCheckingResult badGrammar;
badGrammar.type = TextCheckingTypeGrammar;
badGrammar.location = checkLocation + badGrammarLocation;
badGrammar.length = badGrammarLength;
badGrammar.details = std::move(badGrammarDetails);
results.append(badGrammar);
checkLocation += badGrammarLocation + badGrammarLength;
}
}
void checkTextOfParagraph(TextCheckerClient& client, StringView text, TextCheckingTypeMask checkingTypes, Vector<TextCheckingResult>& results)
{
#if USE(UNIFIED_TEXT_CHECKING)
results = client.checkTextOfParagraph(text, checkingTypes);
#else
Vector<TextCheckingResult> mispellings;
if (checkingTypes & TextCheckingTypeSpelling)
findMisspellings(client, text, mispellings);
#if USE(GRAMMAR_CHECKING)
// Look for grammatical errors that occur before the first misspelling.
Vector<TextCheckingResult> grammaticalErrors;
if (checkingTypes & TextCheckingTypeGrammar) {
unsigned grammarCheckLength = text.length();
for (auto& mispelling : mispellings)
grammarCheckLength = std::min<unsigned>(grammarCheckLength, mispelling.location);
findGrammaticalErrors(client, text.substring(0, grammarCheckLength), grammaticalErrors);
}
results = std::move(grammaticalErrors);
#endif
if (results.isEmpty())
results = std::move(mispellings);
else
results.appendVector(mispellings);
#endif // USE(UNIFIED_TEXT_CHECKING)
}
void Settings::remove(const StringView& _name) const
{
ini_t* ini = INI_T(m_ini);
FilePath uri(_name);
const StringView path = strTrim(uri.getPath(), "/");
const StringView& fileName = uri.getFileName();
int32_t section = INI_GLOBAL_SECTION;
if (!path.isEmpty() )
{
section = ini_find_section(ini, path.getPtr(), path.getLength() );
if (INI_NOT_FOUND == section)
{
section = INI_GLOBAL_SECTION;
}
}
int32_t property = ini_find_property(ini, section, fileName.getPtr(), fileName.getLength() );
if (INI_NOT_FOUND == property)
{
return;
}
ini_property_remove(ini, section, property);
if (INI_GLOBAL_SECTION != section
&& 0 == ini_property_count(ini, section) )
{
ini_section_remove(ini, section);
}
}
StringView Settings::get(const StringView& _name) const
{
ini_t* ini = INI_T(m_ini);
FilePath uri(_name);
const StringView path(strTrim(uri.getPath(), "/") );
const StringView& fileName(uri.getFileName() );
int32_t section = INI_GLOBAL_SECTION;
if (!path.isEmpty() )
{
section = ini_find_section(ini, path.getPtr(), path.getLength() );
if (INI_NOT_FOUND == section)
{
section = INI_GLOBAL_SECTION;
}
}
int32_t property = ini_find_property(ini, section, fileName.getPtr(), fileName.getLength() );
if (INI_NOT_FOUND == property)
{
return StringView();
}
return ini_property_value(ini, section, property);
}
std::u32string StringToUTF32(const StringView str)
{
if (str.empty())
{
return std::u32string();
}
const wchar* begin = &str[0];
const wchar* end = begin + str.length();
if (const auto length = detail::CountCodePoints(begin, end))
{
std::u32string result(length.value(), L'\0');
while (begin != end)
{
const auto ch = *begin++;
if (!IsUTF16Surrogate(ch))
{
result.push_back(ch);
}
else
{
result.push_back(SurrogateToUTF32(ch, *begin++));
}
}
return result;
}
else
{
return std::u32string();
}
}
void processFeaturesString(StringView features, std::function<void(StringView type, StringView value)> callback)
{
unsigned length = features.length();
for (unsigned i = 0; i < length; ) {
// skip to first non-separator
while (i < length && isSeparator(features[i]))
++i;
unsigned keyBegin = i;
// skip to first separator
while (i < length && !isSeparator(features[i]))
i++;
unsigned keyEnd = i;
// skip to first '=', but don't skip past a ','
while (i < length && features[i] != '=' && features[i] != ',')
++i;
// skip to first non-separator, but don't skip past a ','
while (i < length && isSeparator(features[i]) && features[i] != ',')
++i;
unsigned valueBegin = i;
// skip to first separator
while (i < length && !isSeparator(features[i]))
++i;
unsigned valueEnd = i;
callback(features.substring(keyBegin, keyEnd - keyBegin), features.substring(valueBegin, valueEnd - valueBegin));
}
}
static void setWindowFeature(WindowFeatures& features, StringView key, StringView value)
{
// Listing a key with no value is shorthand for key=yes
int numericValue;
if (value.isEmpty() || equalLettersIgnoringASCIICase(value, "yes"))
numericValue = 1;
else
numericValue = value.toInt();
// We treat key of "resizable" here as an additional feature rather than setting resizeable to true.
// This is consistent with Firefox, but could also be handled at another level.
if (equalLettersIgnoringASCIICase(key, "left") || equalLettersIgnoringASCIICase(key, "screenx"))
features.x = numericValue;
else if (equalLettersIgnoringASCIICase(key, "top") || equalLettersIgnoringASCIICase(key, "screeny"))
features.y = numericValue;
else if (equalLettersIgnoringASCIICase(key, "width") || equalLettersIgnoringASCIICase(key, "innerwidth"))
features.width = numericValue;
else if (equalLettersIgnoringASCIICase(key, "height") || equalLettersIgnoringASCIICase(key, "innerheight"))
features.height = numericValue;
else if (equalLettersIgnoringASCIICase(key, "menubar"))
features.menuBarVisible = numericValue;
else if (equalLettersIgnoringASCIICase(key, "toolbar"))
features.toolBarVisible = numericValue;
else if (equalLettersIgnoringASCIICase(key, "location"))
features.locationBarVisible = numericValue;
else if (equalLettersIgnoringASCIICase(key, "status"))
features.statusBarVisible = numericValue;
else if (equalLettersIgnoringASCIICase(key, "fullscreen"))
features.fullscreen = numericValue;
else if (equalLettersIgnoringASCIICase(key, "scrollbars"))
features.scrollbarsVisible = numericValue;
else if (numericValue == 1)
features.additionalFeatures.append(key.toString());
}
int main() {
constexpr StringView sv{"123456"};
static_assert(sv.IsNumber(), "sv isn't a number? WTF?");
constexpr StringView sv2{"123a456"};
static_assert(!sv2.IsNumber(), "sv2 is a number? WTF?");
}
static void parseImageCandidatesFromSrcsetAttribute(StringView attribute, Vector<ImageCandidate>& imageCandidates)
{
// FIXME: We should consider replacing the direct pointers in the parsing process with StringView and positions.
if (attribute.is8Bit())
parseImageCandidatesFromSrcsetAttribute<LChar>(attribute.characters8(), attribute.length(), imageCandidates);
else
parseImageCandidatesFromSrcsetAttribute<UChar>(attribute.characters16(), attribute.length(), imageCandidates);
}
UCharIterator createIterator(StringView string)
{
if (string.is8Bit())
return createLatin1Iterator(string.characters8(), string.length());
UCharIterator iterator;
uiter_setString(&iterator, string.characters16(), string.length());
return iterator;
}
bool write_string(Slice<char>& buffer, StringView v)
{
if (buffer.size() < v.length()) return false;
memcpy(buffer.ptr(), v.c_str(), v.length());
buffer.trim_front(v.length());
return true;
}
EncodedJSValue JSC_HOST_CALL functionProtoFuncToString(ExecState* exec)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSValue thisValue = exec->thisValue();
if (thisValue.inherits(JSFunction::info())) {
JSFunction* function = jsCast<JSFunction*>(thisValue);
if (function->isHostOrBuiltinFunction()) {
scope.release();
return JSValue::encode(jsMakeNontrivialString(exec, "function ", function->name(vm), "() {\n [native code]\n}"));
}
FunctionExecutable* executable = function->jsExecutable();
if (executable->isClass()) {
StringView classSource = executable->classSource().view();
return JSValue::encode(jsString(exec, classSource.toStringWithoutCopying()));
}
if (thisValue.inherits(JSAsyncFunction::info())) {
String functionHeader = executable->isArrowFunction() ? "async " : "async function ";
StringView source = executable->source().provider()->getRange(
executable->parametersStartOffset(),
executable->parametersStartOffset() + executable->source().length());
return JSValue::encode(jsMakeNontrivialString(exec, functionHeader, function->name(vm), source));
}
String functionHeader = executable->isArrowFunction() ? "" : "function ";
StringView source = executable->source().provider()->getRange(
executable->parametersStartOffset(),
executable->parametersStartOffset() + executable->source().length());
scope.release();
return JSValue::encode(jsMakeNontrivialString(exec, functionHeader, function->name(vm), source));
}
if (thisValue.inherits(InternalFunction::info())) {
InternalFunction* function = asInternalFunction(thisValue);
scope.release();
return JSValue::encode(jsMakeNontrivialString(exec, "function ", function->name(), "() {\n [native code]\n}"));
}
if (thisValue.isObject()) {
JSObject* object = asObject(thisValue);
if (object->inlineTypeFlags() & TypeOfShouldCallGetCallData) {
CallData callData;
if (object->methodTable(vm)->getCallData(object, callData) != CallType::None) {
if (auto* classInfo = object->classInfo()) {
scope.release();
return JSValue::encode(jsMakeNontrivialString(exec, "function ", classInfo->className, "() {\n [native code]\n}"));
}
}
}
}
return throwVMTypeError(exec, scope);
}
void AbstractParser::parseGroupTell(const StringView &view)
{
if (view.isEmpty())
sendToUser("What do you want to tell the group?\r\n");
else {
emit sendGroupTellEvent(view.toQByteArray());
sendToUser("OK.\r\n");
}
}
static inline bool hostIsInDomain(StringView host, StringView domain)
{
if (!host.endsWithIgnoringASCIICase(domain))
return false;
ASSERT(host.length() >= domain.length());
unsigned suffixOffset = host.length() - domain.length();
return suffixOffset == 0 || host[suffixOffset - 1] == '.';
}
inline double double_from_string(StringView & i_source)
{
char temp[256];
i_source.copy_to_cstr(temp);
char * end = nullptr;
const double result = strtod(temp, &end);
REFLECTIVE_INTERNAL_ASSERT(end != nullptr && end >= temp);
i_source.remove_prefix(end - temp);
return result;
}
size_t add_string(const size_t vertex, const StringView& s, const bool add_substrings = false)
// extend Trie by one string
// REQUIRE: all chars in interval [0..alphabet_size]
{
size_t v = vertex;
for (size_t i = 0; i < s.length(); ++i) {
v = add_char(v, s[i], add_substrings || i == s.length() - 1);
}
return v;
}
// https://wicg.github.io/entries-api/#valid-path
static bool isValidVirtualPath(StringView virtualPath)
{
if (virtualPath.isEmpty())
return true;
if (virtualPath[0] == '/') {
// An absolute path is a string consisting of '/' (U+002F SOLIDUS) followed by one or more path segments joined by '/' (U+002F SOLIDUS).
return isZeroOrMorePathSegmentsSeparatedBySlashes(virtualPath.substring(1));
}
return isValidRelativeVirtualPath(virtualPath);
}
void AbstractParser::parseGroupKick(const StringView &view)
{
if (view.isEmpty())
sendToUser("Who do you want to kick from the group?\r\n");
else {
// REVISIT: We should change GroupManager to be a "FrontEnd" in this
// thread and call it directly
emit sendGroupKickEvent(view.toQByteArray().simplified());
sendToUser("OK.\r\n");
}
}
void Write(StringView data)
{
NEPTOOLS_CHECK(SinkOverflow, offset+buf_put+data.length() <= size,
"Sink overflow during write");
auto cp = std::min(data.length(), size_t(buf_size - buf_put));
memcpy(buf+buf_put, data.data(), cp);
data.remove_prefix(cp);
buf_put += cp;
if (!data.empty()) Write_(data);
}
void AbstractParser::parseSpecialCommand(StringView wholeCommand)
{
if (wholeCommand.isEmpty())
throw std::runtime_error("input is empty");
if (evalSpecialCommandMap(wholeCommand))
return;
const auto word = wholeCommand.takeFirstWord();
sendToUser(QString("Unrecognized command: %1\r\n").arg(word.toQString()));
}
// https://wicg.github.io/entries-api/#path-segment
static bool isValidPathSegment(StringView segment)
{
if (segment.isEmpty() || segment == "." || segment == "..")
return true;
for (unsigned i = 0; i < segment.length(); ++i) {
if (!isValidPathNameCharacter(segment[i]))
return false;
}
return true;
}
static void appendSourceToError(CallFrame* callFrame, ErrorInstance* exception, unsigned bytecodeOffset)
{
ErrorInstance::SourceAppender appender = exception->sourceAppender();
exception->clearSourceAppender();
RuntimeType type = exception->runtimeTypeForCause();
exception->clearRuntimeTypeForCause();
if (!callFrame->codeBlock()->hasExpressionInfo())
return;
int startOffset = 0;
int endOffset = 0;
int divotPoint = 0;
unsigned line = 0;
unsigned column = 0;
CodeBlock* codeBlock = callFrame->codeBlock();
codeBlock->expressionRangeForBytecodeOffset(bytecodeOffset, divotPoint, startOffset, endOffset, line, column);
int expressionStart = divotPoint - startOffset;
int expressionStop = divotPoint + endOffset;
StringView sourceString = codeBlock->source()->source();
if (!expressionStop || expressionStart > static_cast<int>(sourceString.length()))
return;
VM* vm = &callFrame->vm();
JSValue jsMessage = exception->getDirect(*vm, vm->propertyNames->message);
if (!jsMessage || !jsMessage.isString())
return;
String message = asString(jsMessage)->value(callFrame);
if (expressionStart < expressionStop)
message = appender(message, codeBlock->source()->getRange(expressionStart, expressionStop).toString(), type, ErrorInstance::FoundExactSource);
else {
// No range information, so give a few characters of context.
int dataLength = sourceString.length();
int start = expressionStart;
int stop = expressionStart;
// Get up to 20 characters of context to the left and right of the divot, clamping to the line.
// Then strip whitespace.
while (start > 0 && (expressionStart - start < 20) && sourceString[start - 1] != '\n')
start--;
while (start < (expressionStart - 1) && isStrWhiteSpace(sourceString[start]))
start++;
while (stop < dataLength && (stop - expressionStart < 20) && sourceString[stop] != '\n')
stop++;
while (stop > expressionStart && isStrWhiteSpace(sourceString[stop - 1]))
stop--;
message = appender(message, codeBlock->source()->getRange(start, stop).toString(), type, ErrorInstance::FoundApproximateSource);
}
exception->putDirect(*vm, vm->propertyNames->message, jsString(vm, message));
}
String TextCheckingHelper::findFirstMisspelling(int& firstMisspellingOffset, bool markAll, RefPtr<Range>& firstMisspellingRange)
{
WordAwareIterator it(*m_range);
firstMisspellingOffset = 0;
String firstMisspelling;
int currentChunkOffset = 0;
while (!it.atEnd()) {
StringView text = it.text();
int textLength = text.length();
// Skip some work for one-space-char hunks
if (textLength == 1 && text[0] == ' ') {
int misspellingLocation = -1;
int misspellingLength = 0;
m_client->textChecker()->checkSpellingOfString(text, &misspellingLocation, &misspellingLength);
// 5490627 shows that there was some code path here where the String constructor below crashes.
// We don't know exactly what combination of bad input caused this, so we're making this much
// more robust against bad input on release builds.
ASSERT(misspellingLength >= 0);
ASSERT(misspellingLocation >= -1);
ASSERT(!misspellingLength || misspellingLocation >= 0);
ASSERT(misspellingLocation < textLength);
ASSERT(misspellingLength <= textLength);
ASSERT(misspellingLocation + misspellingLength <= textLength);
if (misspellingLocation >= 0 && misspellingLength > 0 && misspellingLocation < textLength && misspellingLength <= textLength && misspellingLocation + misspellingLength <= textLength) {
// Compute range of misspelled word
RefPtr<Range> misspellingRange = TextIterator::subrange(m_range.get(), currentChunkOffset + misspellingLocation, misspellingLength);
// Remember first-encountered misspelling and its offset.
if (!firstMisspelling) {
firstMisspellingOffset = currentChunkOffset + misspellingLocation;
firstMisspelling = text.substring(misspellingLocation, misspellingLength).toString();
firstMisspellingRange = misspellingRange;
}
// Store marker for misspelled word.
misspellingRange->startContainer()->document().markers().addMarker(misspellingRange.get(), DocumentMarker::Spelling);
// Bail out if we're marking only the first misspelling, and not all instances.
if (!markAll)
break;
}
}
currentChunkOffset += textLength;
it.advance();
}
return firstMisspelling;
}
IDBKeyPathLexer::TokenType IDBKeyPathLexer::lex(String& element)
{
if (m_remainingText.isEmpty())
return TokenEnd;
if (m_remainingText[0] == '.') {
m_remainingText = m_remainingText.substring(1);
return TokenDot;
}
return lexIdentifier(element);
}
void SaveString(const char* filename, StringView data)
{
FILE* f = 0;
fopen_s(&f, filename, "wb");
if (!f)
{
ghlib::Log::Error("Could not open file `", filename, "`");
return;
}
fwrite(data.begin(), data.size(), 1, f);
fclose(f);
}
void WebEditorClient::checkSpellingOfString(StringView text, int* misspellingLocation, int* misspellingLength)
{
*misspellingLocation = -1;
*misspellingLength = 0;
COMPtr<IWebEditingDelegate> ed;
if (FAILED(m_webView->editingDelegate(&ed)) || !ed.get())
return;
initViewSpecificSpelling(m_webView);
ed->checkSpellingOfString(m_webView, text.upconvertedCharacters(), text.length(), misspellingLocation, misspellingLength);
}
TextRun InlineTextBox::constructTextRun(const ComputedStyle& style, const Font& font, StringBuilder* charactersWithHyphen) const
{
ASSERT(lineLayoutItem().text());
StringView string = lineLayoutItem().text().createView();
unsigned startPos = start();
unsigned length = len();
if (string.length() != length || startPos)
string.narrow(startPos, length);
return constructTextRun(style, font, string, lineLayoutItem().textLength() - startPos, charactersWithHyphen);
}
void AbstractParser::parseName(StringView view)
{
if (!view.isEmpty()) {
auto dir = tryGetDir(view);
if (!view.isEmpty()) {
auto name = view.takeFirstWord();
nameDoorCommand(name.toQString(), dir);
return;
}
}
showSyntax("name <dir> <name>");
}
bool AbstractParser::parseExitFlags(StringView words)
{
if (words.isEmpty())
return false;
const auto firstWord = words.takeFirstWord();
for (const ExitFlag flag : ALL_EXIT_FLAGS) {
if (getParserCommandName(flag).matches(firstWord)) {
return parseExitFlag(flag, words);
}
}
return false;
}
bool AbstractParser::parseDoorAction(StringView words)
{
if (words.isEmpty())
return false;
const auto firstWord = words.takeFirstWord();
for (const DoorActionType dat : ALL_DOOR_ACTION_TYPES) {
if (getParserCommandName(dat).matches(firstWord)) {
return parseDoorAction(dat, words);
}
}
return false;
}
