parser/html/nsHtml5TokenizerCppSupplement.h

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "mozilla/CheckedInt.h"
   6 #include "mozilla/Likely.h"
   7
   8 // INT32_MAX is (2^31)-1. Therefore, the highest power-of-two that fits
   9 // is 2^30. Note that this is counting char16_t units. The underlying
  10 // bytes will be twice that, but they fit even in 32-bit size_t even
  11 // if a contiguous chunk of memory of that size is pretty unlikely to
  12 // be available on a 32-bit system.
  13 #define MAX_POWER_OF_TWO_IN_INT32 0x40000000
  14
  15 bool nsHtml5Tokenizer::EnsureBufferSpace(int32_t aLength) {
  16   MOZ_RELEASE_ASSERT(aLength >= 0, "Negative length.");
  17   if (aLength > MAX_POWER_OF_TWO_IN_INT32) {
  18     // Can't happen when loading from network.
  19     return false;
  20   }
  21   mozilla::CheckedInt<int32_t> worstCase(strBufLen);
  22   worstCase += aLength;
  23   worstCase += charRefBufLen;
  24   // Add 2 to account for emissions of LT_GT, LT_SOLIDUS and RSQB_RSQB.
  25   // Adding to the general worst case instead of only the
  26   // TreeBuilder-exposed worst case to avoid re-introducing a bug when
  27   // unifying the tokenizer and tree builder buffers in the future.
  28   worstCase += 2;
  29   if (!worstCase.isValid()) {
  30     return false;
  31   }
  32   if (worstCase.value() > MAX_POWER_OF_TWO_IN_INT32) {
  33     return false;
  34   }
  35   // TODO: Unify nsHtml5Tokenizer::strBuf and nsHtml5TreeBuilder::charBuffer
  36   // so that the call below becomes unnecessary.
  37   if (!tokenHandler->EnsureBufferSpace(worstCase.value())) {
  38     return false;
  39   }
  40   if (!strBuf) {
  41     if (worstCase.value() < MAX_POWER_OF_TWO_IN_INT32) {
  42       // Add one to round to the next power of two to avoid immediate
  43       // reallocation once there are a few characters in the buffer.
  44       worstCase += 1;
  45     }
  46     strBuf = jArray<char16_t, int32_t>::newFallibleJArray(
  47         mozilla::RoundUpPow2(worstCase.value()));
  48     if (!strBuf) {
  49       return false;
  50     }
  51   } else if (worstCase.value() > strBuf.length) {
  52     jArray<char16_t, int32_t> newBuf =
  53         jArray<char16_t, int32_t>::newFallibleJArray(
  54             mozilla::RoundUpPow2(worstCase.value()));
  55     if (!newBuf) {
  56       return false;
  57     }
  58     memcpy(newBuf, strBuf, sizeof(char16_t) * size_t(strBufLen));
  59     strBuf = newBuf;
  60   }
  61   return true;
  62 }
  63
  64 bool nsHtml5Tokenizer::TemplatePushedOrHeadPopped() {
  65   if (encodingDeclarationHandler) {
  66     return encodingDeclarationHandler->TemplatePushedOrHeadPopped();
  67   }
  68   return false;
  69 }
  70
  71 void nsHtml5Tokenizer::RememberGt(int32_t aPos) {
  72   if (encodingDeclarationHandler) {
  73     return encodingDeclarationHandler->RememberGt(aPos);
  74   }
  75 }
  76
  77 void nsHtml5Tokenizer::StartPlainText() {
  78   stateSave = nsHtml5Tokenizer::PLAINTEXT;
  79 }
  80
  81 void nsHtml5Tokenizer::EnableViewSource(nsHtml5Highlighter* aHighlighter) {
  82   mViewSource = mozilla::WrapUnique(aHighlighter);
  83 }
  84
  85 bool nsHtml5Tokenizer::ShouldFlushViewSource() {
  86   return mViewSource->ShouldFlushOps();
  87 }
  88
  89 mozilla::Result<bool, nsresult> nsHtml5Tokenizer::FlushViewSource() {
  90   return mViewSource->FlushOps();
  91 }
  92
  93 void nsHtml5Tokenizer::StartViewSource(const nsAutoString& aTitle) {
  94   mViewSource->Start(aTitle);
  95 }
  96
  97 void nsHtml5Tokenizer::StartViewSourceCharacters() {
  98   mViewSource->StartCharacters();
  99 }
 100
 101 [[nodiscard]] bool nsHtml5Tokenizer::EndViewSource() {
 102   return mViewSource->End();
 103 }
 104
 105 void nsHtml5Tokenizer::SetViewSourceOpSink(nsAHtml5TreeOpSink* aOpSink) {
 106   mViewSource->SetOpSink(aOpSink);
 107 }
 108
 109 void nsHtml5Tokenizer::RewindViewSource() { mViewSource->Rewind(); }
 110
 111 void nsHtml5Tokenizer::errWarnLtSlashInRcdata() {}
 112
 113 // The null checks below annotated MOZ_LIKELY are not actually necessary.
 114
 115 void nsHtml5Tokenizer::errUnquotedAttributeValOrNull(char16_t c) {
 116   if (MOZ_LIKELY(mViewSource)) {
 117     switch (c) {
 118       case '<':
 119         mViewSource->AddErrorToCurrentNode("errUnquotedAttributeLt");
 120         return;
 121       case '`':
 122         mViewSource->AddErrorToCurrentNode("errUnquotedAttributeGrave");
 123         return;
 124       case '\'':
 125       case '"':
 126         mViewSource->AddErrorToCurrentNode("errUnquotedAttributeQuote");
 127         return;
 128       case '=':
 129         mViewSource->AddErrorToCurrentNode("errUnquotedAttributeEquals");
 130         return;
 131     }
 132   }
 133 }
 134
 135 void nsHtml5Tokenizer::errLtOrEqualsOrGraveInUnquotedAttributeOrNull(
 136     char16_t c) {
 137   if (MOZ_LIKELY(mViewSource)) {
 138     switch (c) {
 139       case '=':
 140         mViewSource->AddErrorToCurrentNode("errUnquotedAttributeStartEquals");
 141         return;
 142       case '<':
 143         mViewSource->AddErrorToCurrentNode("errUnquotedAttributeStartLt");
 144         return;
 145       case '`':
 146         mViewSource->AddErrorToCurrentNode("errUnquotedAttributeStartGrave");
 147         return;
 148     }
 149   }
 150 }
 151
 152 void nsHtml5Tokenizer::errBadCharBeforeAttributeNameOrNull(char16_t c) {
 153   if (MOZ_LIKELY(mViewSource)) {
 154     if (c == '<') {
 155       mViewSource->AddErrorToCurrentNode("errBadCharBeforeAttributeNameLt");
 156     } else if (c == '=') {
 157       errEqualsSignBeforeAttributeName();
 158     } else if (c != 0xFFFD) {
 159       errQuoteBeforeAttributeName(c);
 160     }
 161   }
 162 }
 163
 164 void nsHtml5Tokenizer::errBadCharAfterLt(char16_t c) {
 165   if (MOZ_LIKELY(mViewSource)) {
 166     mViewSource->AddErrorToCurrentNode("errBadCharAfterLt");
 167   }
 168 }
 169
 170 void nsHtml5Tokenizer::errQuoteOrLtInAttributeNameOrNull(char16_t c) {
 171   if (MOZ_LIKELY(mViewSource)) {
 172     if (c == '<') {
 173       mViewSource->AddErrorToCurrentNode("errLtInAttributeName");
 174     } else if (c != 0xFFFD) {
 175       mViewSource->AddErrorToCurrentNode("errQuoteInAttributeName");
 176     }
 177   }
 178 }
 179
 180 void nsHtml5Tokenizer::maybeErrAttributesOnEndTag(
 181     nsHtml5HtmlAttributes* attrs) {
 182   if (mViewSource && attrs->getLength() != 0) {
 183     /*
 184      * When an end tag token is emitted with attributes, that is a parse
 185      * error.
 186      */
 187     mViewSource->AddErrorToCurrentRun("maybeErrAttributesOnEndTag");
 188   }
 189 }
 190
 191 void nsHtml5Tokenizer::maybeErrSlashInEndTag(bool selfClosing) {
 192   if (mViewSource && selfClosing && endTag) {
 193     mViewSource->AddErrorToCurrentSlash("maybeErrSlashInEndTag");
 194   }
 195 }
 196
 197 char16_t nsHtml5Tokenizer::errNcrNonCharacter(char16_t ch) {
 198   if (MOZ_UNLIKELY(mViewSource)) {
 199     mViewSource->AddErrorToCurrentNode("errNcrNonCharacter");
 200   }
 201   return ch;
 202 }
 203
 204 void nsHtml5Tokenizer::errAstralNonCharacter(int32_t ch) {
 205   if (MOZ_UNLIKELY(mViewSource)) {
 206     mViewSource->AddErrorToCurrentNode("errNcrNonCharacter");
 207   }
 208 }
 209
 210 char16_t nsHtml5Tokenizer::errNcrControlChar(char16_t ch) {
 211   if (MOZ_UNLIKELY(mViewSource)) {
 212     mViewSource->AddErrorToCurrentNode("errNcrControlChar");
 213   }
 214   return ch;
 215 }
 216
 217 void nsHtml5Tokenizer::errGarbageAfterLtSlash() {
 218   if (MOZ_LIKELY(mViewSource)) {
 219     mViewSource->AddErrorToCurrentNode("errGarbageAfterLtSlash");
 220   }
 221 }
 222
 223 void nsHtml5Tokenizer::errLtSlashGt() {
 224   if (MOZ_LIKELY(mViewSource)) {
 225     mViewSource->AddErrorToCurrentNode("errLtSlashGt");
 226   }
 227 }
 228
 229 void nsHtml5Tokenizer::errCharRefLacksSemicolon() {
 230   if (MOZ_UNLIKELY(mViewSource)) {
 231     mViewSource->AddErrorToCurrentNode("errCharRefLacksSemicolon");
 232   }
 233 }
 234
 235 void nsHtml5Tokenizer::errNoDigitsInNCR() {
 236   if (MOZ_UNLIKELY(mViewSource)) {
 237     mViewSource->AddErrorToCurrentNode("errNoDigitsInNCR");
 238   }
 239 }
 240
 241 void nsHtml5Tokenizer::errGtInSystemId() {
 242   if (MOZ_LIKELY(mViewSource)) {
 243     mViewSource->AddErrorToCurrentNode("errGtInSystemId");
 244   }
 245 }
 246
 247 void nsHtml5Tokenizer::errGtInPublicId() {
 248   if (MOZ_LIKELY(mViewSource)) {
 249     mViewSource->AddErrorToCurrentNode("errGtInPublicId");
 250   }
 251 }
 252
 253 void nsHtml5Tokenizer::errNamelessDoctype() {
 254   if (MOZ_LIKELY(mViewSource)) {
 255     mViewSource->AddErrorToCurrentNode("errNamelessDoctype");
 256   }
 257 }
 258
 259 void nsHtml5Tokenizer::errConsecutiveHyphens() {
 260   if (MOZ_UNLIKELY(mViewSource)) {
 261     mViewSource->AddErrorToCurrentNode("errConsecutiveHyphens");
 262   }
 263 }
 264
 265 void nsHtml5Tokenizer::errPrematureEndOfComment() {
 266   if (MOZ_LIKELY(mViewSource)) {
 267     mViewSource->AddErrorToCurrentNode("errPrematureEndOfComment");
 268   }
 269 }
 270
 271 void nsHtml5Tokenizer::errBogusComment() {
 272   if (MOZ_UNLIKELY(mViewSource)) {
 273     mViewSource->AddErrorToCurrentNode("errBogusComment");
 274   }
 275 }
 276
 277 void nsHtml5Tokenizer::errSlashNotFollowedByGt() {
 278   if (MOZ_LIKELY(mViewSource)) {
 279     mViewSource->AddErrorToCurrentSlash("errSlashNotFollowedByGt");
 280   }
 281 }
 282
 283 void nsHtml5Tokenizer::errNoSpaceBetweenAttributes() {
 284   if (MOZ_LIKELY(mViewSource)) {
 285     mViewSource->AddErrorToCurrentNode("errNoSpaceBetweenAttributes");
 286   }
 287 }
 288
 289 void nsHtml5Tokenizer::errAttributeValueMissing() {
 290   if (MOZ_LIKELY(mViewSource)) {
 291     mViewSource->AddErrorToCurrentNode("errAttributeValueMissing");
 292   }
 293 }
 294
 295 void nsHtml5Tokenizer::errEqualsSignBeforeAttributeName() {
 296   if (MOZ_LIKELY(mViewSource)) {
 297     mViewSource->AddErrorToCurrentNode("errEqualsSignBeforeAttributeName");
 298   }
 299 }
 300
 301 void nsHtml5Tokenizer::errLtGt() {
 302   if (MOZ_LIKELY(mViewSource)) {
 303     mViewSource->AddErrorToCurrentNode("errLtGt");
 304   }
 305 }
 306
 307 void nsHtml5Tokenizer::errProcessingInstruction() {
 308   if (MOZ_LIKELY(mViewSource)) {
 309     mViewSource->AddErrorToCurrentNode("errProcessingInstruction");
 310   }
 311 }
 312
 313 void nsHtml5Tokenizer::errUnescapedAmpersandInterpretedAsCharacterReference() {
 314   if (MOZ_UNLIKELY(mViewSource)) {
 315     mViewSource->AddErrorToCurrentAmpersand(
 316         "errUnescapedAmpersandInterpretedAsCharacterReference");
 317   }
 318 }
 319
 320 void nsHtml5Tokenizer::errNotSemicolonTerminated() {
 321   if (MOZ_UNLIKELY(mViewSource)) {
 322     mViewSource->AddErrorToCurrentNode("errNotSemicolonTerminated");
 323   }
 324 }
 325
 326 void nsHtml5Tokenizer::errNoNamedCharacterMatch() {
 327   if (MOZ_UNLIKELY(mViewSource)) {
 328     mViewSource->AddErrorToCurrentAmpersand("errNoNamedCharacterMatch");
 329   }
 330 }
 331
 332 void nsHtml5Tokenizer::errQuoteBeforeAttributeName(char16_t c) {
 333   if (MOZ_LIKELY(mViewSource)) {
 334     mViewSource->AddErrorToCurrentNode("errQuoteBeforeAttributeName");
 335   }
 336 }
 337
 338 void nsHtml5Tokenizer::errExpectedPublicId() {
 339   if (MOZ_LIKELY(mViewSource)) {
 340     mViewSource->AddErrorToCurrentNode("errExpectedPublicId");
 341   }
 342 }
 343
 344 void nsHtml5Tokenizer::errBogusDoctype() {
 345   if (MOZ_UNLIKELY(mViewSource)) {
 346     mViewSource->AddErrorToCurrentNode("errBogusDoctype");
 347   }
 348 }
 349
 350 void nsHtml5Tokenizer::errNcrSurrogate() {
 351   if (MOZ_UNLIKELY(mViewSource)) {
 352     mViewSource->AddErrorToCurrentNode("errNcrSurrogate");
 353   }
 354 }
 355
 356 void nsHtml5Tokenizer::errNcrCr() {
 357   if (MOZ_UNLIKELY(mViewSource)) {
 358     mViewSource->AddErrorToCurrentNode("errNcrCr");
 359   }
 360 }
 361
 362 void nsHtml5Tokenizer::errNcrInC1Range() {
 363   if (MOZ_UNLIKELY(mViewSource)) {
 364     mViewSource->AddErrorToCurrentNode("errNcrInC1Range");
 365   }
 366 }
 367
 368 void nsHtml5Tokenizer::errEofInPublicId() {
 369   if (MOZ_UNLIKELY(mViewSource)) {
 370     mViewSource->AddErrorToCurrentRun("errEofInPublicId");
 371   }
 372 }
 373
 374 void nsHtml5Tokenizer::errEofInComment() {
 375   if (MOZ_UNLIKELY(mViewSource)) {
 376     mViewSource->AddErrorToCurrentRun("errEofInComment");
 377   }
 378 }
 379
 380 void nsHtml5Tokenizer::errEofInDoctype() {
 381   if (MOZ_UNLIKELY(mViewSource)) {
 382     mViewSource->AddErrorToCurrentRun("errEofInDoctype");
 383   }
 384 }
 385
 386 void nsHtml5Tokenizer::errEofInAttributeValue() {
 387   if (MOZ_UNLIKELY(mViewSource)) {
 388     mViewSource->AddErrorToCurrentRun("errEofInAttributeValue");
 389   }
 390 }
 391
 392 void nsHtml5Tokenizer::errEofInAttributeName() {
 393   if (MOZ_UNLIKELY(mViewSource)) {
 394     mViewSource->AddErrorToCurrentRun("errEofInAttributeName");
 395   }
 396 }
 397
 398 void nsHtml5Tokenizer::errEofWithoutGt() {
 399   if (MOZ_UNLIKELY(mViewSource)) {
 400     mViewSource->AddErrorToCurrentRun("errEofWithoutGt");
 401   }
 402 }
 403
 404 void nsHtml5Tokenizer::errEofInTagName() {
 405   if (MOZ_UNLIKELY(mViewSource)) {
 406     mViewSource->AddErrorToCurrentRun("errEofInTagName");
 407   }
 408 }
 409
 410 void nsHtml5Tokenizer::errEofInEndTag() {
 411   if (MOZ_UNLIKELY(mViewSource)) {
 412     mViewSource->AddErrorToCurrentRun("errEofInEndTag");
 413   }
 414 }
 415
 416 void nsHtml5Tokenizer::errEofAfterLt() {
 417   if (MOZ_UNLIKELY(mViewSource)) {
 418     mViewSource->AddErrorToCurrentRun("errEofAfterLt");
 419   }
 420 }
 421
 422 void nsHtml5Tokenizer::errNcrOutOfRange() {
 423   if (MOZ_UNLIKELY(mViewSource)) {
 424     mViewSource->AddErrorToCurrentNode("errNcrOutOfRange");
 425   }
 426 }
 427
 428 void nsHtml5Tokenizer::errNcrUnassigned() {
 429   if (MOZ_UNLIKELY(mViewSource)) {
 430     mViewSource->AddErrorToCurrentNode("errNcrUnassigned");
 431   }
 432 }
 433
 434 void nsHtml5Tokenizer::errDuplicateAttribute() {
 435   if (attributes) {
 436     // There is an open issue for properly specifying this:
 437     // https://github.com/whatwg/html/issues/3257
 438     attributes->setDuplicateAttributeError();
 439   }
 440
 441   if (MOZ_UNLIKELY(mViewSource)) {
 442     mViewSource->AddErrorToCurrentNode("errDuplicateAttribute");
 443   }
 444 }
 445
 446 void nsHtml5Tokenizer::errEofInSystemId() {
 447   if (MOZ_UNLIKELY(mViewSource)) {
 448     mViewSource->AddErrorToCurrentRun("errEofInSystemId");
 449   }
 450 }
 451
 452 void nsHtml5Tokenizer::errExpectedSystemId() {
 453   if (MOZ_LIKELY(mViewSource)) {
 454     mViewSource->AddErrorToCurrentNode("errExpectedSystemId");
 455   }
 456 }
 457
 458 void nsHtml5Tokenizer::errMissingSpaceBeforeDoctypeName() {
 459   if (MOZ_LIKELY(mViewSource)) {
 460     mViewSource->AddErrorToCurrentNode("errMissingSpaceBeforeDoctypeName");
 461   }
 462 }
 463
 464 void nsHtml5Tokenizer::errNestedComment() {
 465   if (MOZ_LIKELY(mViewSource)) {
 466     mViewSource->AddErrorToCurrentNode("errNestedComment");
 467   }
 468 }
 469
 470 void nsHtml5Tokenizer::errNcrControlChar() {
 471   if (MOZ_UNLIKELY(mViewSource)) {
 472     mViewSource->AddErrorToCurrentNode("errNcrControlChar");
 473   }
 474 }
 475
 476 void nsHtml5Tokenizer::errNcrZero() {
 477   if (MOZ_UNLIKELY(mViewSource)) {
 478     mViewSource->AddErrorToCurrentNode("errNcrZero");
 479   }
 480 }
 481
 482 void nsHtml5Tokenizer::errNoSpaceBetweenDoctypeSystemKeywordAndQuote() {
 483   if (MOZ_LIKELY(mViewSource)) {
 484     mViewSource->AddErrorToCurrentNode(
 485         "errNoSpaceBetweenDoctypeSystemKeywordAndQuote");
 486   }
 487 }
 488
 489 void nsHtml5Tokenizer::errNoSpaceBetweenPublicAndSystemIds() {
 490   if (MOZ_LIKELY(mViewSource)) {
 491     mViewSource->AddErrorToCurrentNode("errNoSpaceBetweenPublicAndSystemIds");
 492   }
 493 }
 494
 495 void nsHtml5Tokenizer::errNoSpaceBetweenDoctypePublicKeywordAndQuote() {
 496   if (MOZ_LIKELY(mViewSource)) {
 497     mViewSource->AddErrorToCurrentNode(
 498         "errNoSpaceBetweenDoctypePublicKeywordAndQuote");
 499   }
 500 }