The Tor Browser / file comparison

comparison: parser/html/nsHtml5MetaScanner.cpp

parser/html/nsHtml5MetaScanner.cpp

branch
TOR_BUG_9701
changeset 14
925c144e1f1f
equal deleted inserted replaced
-1:000000000000 0:e8f4e9c3842f
1 /*
2 * Copyright (c) 2007 Henri Sivonen
3 * Copyright (c) 2008-2010 Mozilla Foundation
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24 /*
25 * THIS IS A GENERATED FILE. PLEASE DO NOT EDIT.
26 * Please edit MetaScanner.java instead and regenerate.
27 */
28
29 #define nsHtml5MetaScanner_cpp__
30
31 #include "nsIAtom.h"
32 #include "nsHtml5AtomTable.h"
33 #include "nsString.h"
34 #include "nsNameSpaceManager.h"
35 #include "nsIContent.h"
36 #include "nsTraceRefcnt.h"
37 #include "jArray.h"
38 #include "nsHtml5ArrayCopy.h"
39 #include "nsAHtml5TreeBuilderState.h"
40 #include "nsHtml5Atoms.h"
41 #include "nsHtml5ByteReadable.h"
42 #include "nsIUnicodeDecoder.h"
43 #include "nsHtml5Macros.h"
44 #include "nsIContentHandle.h"
45
46 #include "nsHtml5Tokenizer.h"
47 #include "nsHtml5TreeBuilder.h"
48 #include "nsHtml5AttributeName.h"
49 #include "nsHtml5ElementName.h"
50 #include "nsHtml5HtmlAttributes.h"
51 #include "nsHtml5StackNode.h"
52 #include "nsHtml5UTF16Buffer.h"
53 #include "nsHtml5StateSnapshot.h"
54 #include "nsHtml5Portability.h"
55
56 #include "nsHtml5MetaScanner.h"
57
58 static char16_t const CHARSET_DATA[] = { 'h', 'a', 'r', 's', 'e', 't' };
59 staticJArray<char16_t,int32_t> nsHtml5MetaScanner::CHARSET = { CHARSET_DATA, MOZ_ARRAY_LENGTH(CHARSET_DATA) };
60 static char16_t const CONTENT_DATA[] = { 'o', 'n', 't', 'e', 'n', 't' };
61 staticJArray<char16_t,int32_t> nsHtml5MetaScanner::CONTENT = { CONTENT_DATA, MOZ_ARRAY_LENGTH(CONTENT_DATA) };
62 static char16_t const HTTP_EQUIV_DATA[] = { 't', 't', 'p', '-', 'e', 'q', 'u', 'i', 'v' };
63 staticJArray<char16_t,int32_t> nsHtml5MetaScanner::HTTP_EQUIV = { HTTP_EQUIV_DATA, MOZ_ARRAY_LENGTH(HTTP_EQUIV_DATA) };
64 static char16_t const CONTENT_TYPE_DATA[] = { 'c', 'o', 'n', 't', 'e', 'n', 't', '-', 't', 'y', 'p', 'e' };
65 staticJArray<char16_t,int32_t> nsHtml5MetaScanner::CONTENT_TYPE = { CONTENT_TYPE_DATA, MOZ_ARRAY_LENGTH(CONTENT_TYPE_DATA) };
66
67 nsHtml5MetaScanner::nsHtml5MetaScanner()
68 : readable(nullptr),
69 metaState(NS_HTML5META_SCANNER_NO),
70 contentIndex(INT32_MAX),
71 charsetIndex(INT32_MAX),
72 httpEquivIndex(INT32_MAX),
73 contentTypeIndex(INT32_MAX),
74 stateSave(NS_HTML5META_SCANNER_DATA),
75 strBufLen(0),
76 strBuf(jArray<char16_t,int32_t>::newJArray(36)),
77 content(nullptr),
78 charset(nullptr),
79 httpEquivState(NS_HTML5META_SCANNER_HTTP_EQUIV_NOT_SEEN)
80 {
81 MOZ_COUNT_CTOR(nsHtml5MetaScanner);
82 }
83
84
85 nsHtml5MetaScanner::~nsHtml5MetaScanner()
86 {
87 MOZ_COUNT_DTOR(nsHtml5MetaScanner);
88 nsHtml5Portability::releaseString(content);
89 nsHtml5Portability::releaseString(charset);
90 }
91
92 void
93 nsHtml5MetaScanner::stateLoop(int32_t state)
94 {
95 int32_t c = -1;
96 bool reconsume = false;
97 stateloop: for (; ; ) {
98 switch(state) {
99 case NS_HTML5META_SCANNER_DATA: {
100 for (; ; ) {
101 if (reconsume) {
102 reconsume = false;
103 } else {
104 c = read();
105 }
106 switch(c) {
107 case -1: {
108 NS_HTML5_BREAK(stateloop);
109 }
110 case '<': {
111 state = NS_HTML5META_SCANNER_TAG_OPEN;
112 NS_HTML5_BREAK(dataloop);
113 }
114 default: {
115 continue;
116 }
117 }
118 }
119 dataloop_end: ;
120 }
121 case NS_HTML5META_SCANNER_TAG_OPEN: {
122 for (; ; ) {
123 c = read();
124 switch(c) {
125 case -1: {
126 NS_HTML5_BREAK(stateloop);
127 }
128 case 'm':
129 case 'M': {
130 metaState = NS_HTML5META_SCANNER_M;
131 state = NS_HTML5META_SCANNER_TAG_NAME;
132 NS_HTML5_BREAK(tagopenloop);
133 }
134 case '!': {
135 state = NS_HTML5META_SCANNER_MARKUP_DECLARATION_OPEN;
136 NS_HTML5_CONTINUE(stateloop);
137 }
138 case '\?':
139 case '/': {
140 state = NS_HTML5META_SCANNER_SCAN_UNTIL_GT;
141 NS_HTML5_CONTINUE(stateloop);
142 }
143 case '>': {
144 state = NS_HTML5META_SCANNER_DATA;
145 NS_HTML5_CONTINUE(stateloop);
146 }
147 default: {
148 if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
149 metaState = NS_HTML5META_SCANNER_NO;
150 state = NS_HTML5META_SCANNER_TAG_NAME;
151 NS_HTML5_BREAK(tagopenloop);
152 }
153 state = NS_HTML5META_SCANNER_DATA;
154 reconsume = true;
155 NS_HTML5_CONTINUE(stateloop);
156 }
157 }
158 }
159 tagopenloop_end: ;
160 }
161 case NS_HTML5META_SCANNER_TAG_NAME: {
162 for (; ; ) {
163 c = read();
164 switch(c) {
165 case -1: {
166 NS_HTML5_BREAK(stateloop);
167 }
168 case ' ':
169 case '\t':
170 case '\n':
171 case '\f': {
172 state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_NAME;
173 NS_HTML5_BREAK(tagnameloop);
174 }
175 case '/': {
176 state = NS_HTML5META_SCANNER_SELF_CLOSING_START_TAG;
177 NS_HTML5_CONTINUE(stateloop);
178 }
179 case '>': {
180 state = NS_HTML5META_SCANNER_DATA;
181 NS_HTML5_CONTINUE(stateloop);
182 }
183 case 'e':
184 case 'E': {
185 if (metaState == NS_HTML5META_SCANNER_M) {
186 metaState = NS_HTML5META_SCANNER_E;
187 } else {
188 metaState = NS_HTML5META_SCANNER_NO;
189 }
190 continue;
191 }
192 case 't':
193 case 'T': {
194 if (metaState == NS_HTML5META_SCANNER_E) {
195 metaState = NS_HTML5META_SCANNER_T;
196 } else {
197 metaState = NS_HTML5META_SCANNER_NO;
198 }
199 continue;
200 }
201 case 'a':
202 case 'A': {
203 if (metaState == NS_HTML5META_SCANNER_T) {
204 metaState = NS_HTML5META_SCANNER_A;
205 } else {
206 metaState = NS_HTML5META_SCANNER_NO;
207 }
208 continue;
209 }
210 default: {
211 metaState = NS_HTML5META_SCANNER_NO;
212 continue;
213 }
214 }
215 }
216 tagnameloop_end: ;
217 }
218 case NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_NAME: {
219 for (; ; ) {
220 if (reconsume) {
221 reconsume = false;
222 } else {
223 c = read();
224 }
225 switch(c) {
226 case -1: {
227 NS_HTML5_BREAK(stateloop);
228 }
229 case ' ':
230 case '\t':
231 case '\n':
232 case '\f': {
233 continue;
234 }
235 case '/': {
236 state = NS_HTML5META_SCANNER_SELF_CLOSING_START_TAG;
237 NS_HTML5_CONTINUE(stateloop);
238 }
239 case '>': {
240 if (handleTag()) {
241 NS_HTML5_BREAK(stateloop);
242 }
243 state = NS_HTML5META_SCANNER_DATA;
244 NS_HTML5_CONTINUE(stateloop);
245 }
246 case 'c':
247 case 'C': {
248 contentIndex = 0;
249 charsetIndex = 0;
250 httpEquivIndex = INT32_MAX;
251 contentTypeIndex = INT32_MAX;
252 state = NS_HTML5META_SCANNER_ATTRIBUTE_NAME;
253 NS_HTML5_BREAK(beforeattributenameloop);
254 }
255 case 'h':
256 case 'H': {
257 contentIndex = INT32_MAX;
258 charsetIndex = INT32_MAX;
259 httpEquivIndex = 0;
260 contentTypeIndex = INT32_MAX;
261 state = NS_HTML5META_SCANNER_ATTRIBUTE_NAME;
262 NS_HTML5_BREAK(beforeattributenameloop);
263 }
264 default: {
265 contentIndex = INT32_MAX;
266 charsetIndex = INT32_MAX;
267 httpEquivIndex = INT32_MAX;
268 contentTypeIndex = INT32_MAX;
269 state = NS_HTML5META_SCANNER_ATTRIBUTE_NAME;
270 NS_HTML5_BREAK(beforeattributenameloop);
271 }
272 }
273 }
274 beforeattributenameloop_end: ;
275 }
276 case NS_HTML5META_SCANNER_ATTRIBUTE_NAME: {
277 for (; ; ) {
278 c = read();
279 switch(c) {
280 case -1: {
281 NS_HTML5_BREAK(stateloop);
282 }
283 case ' ':
284 case '\t':
285 case '\n':
286 case '\f': {
287 state = NS_HTML5META_SCANNER_AFTER_ATTRIBUTE_NAME;
288 NS_HTML5_CONTINUE(stateloop);
289 }
290 case '/': {
291 state = NS_HTML5META_SCANNER_SELF_CLOSING_START_TAG;
292 NS_HTML5_CONTINUE(stateloop);
293 }
294 case '=': {
295 strBufLen = 0;
296 contentTypeIndex = 0;
297 state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_VALUE;
298 NS_HTML5_BREAK(attributenameloop);
299 }
300 case '>': {
301 if (handleTag()) {
302 NS_HTML5_BREAK(stateloop);
303 }
304 state = NS_HTML5META_SCANNER_DATA;
305 NS_HTML5_CONTINUE(stateloop);
306 }
307 default: {
308 if (metaState == NS_HTML5META_SCANNER_A) {
309 if (c >= 'A' && c <= 'Z') {
310 c += 0x20;
311 }
312 if (contentIndex < CONTENT.length && c == CONTENT[contentIndex]) {
313 ++contentIndex;
314 } else {
315 contentIndex = INT32_MAX;
316 }
317 if (charsetIndex < CHARSET.length && c == CHARSET[charsetIndex]) {
318 ++charsetIndex;
319 } else {
320 charsetIndex = INT32_MAX;
321 }
322 if (httpEquivIndex < HTTP_EQUIV.length && c == HTTP_EQUIV[httpEquivIndex]) {
323 ++httpEquivIndex;
324 } else {
325 httpEquivIndex = INT32_MAX;
326 }
327 }
328 continue;
329 }
330 }
331 }
332 attributenameloop_end: ;
333 }
334 case NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_VALUE: {
335 for (; ; ) {
336 c = read();
337 switch(c) {
338 case -1: {
339 NS_HTML5_BREAK(stateloop);
340 }
341 case ' ':
342 case '\t':
343 case '\n':
344 case '\f': {
345 continue;
346 }
347 case '\"': {
348 state = NS_HTML5META_SCANNER_ATTRIBUTE_VALUE_DOUBLE_QUOTED;
349 NS_HTML5_BREAK(beforeattributevalueloop);
350 }
351 case '\'': {
352 state = NS_HTML5META_SCANNER_ATTRIBUTE_VALUE_SINGLE_QUOTED;
353 NS_HTML5_CONTINUE(stateloop);
354 }
355 case '>': {
356 if (handleTag()) {
357 NS_HTML5_BREAK(stateloop);
358 }
359 state = NS_HTML5META_SCANNER_DATA;
360 NS_HTML5_CONTINUE(stateloop);
361 }
362 default: {
363 handleCharInAttributeValue(c);
364 state = NS_HTML5META_SCANNER_ATTRIBUTE_VALUE_UNQUOTED;
365 NS_HTML5_CONTINUE(stateloop);
366 }
367 }
368 }
369 beforeattributevalueloop_end: ;
370 }
371 case NS_HTML5META_SCANNER_ATTRIBUTE_VALUE_DOUBLE_QUOTED: {
372 for (; ; ) {
373 if (reconsume) {
374 reconsume = false;
375 } else {
376 c = read();
377 }
378 switch(c) {
379 case -1: {
380 NS_HTML5_BREAK(stateloop);
381 }
382 case '\"': {
383 handleAttributeValue();
384 state = NS_HTML5META_SCANNER_AFTER_ATTRIBUTE_VALUE_QUOTED;
385 NS_HTML5_BREAK(attributevaluedoublequotedloop);
386 }
387 default: {
388 handleCharInAttributeValue(c);
389 continue;
390 }
391 }
392 }
393 attributevaluedoublequotedloop_end: ;
394 }
395 case NS_HTML5META_SCANNER_AFTER_ATTRIBUTE_VALUE_QUOTED: {
396 for (; ; ) {
397 c = read();
398 switch(c) {
399 case -1: {
400 NS_HTML5_BREAK(stateloop);
401 }
402 case ' ':
403 case '\t':
404 case '\n':
405 case '\f': {
406 state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_NAME;
407 NS_HTML5_CONTINUE(stateloop);
408 }
409 case '/': {
410 state = NS_HTML5META_SCANNER_SELF_CLOSING_START_TAG;
411 NS_HTML5_BREAK(afterattributevaluequotedloop);
412 }
413 case '>': {
414 if (handleTag()) {
415 NS_HTML5_BREAK(stateloop);
416 }
417 state = NS_HTML5META_SCANNER_DATA;
418 NS_HTML5_CONTINUE(stateloop);
419 }
420 default: {
421 state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_NAME;
422 reconsume = true;
423 NS_HTML5_CONTINUE(stateloop);
424 }
425 }
426 }
427 afterattributevaluequotedloop_end: ;
428 }
429 case NS_HTML5META_SCANNER_SELF_CLOSING_START_TAG: {
430 c = read();
431 switch(c) {
432 case -1: {
433 NS_HTML5_BREAK(stateloop);
434 }
435 case '>': {
436 if (handleTag()) {
437 NS_HTML5_BREAK(stateloop);
438 }
439 state = NS_HTML5META_SCANNER_DATA;
440 NS_HTML5_CONTINUE(stateloop);
441 }
442 default: {
443 state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_NAME;
444 reconsume = true;
445 NS_HTML5_CONTINUE(stateloop);
446 }
447 }
448 }
449 case NS_HTML5META_SCANNER_ATTRIBUTE_VALUE_UNQUOTED: {
450 for (; ; ) {
451 if (reconsume) {
452 reconsume = false;
453 } else {
454 c = read();
455 }
456 switch(c) {
457 case -1: {
458 NS_HTML5_BREAK(stateloop);
459 }
460 case ' ':
461 case '\t':
462 case '\n':
463 case '\f': {
464 handleAttributeValue();
465 state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_NAME;
466 NS_HTML5_CONTINUE(stateloop);
467 }
468 case '>': {
469 handleAttributeValue();
470 if (handleTag()) {
471 NS_HTML5_BREAK(stateloop);
472 }
473 state = NS_HTML5META_SCANNER_DATA;
474 NS_HTML5_CONTINUE(stateloop);
475 }
476 default: {
477 handleCharInAttributeValue(c);
478 continue;
479 }
480 }
481 }
482 }
483 case NS_HTML5META_SCANNER_AFTER_ATTRIBUTE_NAME: {
484 for (; ; ) {
485 c = read();
486 switch(c) {
487 case -1: {
488 NS_HTML5_BREAK(stateloop);
489 }
490 case ' ':
491 case '\t':
492 case '\n':
493 case '\f': {
494 continue;
495 }
496 case '/': {
497 handleAttributeValue();
498 state = NS_HTML5META_SCANNER_SELF_CLOSING_START_TAG;
499 NS_HTML5_CONTINUE(stateloop);
500 }
501 case '=': {
502 strBufLen = 0;
503 contentTypeIndex = 0;
504 state = NS_HTML5META_SCANNER_BEFORE_ATTRIBUTE_VALUE;
505 NS_HTML5_CONTINUE(stateloop);
506 }
507 case '>': {
508 handleAttributeValue();
509 if (handleTag()) {
510 NS_HTML5_BREAK(stateloop);
511 }
512 state = NS_HTML5META_SCANNER_DATA;
513 NS_HTML5_CONTINUE(stateloop);
514 }
515 case 'c':
516 case 'C': {
517 contentIndex = 0;
518 charsetIndex = 0;
519 state = NS_HTML5META_SCANNER_ATTRIBUTE_NAME;
520 NS_HTML5_CONTINUE(stateloop);
521 }
522 default: {
523 contentIndex = INT32_MAX;
524 charsetIndex = INT32_MAX;
525 state = NS_HTML5META_SCANNER_ATTRIBUTE_NAME;
526 NS_HTML5_CONTINUE(stateloop);
527 }
528 }
529 }
530 }
531 case NS_HTML5META_SCANNER_MARKUP_DECLARATION_OPEN: {
532 for (; ; ) {
533 c = read();
534 switch(c) {
535 case -1: {
536 NS_HTML5_BREAK(stateloop);
537 }
538 case '-': {
539 state = NS_HTML5META_SCANNER_MARKUP_DECLARATION_HYPHEN;
540 NS_HTML5_BREAK(markupdeclarationopenloop);
541 }
542 default: {
543 state = NS_HTML5META_SCANNER_SCAN_UNTIL_GT;
544 reconsume = true;
545 NS_HTML5_CONTINUE(stateloop);
546 }
547 }
548 }
549 markupdeclarationopenloop_end: ;
550 }
551 case NS_HTML5META_SCANNER_MARKUP_DECLARATION_HYPHEN: {
552 for (; ; ) {
553 c = read();
554 switch(c) {
555 case -1: {
556 NS_HTML5_BREAK(stateloop);
557 }
558 case '-': {
559 state = NS_HTML5META_SCANNER_COMMENT_START;
560 NS_HTML5_BREAK(markupdeclarationhyphenloop);
561 }
562 default: {
563 state = NS_HTML5META_SCANNER_SCAN_UNTIL_GT;
564 reconsume = true;
565 NS_HTML5_CONTINUE(stateloop);
566 }
567 }
568 }
569 markupdeclarationhyphenloop_end: ;
570 }
571 case NS_HTML5META_SCANNER_COMMENT_START: {
572 for (; ; ) {
573 c = read();
574 switch(c) {
575 case -1: {
576 NS_HTML5_BREAK(stateloop);
577 }
578 case '-': {
579 state = NS_HTML5META_SCANNER_COMMENT_START_DASH;
580 NS_HTML5_CONTINUE(stateloop);
581 }
582 case '>': {
583 state = NS_HTML5META_SCANNER_DATA;
584 NS_HTML5_CONTINUE(stateloop);
585 }
586 default: {
587 state = NS_HTML5META_SCANNER_COMMENT;
588 NS_HTML5_BREAK(commentstartloop);
589 }
590 }
591 }
592 commentstartloop_end: ;
593 }
594 case NS_HTML5META_SCANNER_COMMENT: {
595 for (; ; ) {
596 c = read();
597 switch(c) {
598 case -1: {
599 NS_HTML5_BREAK(stateloop);
600 }
601 case '-': {
602 state = NS_HTML5META_SCANNER_COMMENT_END_DASH;
603 NS_HTML5_BREAK(commentloop);
604 }
605 default: {
606 continue;
607 }
608 }
609 }
610 commentloop_end: ;
611 }
612 case NS_HTML5META_SCANNER_COMMENT_END_DASH: {
613 for (; ; ) {
614 c = read();
615 switch(c) {
616 case -1: {
617 NS_HTML5_BREAK(stateloop);
618 }
619 case '-': {
620 state = NS_HTML5META_SCANNER_COMMENT_END;
621 NS_HTML5_BREAK(commentenddashloop);
622 }
623 default: {
624 state = NS_HTML5META_SCANNER_COMMENT;
625 NS_HTML5_CONTINUE(stateloop);
626 }
627 }
628 }
629 commentenddashloop_end: ;
630 }
631 case NS_HTML5META_SCANNER_COMMENT_END: {
632 for (; ; ) {
633 c = read();
634 switch(c) {
635 case -1: {
636 NS_HTML5_BREAK(stateloop);
637 }
638 case '>': {
639 state = NS_HTML5META_SCANNER_DATA;
640 NS_HTML5_CONTINUE(stateloop);
641 }
642 case '-': {
643 continue;
644 }
645 default: {
646 state = NS_HTML5META_SCANNER_COMMENT;
647 NS_HTML5_CONTINUE(stateloop);
648 }
649 }
650 }
651 }
652 case NS_HTML5META_SCANNER_COMMENT_START_DASH: {
653 c = read();
654 switch(c) {
655 case -1: {
656 NS_HTML5_BREAK(stateloop);
657 }
658 case '-': {
659 state = NS_HTML5META_SCANNER_COMMENT_END;
660 NS_HTML5_CONTINUE(stateloop);
661 }
662 case '>': {
663 state = NS_HTML5META_SCANNER_DATA;
664 NS_HTML5_CONTINUE(stateloop);
665 }
666 default: {
667 state = NS_HTML5META_SCANNER_COMMENT;
668 NS_HTML5_CONTINUE(stateloop);
669 }
670 }
671 }
672 case NS_HTML5META_SCANNER_ATTRIBUTE_VALUE_SINGLE_QUOTED: {
673 for (; ; ) {
674 if (reconsume) {
675 reconsume = false;
676 } else {
677 c = read();
678 }
679 switch(c) {
680 case -1: {
681 NS_HTML5_BREAK(stateloop);
682 }
683 case '\'': {
684 handleAttributeValue();
685 state = NS_HTML5META_SCANNER_AFTER_ATTRIBUTE_VALUE_QUOTED;
686 NS_HTML5_CONTINUE(stateloop);
687 }
688 default: {
689 handleCharInAttributeValue(c);
690 continue;
691 }
692 }
693 }
694 }
695 case NS_HTML5META_SCANNER_SCAN_UNTIL_GT: {
696 for (; ; ) {
697 if (reconsume) {
698 reconsume = false;
699 } else {
700 c = read();
701 }
702 switch(c) {
703 case -1: {
704 NS_HTML5_BREAK(stateloop);
705 }
706 case '>': {
707 state = NS_HTML5META_SCANNER_DATA;
708 NS_HTML5_CONTINUE(stateloop);
709 }
710 default: {
711 continue;
712 }
713 }
714 }
715 }
716 }
717 }
718 stateloop_end: ;
719 stateSave = state;
720 }
721
722 void
723 nsHtml5MetaScanner::handleCharInAttributeValue(int32_t c)
724 {
725 if (metaState == NS_HTML5META_SCANNER_A) {
726 if (contentIndex == CONTENT.length || charsetIndex == CHARSET.length) {
727 addToBuffer(c);
728 } else if (httpEquivIndex == HTTP_EQUIV.length) {
729 if (contentTypeIndex < CONTENT_TYPE.length && toAsciiLowerCase(c) == CONTENT_TYPE[contentTypeIndex]) {
730 ++contentTypeIndex;
731 } else {
732 contentTypeIndex = INT32_MAX;
733 }
734 }
735 }
736 }
737
738 void
739 nsHtml5MetaScanner::addToBuffer(int32_t c)
740 {
741 if (strBufLen == strBuf.length) {
742 jArray<char16_t,int32_t> newBuf = jArray<char16_t,int32_t>::newJArray(strBuf.length + (strBuf.length << 1));
743 nsHtml5ArrayCopy::arraycopy(strBuf, newBuf, strBuf.length);
744 strBuf = newBuf;
745 }
746 strBuf[strBufLen++] = (char16_t) c;
747 }
748
749 void
750 nsHtml5MetaScanner::handleAttributeValue()
751 {
752 if (metaState != NS_HTML5META_SCANNER_A) {
753 return;
754 }
755 if (contentIndex == CONTENT.length && !content) {
756 content = nsHtml5Portability::newStringFromBuffer(strBuf, 0, strBufLen);
757 return;
758 }
759 if (charsetIndex == CHARSET.length && !charset) {
760 charset = nsHtml5Portability::newStringFromBuffer(strBuf, 0, strBufLen);
761 return;
762 }
763 if (httpEquivIndex == HTTP_EQUIV.length && httpEquivState == NS_HTML5META_SCANNER_HTTP_EQUIV_NOT_SEEN) {
764 httpEquivState = (contentTypeIndex == CONTENT_TYPE.length) ? NS_HTML5META_SCANNER_HTTP_EQUIV_CONTENT_TYPE : NS_HTML5META_SCANNER_HTTP_EQUIV_OTHER;
765 return;
766 }
767 }
768
769 bool
770 nsHtml5MetaScanner::handleTag()
771 {
772 bool stop = handleTagInner();
773 nsHtml5Portability::releaseString(content);
774 content = nullptr;
775 nsHtml5Portability::releaseString(charset);
776 charset = nullptr;
777 httpEquivState = NS_HTML5META_SCANNER_HTTP_EQUIV_NOT_SEEN;
778 return stop;
779 }
780
781 bool
782 nsHtml5MetaScanner::handleTagInner()
783 {
784 if (!!charset && tryCharset(charset)) {
785 return true;
786 }
787 if (!!content && httpEquivState == NS_HTML5META_SCANNER_HTTP_EQUIV_CONTENT_TYPE) {
788 nsString* extract = nsHtml5TreeBuilder::extractCharsetFromContent(content);
789 if (!extract) {
790 return false;
791 }
792 bool success = tryCharset(extract);
793 nsHtml5Portability::releaseString(extract);
794 return success;
795 }
796 return false;
797 }
798
799 void
800 nsHtml5MetaScanner::initializeStatics()
801 {
802 }
803
804 void
805 nsHtml5MetaScanner::releaseStatics()
806 {
807 }
808
809
810 #include "nsHtml5MetaScannerCppSupplement.h"
811

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial