static inline void documentWrite(ExecState& state, JSHTMLDocument* thisDocument, NewlineRequirement addNewline)
{
HTMLDocument* document = &thisDocument->wrapped();
// DOM only specifies single string argument, but browsers allow multiple or no arguments.
size_t size = state.argumentCount();
String firstString = state.argument(0).toString(&state)->value(&state);
SegmentedString segmentedString = firstString;
if (size != 1) {
if (!size)
segmentedString.clear();
else {
for (size_t i = 1; i < size; ++i) {
String subsequentString = state.uncheckedArgument(i).toString(&state)->value(&state);
segmentedString.append(SegmentedString(subsequentString));
}
}
}
if (addNewline)
segmentedString.append(SegmentedString(String(&newlineCharacter, 1)));
Document* activeDocument = findCallingDocument(state);
document->write(segmentedString, activeDocument);
}
void TextTokenizer::write(const SegmentedString& s, bool)
{
ExceptionCode ec;
m_dest = m_buffer;
SegmentedString str = s;
while (!str.isEmpty()) {
UChar c = *str;
if (c == '\r') {
*m_dest++ = '\n';
// possibly skip an LF in the case of an CRLF sequence
m_skipLF = true;
} else if (c == '\n') {
if (!m_skipLF)
*m_dest++ = c;
else
m_skipLF = false;
} else {
*m_dest++ = c;
m_skipLF = false;
}
str.advance();
// Maybe enlarge the buffer
checkBuffer();
}
if (!m_preElement && !inViewSourceMode()) {
RefPtr<Element> rootElement = m_doc->createElement(htmlTag, false);
m_doc->appendChild(rootElement, ec);
RefPtr<Element> body = m_doc->createElement(bodyTag, false);
rootElement->appendChild(body, ec);
RefPtr<Element> preElement = m_doc->createElement(preTag, false);
preElement->setAttribute("style", "word-wrap: break-word; white-space: pre-wrap;", ec);
body->appendChild(preElement, ec);
m_preElement = preElement.get();
}
String string = String(m_buffer, m_dest - m_buffer);
if (inViewSourceMode()) {
static_cast<HTMLViewSourceDocument*>(m_doc)->addViewSourceText(string);
return;
}
unsigned charsLeft = string.length();
while (charsLeft) {
// split large text to nodes of manageable size
RefPtr<Text> text = Text::createWithLengthLimit(m_doc, string, charsLeft);
m_preElement->appendChild(text, ec);
}
}
void SegmentedString::prepend(const SegmentedString& s)
{
ASSERT(!escaped());
ASSERT(!s.escaped());
if (s.isComposite()) {
Deque<SegmentedSubstring>::const_reverse_iterator it = s.m_substrings.rbegin();
Deque<SegmentedSubstring>::const_reverse_iterator e = s.m_substrings.rend();
for (; it != e; ++it)
prepend(*it);
}
prepend(s.m_currentString);
m_currentChar = m_pushedChar1 ? m_pushedChar1 : (m_currentString.m_length ? m_currentString.getCurrentChar() : 0);
}
bool TextTokenizer::write(const SegmentedString& s, bool appendData)
{
ExceptionCode ec;
m_dest = m_buffer;
SegmentedString str = s;
while (!str.isEmpty()) {
UChar c = *str;
if (c == '\r') {
*m_dest++ = '\n';
// possibly skip an LF in the case of an CRLF sequence
m_skipLF = true;
} else if (c == '\n') {
if (!m_skipLF)
*m_dest++ = c;
else
m_skipLF = false;
} else {
*m_dest++ = c;
m_skipLF = false;
}
++str;
// Maybe enlarge the buffer
checkBuffer();
}
if (!m_preElement) {
RefPtr<Element> rootElement = m_doc->createElementNS(xhtmlNamespaceURI, "html", ec);
m_doc->appendChild(rootElement, ec);
RefPtr<Element> body = m_doc->createElementNS(xhtmlNamespaceURI, "body", ec);
rootElement->appendChild(body, ec);
RefPtr<Element> preElement = m_doc->createElementNS(xhtmlNamespaceURI, "pre", ec);
body->appendChild(preElement, ec);
m_preElement = preElement.get();
}
String string = String(m_buffer, m_dest - m_buffer);
RefPtr<Text> text = m_doc->createTextNode(string);
m_preElement->appendChild(text, ec);
return false;
}
void HTMLSourceTracker::end(SegmentedString& currentInput, HTMLTokenizer* tokenizer, HTMLToken& token)
{
m_cachedSourceForToken = String();
// FIXME: This work should really be done by the HTMLTokenizer.
token.end(currentInput.numberOfCharactersConsumed() - tokenizer->numberOfBufferedCharacters());
}
void XMLTokenizer::write(const SegmentedString& s, bool /*appendData*/)
{
String parseString = s.toString();
if (m_sawXSLTransform || !m_sawFirstElement)
m_originalSourceForTransform += parseString;
if (m_parserStopped || m_sawXSLTransform)
return;
if (m_parserPaused) {
m_pendingSrc.append(s);
return;
}
doWrite(s.toString());
}
void CSSPreloadScanner::emitRule(const SegmentedString& source)
{
if (equalIgnoringCase("import", m_rule.characters(), m_rule.length())) {
String url = parseCSSStringOrURL(m_ruleValue.characters(), m_ruleValue.length());
if (!url.isEmpty()) {
KURL baseElementURL; // FIXME: This should be passed in from the HTMLPreloadScaner via scan()!
TextPosition position = TextPosition(source.currentLine(), source.currentColumn());
OwnPtr<PreloadRequest> request = PreloadRequest::create("css", position, url, baseElementURL, CachedResource::CSSStyleSheet);
// FIXME: Should this be including the charset in the preload request?
m_requests->append(request.release());
}
m_state = Initial;
} else if (equalIgnoringCase("charset", m_rule.characters(), m_rule.length()))
m_state = Initial;
else
m_state = DoneParsingImportRules;
m_rule.clear();
m_ruleValue.clear();
}
void XMLDocumentParser::append(const SegmentedString& s)
{
String parseString = s.toString();
if (m_sawXSLTransform || !m_sawFirstElement)
m_originalSourceForTransform += parseString;
if (isStopped() || m_sawXSLTransform)
return;
if (m_parserPaused) {
m_pendingSrc.append(s);
return;
}
doWrite(s.toString());
// After parsing, go ahead and dispatch image beforeload events.
ImageLoader::dispatchPendingBeforeLoadEvents();
}
static bool consumeNamedEntity(SegmentedString& source, StringBuilder& decodedEntity, bool& notEnoughCharacters, UChar additionalAllowedCharacter, UChar& cc)
{
StringBuilder consumedCharacters;
HTMLEntitySearch entitySearch;
while (!source.isEmpty()) {
cc = source.currentChar();
entitySearch.advance(cc);
if (!entitySearch.isEntityPrefix())
break;
consumedCharacters.append(cc);
source.advance();
}
notEnoughCharacters = source.isEmpty();
if (notEnoughCharacters) {
// We can't an entity because there might be a longer entity
// that we could match if we had more data.
unconsumeCharacters(source, consumedCharacters);
return false;
}
if (!entitySearch.mostRecentMatch()) {
unconsumeCharacters(source, consumedCharacters);
return false;
}
if (entitySearch.mostRecentMatch()->length != entitySearch.currentLength()) {
// We've consumed too many characters. We need to walk the
// source back to the point at which we had consumed an
// actual entity.
unconsumeCharacters(source, consumedCharacters);
consumedCharacters.clear();
const int length = entitySearch.mostRecentMatch()->length;
const LChar* reference = entitySearch.mostRecentMatch()->entity;
for (int i = 0; i < length; ++i) {
cc = source.currentChar();
ASSERT_UNUSED(reference, cc == *reference++);
consumedCharacters.append(cc);
source.advance();
ASSERT(!source.isEmpty());
}
cc = source.currentChar();
}
if (entitySearch.mostRecentMatch()->lastCharacter() == ';'
|| !additionalAllowedCharacter
|| !(isASCIIAlphanumeric(cc) || cc == '=')) {
decodedEntity.append(entitySearch.mostRecentMatch()->firstValue);
if (entitySearch.mostRecentMatch()->secondValue)
decodedEntity.append(entitySearch.mostRecentMatch()->secondValue);
return true;
}
unconsumeCharacters(source, consumedCharacters);
return false;
}
void SegmentedString::append(const SegmentedString &s)
{
ASSERT(!s.escaped());
append(s.m_currentString);
if (s.m_composite) {
DeprecatedValueListConstIterator<SegmentedSubstring> i = s.m_substrings.begin();
DeprecatedValueListConstIterator<SegmentedSubstring> e = s.m_substrings.end();
for (; i != e; ++i)
append(*i);
}
m_currentChar = m_pushedChar1 ? &m_pushedChar1 : m_currentString.m_current;
}
void XMLDocumentParser::resumeParsing()
{
ASSERT(m_parserPaused);
m_parserPaused = false;
// First, execute any pending callbacks
parse();
if (m_parserPaused)
return;
// Then, write any pending data
SegmentedString rest = m_pendingSrc;
m_pendingSrc.clear();
append(rest.toString().impl());
// Finally, if finish() has been called and append() didn't result
// in any further callbacks being queued, call end()
if (m_finishCalled && !m_parserPaused && !m_pendingScript)
end();
}
void SegmentedString::prepend(const SegmentedString& s, PrependType type) {
if (s.isComposite()) {
Deque<SegmentedSubstring>::const_reverse_iterator it =
s.m_substrings.rbegin();
Deque<SegmentedSubstring>::const_reverse_iterator e = s.m_substrings.rend();
for (; it != e; ++it)
prepend(*it, type);
}
prepend(s.m_currentString, type);
m_currentChar =
m_currentString.length() ? m_currentString.getCurrentChar() : 0;
}
void SegmentedString::append(const SegmentedString &s)
{
ASSERT(!m_closed);
ASSERT(!s.escaped());
append(s.m_currentString);
if (s.m_composite) {
Deque<SegmentedSubstring>::const_iterator it = s.m_substrings.begin();
Deque<SegmentedSubstring>::const_iterator e = s.m_substrings.end();
for (; it != e; ++it)
append(*it);
}
m_currentChar = m_pushedChar1 ? &m_pushedChar1 : m_currentString.m_current;
}
void SegmentedString::append(const SegmentedString& s) {
ASSERT(!m_closed);
append(s.m_currentString);
if (s.isComposite()) {
Deque<SegmentedSubstring>::const_iterator it = s.m_substrings.begin();
Deque<SegmentedSubstring>::const_iterator e = s.m_substrings.end();
for (; it != e; ++it)
append(*it);
}
m_currentChar =
m_currentString.length() ? m_currentString.getCurrentChar() : 0;
}
void SegmentedString::prepend(const SegmentedString &s)
{
ASSERT(!escaped());
ASSERT(!s.escaped());
if (s.m_composite) {
DeprecatedValueListConstIterator<SegmentedSubstring> i = s.m_substrings.fromLast();
DeprecatedValueListConstIterator<SegmentedSubstring> e = s.m_substrings.end();
for (; i != e; --i)
prepend(*i);
}
prepend(s.m_currentString);
m_currentChar = m_pushedChar1 ? &m_pushedChar1 : m_currentString.m_current;
}
static inline void documentWrite(ExecState* exec, HTMLDocument* document, NewlineRequirement addNewline)
{
// DOM only specifies single string argument, but browsers allow multiple or no arguments.
size_t size = exec->argumentCount();
UString firstString = exec->argument(0).toString(exec);
SegmentedString segmentedString = ustringToString(firstString);
if (size != 1) {
if (!size)
segmentedString.clear();
else {
for (size_t i = 1; i < size; ++i) {
UString subsequentString = exec->argument(i).toString(exec);
segmentedString.append(SegmentedString(ustringToString(subsequentString)));
}
}
}
if (addNewline)
segmentedString.append(SegmentedString(&newlineCharacter, 1));
Document* activeDocument = asJSDOMWindow(exec->lexicalGlobalObject())->impl()->document();
document->write(segmentedString, activeDocument);
}
void SegmentedString::append(const SegmentedString& s)
{
ASSERT(!m_closed);
if (s.m_pushedChar1) {
Vector<UChar, 2> unconsumedData;
unconsumedData.append(s.m_pushedChar1);
if (s.m_pushedChar2)
unconsumedData.append(s.m_pushedChar2);
append(SegmentedSubstring(String(unconsumedData)));
}
append(s.m_currentString);
if (s.isComposite()) {
Deque<SegmentedSubstring>::const_iterator it = s.m_substrings.begin();
Deque<SegmentedSubstring>::const_iterator e = s.m_substrings.end();
for (; it != e; ++it)
append(*it);
}
m_currentChar = m_pushedChar1 ? m_pushedChar1 : (m_currentString.m_length ? m_currentString.getCurrentChar() : 0);
}
bool FTPDirectoryTokenizer::write(const SegmentedString& s, bool appendData)
{
// Make sure we have the table element to append to by loading the template set in the pref, or
// creating a very basic document with the appropriate table
if (!m_tableElement) {
if (!loadDocumentTemplate())
createBasicDocument();
ASSERT(m_tableElement);
}
bool foundNewLine = false;
m_dest = m_buffer;
SegmentedString str = s;
while (!str.isEmpty()) {
UChar c = *str;
if (c == '\r') {
*m_dest++ = '\n';
// possibly skip an LF in the case of an CRLF sequence
m_skipLF = true;
} else if (c == '\n') {
if (!m_skipLF)
*m_dest++ = c;
else
m_skipLF = false;
foundNewLine = true;
} else {
*m_dest++ = c;
m_skipLF = false;
}
str.advance(0);
// Maybe enlarge the buffer
checkBuffer();
}
if (!foundNewLine) {
m_dest = m_buffer;
return false;
}
UChar* start = m_buffer;
UChar* cursor = start;
while (cursor < m_dest) {
if (*cursor == '\n') {
m_carryOver.append(String(start, cursor - start));
LOG(FTP, "%s", m_carryOver.ascii().data());
parseAndAppendOneLine(m_carryOver);
m_carryOver = String();
start = ++cursor;
} else
cursor++;
}
// Copy the partial line we have left to the carryover buffer
if (cursor - start > 1)
m_carryOver.append(String(start, cursor - start - 1));
return false;
}
bool consumeHTMLEntity(SegmentedString& source, Vector<UChar, 16>& decodedEntity, bool& notEnoughCharacters, UChar additionalAllowedCharacter)
{
ASSERT(!additionalAllowedCharacter || additionalAllowedCharacter == '"' || additionalAllowedCharacter == '\'' || additionalAllowedCharacter == '>');
ASSERT(!notEnoughCharacters);
ASSERT(decodedEntity.isEmpty());
enum EntityState {
Initial,
Number,
MaybeHexLowerCaseX,
MaybeHexUpperCaseX,
Hex,
Decimal,
Named
};
EntityState entityState = Initial;
UChar32 result = 0;
Vector<UChar, 10> consumedCharacters;
while (!source.isEmpty()) {
UChar cc = *source;
switch (entityState) {
case Initial: {
if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ' || cc == '<' || cc == '&')
return false;
if (additionalAllowedCharacter && cc == additionalAllowedCharacter)
return false;
if (cc == '#') {
entityState = Number;
break;
}
if ((cc >= 'a' && cc <= 'z') || (cc >= 'A' && cc <= 'Z')) {
entityState = Named;
continue;
}
return false;
}
case Number: {
if (cc == 'x') {
entityState = MaybeHexLowerCaseX;
break;
}
if (cc == 'X') {
entityState = MaybeHexUpperCaseX;
break;
}
if (cc >= '0' && cc <= '9') {
entityState = Decimal;
continue;
}
source.push('#');
return false;
}
case MaybeHexLowerCaseX: {
if (isHexDigit(cc)) {
entityState = Hex;
continue;
}
source.push('#');
source.push('x');
return false;
}
case MaybeHexUpperCaseX: {
if (isHexDigit(cc)) {
entityState = Hex;
continue;
}
source.push('#');
source.push('X');
return false;
}
case Hex: {
if (cc >= '0' && cc <= '9')
result = result * 16 + cc - '0';
else if (cc >= 'a' && cc <= 'f')
result = result * 16 + 10 + cc - 'a';
else if (cc >= 'A' && cc <= 'F')
result = result * 16 + 10 + cc - 'A';
else {
if (cc == ';')
source.advanceAndASSERT(cc);
return convertToUTF16(legalEntityFor(result), decodedEntity);
}
break;
}
case Decimal: {
if (cc >= '0' && cc <= '9')
result = result * 10 + cc - '0';
else {
if (cc == ';')
source.advanceAndASSERT(cc);
return convertToUTF16(legalEntityFor(result), decodedEntity);
}
break;
}
case Named: {
HTMLEntitySearch entitySearch;
while (!source.isEmpty()) {
cc = *source;
entitySearch.advance(cc);
if (!entitySearch.isEntityPrefix())
break;
consumedCharacters.append(cc);
source.advanceAndASSERT(cc);
}
notEnoughCharacters = source.isEmpty();
if (notEnoughCharacters) {
// We can't an entity because there might be a longer entity
// that we could match if we had more data.
unconsumeCharacters(source, consumedCharacters);
return false;
}
if (!entitySearch.mostRecentMatch()) {
ASSERT(!entitySearch.currentValue());
unconsumeCharacters(source, consumedCharacters);
return false;
}
if (entitySearch.mostRecentMatch()->length != entitySearch.currentLength()) {
// We've consumed too many characters. We need to walk the
// source back to the point at which we had consumed an
// actual entity.
unconsumeCharacters(source, consumedCharacters);
consumedCharacters.clear();
const int length = entitySearch.mostRecentMatch()->length;
const UChar* reference = entitySearch.mostRecentMatch()->entity;
for (int i = 0; i < length; ++i) {
cc = *source;
ASSERT_UNUSED(reference, cc == *reference++);
consumedCharacters.append(cc);
source.advanceAndASSERT(cc);
ASSERT(!source.isEmpty());
}
cc = *source;
}
if (entitySearch.mostRecentMatch()->lastCharacter() == ';'
|| !additionalAllowedCharacter
|| !(isAlphaNumeric(cc) || cc == '=')) {
return convertToUTF16(entitySearch.mostRecentMatch()->value, decodedEntity);
}
unconsumeCharacters(source, consumedCharacters);
return false;
}
}
consumedCharacters.append(cc);
source.advanceAndASSERT(cc);
}
ASSERT(source.isEmpty());
notEnoughCharacters = true;
unconsumeCharacters(source, consumedCharacters);
return false;
}
void HTMLDocumentParser::append(const SegmentedString& source)
{
if (isStopped())
return;
#if ENABLE(THREADED_HTML_PARSER)
if (shouldUseThreading()) {
if (!m_haveBackgroundParser)
startBackgroundParser();
ParserIdentifier identifier = ParserMap::identifierForParser(this);
const Closure& appendPartial = bind(&BackgroundHTMLParser::appendPartial, identifier, source.toString().isolatedCopy());
HTMLParserThread::shared()->postTask(appendPartial);
return;
}
#endif
// pumpTokenizer can cause this parser to be detached from the Document,
// but we need to ensure it isn't deleted yet.
RefPtr<HTMLDocumentParser> protect(this);
if (m_preloadScanner) {
if (m_input.current().isEmpty() && !isWaitingForScripts()) {
// We have parsed until the end of the current input and so are now moving ahead of the preload scanner.
// Clear the scanner so we know to scan starting from the current input point if we block again.
m_preloadScanner.clear();
} else {
m_preloadScanner->appendToEnd(source);
if (isWaitingForScripts())
m_preloadScanner->scan();
}
}
m_input.appendToEnd(source);
if (inPumpSession()) {
// We've gotten data off the network in a nested write.
// We don't want to consume any more of the input stream now. Do
// not worry. We'll consume this data in a less-nested write().
return;
}
pumpTokenizerIfPossible(AllowYield);
endIfDelayed();
}
static inline void documentWrite(ExecState* exec, HTMLDocument* document, NewlineRequirement addNewline)
{
// DOM only specifies single string argument, but browsers allow multiple or no arguments.
size_t size = exec->argumentCount();
UString firstString = exec->argument(0).toString(exec);
#if defined(JSC_TAINTED)
unsigned int tainted = 0;
if (firstString.isTainted()) {
TaintedStructure trace_struct;
trace_struct.taintedno = firstString.isTainted();
trace_struct.internalfunc = "documentWrite";
trace_struct.jsfunc = "document.write/writeln";
trace_struct.action = "sink";
trace_struct.value = TaintedUtils::UString2string(firstString);
TaintedTrace* trace = TaintedTrace::getInstance();
trace->addTaintedTrace(trace_struct);
tainted = firstString.isTainted();
}
#endif
SegmentedString segmentedString = ustringToString(firstString);
if (size != 1) {
if (!size)
segmentedString.clear();
else {
for (size_t i = 1; i < size; ++i) {
UString subsequentString = exec->argument(i).toString(exec);
#if defined(JSC_TAINTED)
unsigned int c_tainted = 0;
if (subsequentString.isTainted()) {
c_tainted = subsequentString.isTainted();
}
if (c_tainted) {
TaintedStructure trace_struct;
trace_struct.taintedno = c_tainted;
trace_struct.internalfunc = "documentWrite";
trace_struct.jsfunc = "document.write/writeln";
trace_struct.action = "sink";
trace_struct.value = TaintedUtils::UString2string(subsequentString);
TaintedTrace* trace = TaintedTrace::getInstance();
trace->addTaintedTrace(trace_struct);
tainted = c_tainted;
}
#endif
segmentedString.append(SegmentedString(ustringToString(subsequentString)));
}
}
}
if (addNewline)
segmentedString.append(SegmentedString(String(&newlineCharacter, 1)));
Document* activeDocument = asJSDOMWindow(exec->lexicalGlobalObject())->impl()->document();
document->write(segmentedString, activeDocument);
#if defined(JSC_TAINTED)
if (tainted) {
activeDocument->setTainted(tainted);
}
#endif
}