static String replaceNonPrintableCharacters(const String& text)
{
StringBuilder stringBuilder;
for (size_t i = 0; i < text.length(); ++i) {
if (isASCIIPrintable(text[i]))
stringBuilder.append(text[i]);
else
stringBuilder.append('?');
}
return stringBuilder.toString();
}
static char* makePrintable(const char *from, char *to)
{
const char* f;
char* t;
for (f = from, t = to; *f; f++, t++)
*t = isASCIIPrintable(*f) ? *f : '_';
*t = 0;
return to;
}
bool WebSocketExtensionParser::consumeToken()
{
skipSpaces();
const char* start = m_current;
while (m_current < m_end && isASCIIPrintable(*m_current) && !isSeparator(*m_current))
++m_current;
if (start < m_current) {
m_currentToken = String(start, m_current - start);
return true;
}
return false;
}
std::ostream& operator<<(std::ostream& ostream, const CString& string) {
if (string.isNull())
return ostream << "<null>";
ostream << '"';
for (size_t index = 0; index < string.length(); ++index) {
// Print shorthands for select cases.
char character = string.data()[index];
switch (character) {
case '\t':
ostream << "\\t";
break;
case '\n':
ostream << "\\n";
break;
case '\r':
ostream << "\\r";
break;
case '"':
ostream << "\\\"";
break;
case '\\':
ostream << "\\\\";
break;
default:
if (isASCIIPrintable(character)) {
ostream << character;
} else {
// Print "\xHH" for control or non-ASCII characters.
ostream << "\\x";
if (character >= 0 && character < 0x10)
ostream << "0";
ostream.setf(std::ios_base::hex, std::ios_base::basefield);
ostream.setf(std::ios::uppercase);
ostream << (character & 0xff);
}
break;
}
}
return ostream << '"';
}
static String keyTextForNixKeyEvent(const NIXKeyEvent& event)
{
if (event.text)
return String::fromUTF8(event.text);
int keycode = static_cast<int>(event.key);
if (isASCIIPrintable(keycode))
return String::format("%c", event.shouldUseUpperCase ? toASCIIUpper(keycode) : toASCIILower(keycode));
switch (event.key) {
case kNIXKeyEventKey_Tab:
case kNIXKeyEventKey_Backtab:
return "\t";
case kNIXKeyEventKey_Enter:
case kNIXKeyEventKey_Return:
return "\r";
default:
break;
}
return "";
}
LRESULT WebPopupMenuProxyWin::onKeyDown(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam, bool& handled)
{
handled = true;
LRESULT lResult = 0;
switch (LOWORD(wParam)) {
case VK_DOWN:
case VK_RIGHT:
down();
break;
case VK_UP:
case VK_LEFT:
up();
break;
case VK_HOME:
focusFirst();
break;
case VK_END:
focusLast();
break;
case VK_PRIOR:
if (focusedIndex() != scrollOffset()) {
// Set the selection to the first visible item
int firstVisibleItem = scrollOffset();
up(focusedIndex() - firstVisibleItem);
} else {
// The first visible item is selected, so move the selection back one page
up(visibleItems());
}
break;
case VK_NEXT: {
int lastVisibleItem = scrollOffset() + visibleItems() - 1;
if (focusedIndex() != lastVisibleItem) {
// Set the selection to the last visible item
down(lastVisibleItem - focusedIndex());
} else {
// The last visible item is selected, so move the selection forward one page
down(visibleItems());
}
break;
}
case VK_TAB:
::SendMessage(m_webView->window(), message, wParam, lParam);
hide();
break;
case VK_ESCAPE:
hide();
break;
default:
if (isASCIIPrintable(wParam)) {
// Send the keydown to the WebView so it can be used for type-to-select.
// Since we know that the virtual key is ASCII printable, it's OK to convert this to
// a WM_CHAR message. (We don't want to call TranslateMessage because that will post a
// WM_CHAR message that will be stolen and redirected to the popup HWND.
::PostMessage(m_popup, WM_HOST_WINDOW_CHAR, wParam, lParam);
} else
lResult = 1;
break;
}
return lResult;
}
void NFA::debugPrintDot() const
{
dataLogF("digraph NFA_Transitions {\n");
dataLogF(" rankdir=LR;\n");
dataLogF(" node [shape=circle];\n");
dataLogF(" {\n");
for (unsigned i = 0; i < nodes.size(); ++i) {
dataLogF(" %d [label=<Node %d", i, i);
const auto& node = nodes[i];
if (node.actionStart != node.actionEnd) {
dataLogF("<BR/>(Final: ");
bool isFirst = true;
for (unsigned actionIndex = node.actionStart; actionIndex < node.actionEnd; ++actionIndex) {
if (!isFirst)
dataLogF(", ");
dataLogF("%llu", actions[actionIndex]);
isFirst = false;
}
dataLogF(")");
}
dataLogF(">]");
if (node.actionStart != node.actionEnd)
dataLogF(" [shape=doublecircle]");
dataLogF(";\n");
}
dataLogF(" }\n");
dataLogF(" {\n");
for (unsigned i = 0; i < nodes.size(); ++i) {
const auto& node = nodes[i];
HashMap<uint32_t, Vector<uint32_t>, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> transitionsPerTarget;
for (uint32_t transitionIndex = node.rangesStart; transitionIndex < node.rangesEnd; ++transitionIndex) {
const ImmutableCharRange& range = transitions[transitionIndex];
for (uint32_t targetIndex = range.targetStart; targetIndex < range.targetEnd; ++targetIndex) {
uint32_t target = targets[targetIndex];
auto addResult = transitionsPerTarget.add(target, Vector<uint32_t>());
addResult.iterator->value.append(transitionIndex);
}
}
for (const auto& slot : transitionsPerTarget) {
dataLogF(" %d -> %d [label=\"", i, slot.key);
bool isFirst = true;
for (uint32_t rangeIndex : slot.value) {
if (!isFirst)
dataLogF(", ");
else
isFirst = false;
const ImmutableCharRange& range = transitions[rangeIndex];
if (range.first == range.last) {
if (isASCIIPrintable(range.first))
dataLogF("%c", range.first);
else
dataLogF("%d", range.first);
} else {
if (isASCIIPrintable(range.first) && isASCIIPrintable(range.last))
dataLogF("%c-%c", range.first, range.last);
else
dataLogF("%d-%d", range.first, range.last);
}
}
dataLogF("\"]\n");
}
for (uint32_t epsilonTargetIndex = node.epsilonTransitionTargetsStart; epsilonTargetIndex < node.epsilonTransitionTargetsEnd; ++epsilonTargetIndex) {
uint32_t target = epsilonTransitionsTargets[epsilonTargetIndex];
dataLogF(" %d -> %d [label=\"ɛ\"]\n", i, target);
}
}
dataLogF(" }\n");
dataLogF("}\n");
}
