API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 19th, 2011
1,262
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 87.80 KB | None | 0 0
raw download clone embed print report
  1.  
  2. PRInt32
  3. nsHtml5Tokenizer::stateLoop(PRInt32 state, PRUnichar c, PRInt32 pos, PRUnichar* buf, PRBool reconsume, PRInt32 returnState, PRInt32 endPos)
  4. {
  5.   stateloop: for (; ; ) {
  6.     switc//h(state) {
  7.       case NS_HTML5TOKENIZER_DATA: {
  8.         for (; ; ) {
  9.           if (reconsume) {
  10.             reconsume = PR_FALSE;
  11.           } else {
  12.             if (++pos == endPos) {
  13.               NS_HTML5_BREAK(stateloop);
  14.             }
  15.             c = checkChar(buf, pos);
  16.           }
  17.           switch(c) {
  18.             case '&': {
  19.               flushChars(buf, pos);
  20.               clearStrBufAndAppend(c);
  21.               setAdditionalAndRememberAmpersandLocation('\0');
  22.               returnState = state;
  23.               state = NS_HTML5TOKENIZER_CONSUME_CHARACTER_REFERENCE;
  24.               NS_HTML5_CONTINUE(stateloop);
  25.             }
  26.             case '<': {
  27.               flushChars(buf, pos);
  28.               state = NS_HTML5TOKENIZER_TAG_OPEN;
  29.               NS_HTML5_BREAK(dataloop);
  30.             }
  31.             case '\0': {
  32.               emitReplacementCharacter(buf, pos);
  33.               continue;
  34.             }
  35.             case '\r': {
  36.               emitCarriageReturn(buf, pos);
  37.               NS_HTML5_BREAK(stateloop);
  38.             }
  39.             case '\n': {
  40.               silentLineFeed();
  41.             }
  42.             default: {
  43.               continue;
  44.             }
  45.           }
  46.         }
  47.         dataloop_end: ;
  48.       }
  49.       case NS_HTML5TOKENIZER_TAG_OPEN: {
  50.         for (; ; ) {
  51.           if (++pos == endPos) {
  52.             NS_HTML5_BREAK(stateloop);
  53.           }
  54.           c = checkChar(buf, pos);
  55.           if (c >= 'A' && c <= 'Z') {
  56.             endTag = PR_FALSE;
  57.             clearStrBufAndAppend((PRUnichar) (c + 0x20));
  58.             state = NS_HTML5TOKENIZER_TAG_NAME;
  59.             NS_HTML5_BREAK(tagopenloop);
  60.           } else if (c >= 'a' && c <= 'z') {
  61.             endTag = PR_FALSE;
  62.             clearStrBufAndAppend(c);
  63.             state = NS_HTML5TOKENIZER_TAG_NAME;
  64.             NS_HTML5_BREAK(tagopenloop);
  65.           }
  66.           switch(c) {
  67.             case '!': {
  68.               state = NS_HTML5TOKENIZER_MARKUP_DECLARATION_OPEN;
  69.               NS_HTML5_CONTINUE(stateloop);
  70.             }
  71.             case '/': {
  72.               state = NS_HTML5TOKENIZER_CLOSE_TAG_OPEN;
  73.               NS_HTML5_CONTINUE(stateloop);
  74.             }
  75.             case '\?': {
  76.  
  77.               clearLongStrBufAndAppend(c);
  78.               state = NS_HTML5TOKENIZER_BOGUS_COMMENT;
  79.               NS_HTML5_CONTINUE(stateloop);
  80.             }
  81.             case '>': {
  82.  
  83.               tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 2);
  84.               cstart = pos + 1;
  85.               state = NS_HTML5TOKENIZER_DATA;
  86.               NS_HTML5_CONTINUE(stateloop);
  87.             }
  88.             default: {
  89.  
  90.               tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
  91.               cstart = pos;
  92.               state = NS_HTML5TOKENIZER_DATA;
  93.               reconsume = PR_TRUE;
  94.               NS_HTML5_CONTINUE(stateloop);
  95.             }
  96.           }
  97.         }
  98.         tagopenloop_end: ;
  99.       }
  100.       case NS_HTML5TOKENIZER_TAG_NAME: {
  101.         for (; ; ) {
  102.           if (++pos == endPos) {
  103.             NS_HTML5_BREAK(stateloop);
  104.           }
  105.           c = checkChar(buf, pos);
  106.           switch(c) {
  107.             case '\r': {
  108.               silentCarriageReturn();
  109.               strBufToElementNameString();
  110.               state = NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_NAME;
  111.               NS_HTML5_BREAK(stateloop);
  112.             }
  113.             case '\n': {
  114.               silentLineFeed();
  115.             }
  116.             case ' ':
  117.             case '\t':
  118.             case '\f': {
  119.               strBufToElementNameString();
  120.               state = NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_NAME;
  121.               NS_HTML5_BREAK(tagnameloop);
  122.             }
  123.             case '/': {
  124.               strBufToElementNameString();
  125.               state = NS_HTML5TOKENIZER_SELF_CLOSING_START_TAG;
  126.               NS_HTML5_CONTINUE(stateloop);
  127.             }
  128.             case '>': {
  129.               strBufToElementNameString();
  130.               state = emitCurrentTagToken(PR_FALSE, pos);
  131.               if (shouldSuspend) {
  132.                 NS_HTML5_BREAK(stateloop);
  133.               }
  134.               NS_HTML5_CONTINUE(stateloop);
  135.             }
  136.             case '\0': {
  137.               c = 0xfffd;
  138.             }
  139.             default: {
  140.               if (c >= 'A' && c <= 'Z') {
  141.                 c += 0x20;
  142.               }
  143.               appendStrBuf(c);
  144.               continue;
  145.             }
  146.           }
  147.         }
  148.         tagnameloop_end: ;
  149.       }
  150.       case NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_NAME: {
  151.         for (; ; ) {
  152.           if (reconsume) {
  153.             reconsume = PR_FALSE;
  154.           } else {
  155.             if (++pos == endPos) {
  156.               NS_HTML5_BREAK(stateloop);
  157.             }
  158.             c = checkChar(buf, pos);
  159.           }
  160.           switch(c) {
  161.             case '\r': {
  162.               silentCarriageReturn();
  163.               NS_HTML5_BREAK(stateloop);
  164.             }
  165.             case '\n': {
  166.               silentLineFeed();
  167.             }
  168.             case ' ':
  169.             case '\t':
  170.             case '\f': {
  171.               continue;
  172.             }
  173.             case '/': {
  174.               state = NS_HTML5TOKENIZER_SELF_CLOSING_START_TAG;
  175.               NS_HTML5_CONTINUE(stateloop);
  176.             }
  177.             case '>': {
  178.               state = emitCurrentTagToken(PR_FALSE, pos);
  179.               if (shouldSuspend) {
  180.                 NS_HTML5_BREAK(stateloop);
  181.               }
  182.               NS_HTML5_CONTINUE(stateloop);
  183.             }
  184.             case '\0': {
  185.               c = 0xfffd;
  186.             }
  187.             case '\"':
  188.             case '\'':
  189.             case '<':
  190.             case '=':
  191.             default: {
  192.               if (c >= 'A' && c <= 'Z') {
  193.                 c += 0x20;
  194.               }
  195.               clearStrBufAndAppend(c);
  196.               state = NS_HTML5TOKENIZER_ATTRIBUTE_NAME;
  197.               NS_HTML5_BREAK(beforeattributenameloop);
  198.             }
  199.           }
  200.         }
  201.         beforeattributenameloop_end: ;
  202.       }
  203.       case NS_HTML5TOKENIZER_ATTRIBUTE_NAME: {
  204.         for (; ; ) {
  205.           if (++pos == endPos) {
  206.             NS_HTML5_BREAK(stateloop);
  207.           }
  208.           c = checkChar(buf, pos);
  209.           switch(c) {
  210.             case '\r': {
  211.               silentCarriageReturn();
  212.               attributeNameComplete();
  213.               state = NS_HTML5TOKENIZER_AFTER_ATTRIBUTE_NAME;
  214.               NS_HTML5_BREAK(stateloop);
  215.             }
  216.             case '\n': {
  217.               silentLineFeed();
  218.             }
  219.             case ' ':
  220.             case '\t':
  221.             case '\f': {
  222.               attributeNameComplete();
  223.               state = NS_HTML5TOKENIZER_AFTER_ATTRIBUTE_NAME;
  224.               NS_HTML5_CONTINUE(stateloop);
  225.             }
  226.             case '/': {
  227.               attributeNameComplete();
  228.               addAttributeWithoutValue();
  229.               state = NS_HTML5TOKENIZER_SELF_CLOSING_START_TAG;
  230.               NS_HTML5_CONTINUE(stateloop);
  231.             }
  232.             case '=': {
  233.               attributeNameComplete();
  234.               state = NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_VALUE;
  235.               NS_HTML5_BREAK(attributenameloop);
  236.             }
  237.             case '>': {
  238.               attributeNameComplete();
  239.               addAttributeWithoutValue();
  240.               state = emitCurrentTagToken(PR_FALSE, pos);
  241.               if (shouldSuspend) {
  242.                 NS_HTML5_BREAK(stateloop);
  243.               }
  244.               NS_HTML5_CONTINUE(stateloop);
  245.             }
  246.             case '\0': {
  247.               c = 0xfffd;
  248.             }
  249.             case '\"':
  250.             case '\'':
  251.             case '<':
  252.             default: {
  253.               if (c >= 'A' && c <= 'Z') {
  254.                 c += 0x20;
  255.               }
  256.               appendStrBuf(c);
  257.               continue;
  258.             }
  259.           }
  260.         }
  261.         attributenameloop_end: ;
  262.       }
  263.       case NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_VALUE: {
  264.         for (; ; ) {
  265.           if (++pos == endPos) {
  266.             NS_HTML5_BREAK(stateloop);
  267.           }
  268.           c = checkChar(buf, pos);
  269.           switch(c) {
  270.             case '\r': {
  271.               silentCarriageReturn();
  272.               NS_HTML5_BREAK(stateloop);
  273.             }
  274.             case '\n': {
  275.               silentLineFeed();
  276.             }
  277.             case ' ':
  278.             case '\t':
  279.             case '\f': {
  280.               continue;
  281.             }
  282.             case '\"': {
  283.               clearLongStrBuf();
  284.               state = NS_HTML5TOKENIZER_ATTRIBUTE_VALUE_DOUBLE_QUOTED;
  285.               NS_HTML5_BREAK(beforeattributevalueloop);
  286.             }
  287.             case '&': {
  288.               clearLongStrBuf();
  289.               state = NS_HTML5TOKENIZER_ATTRIBUTE_VALUE_UNQUOTED;
  290.  
  291.               reconsume = PR_TRUE;
  292.               NS_HTML5_CONTINUE(stateloop);
  293.             }
  294.             case '\'': {
  295.               clearLongStrBuf();
  296.               state = NS_HTML5TOKENIZER_ATTRIBUTE_VALUE_SINGLE_QUOTED;
  297.               NS_HTML5_CONTINUE(stateloop);
  298.             }
  299.             case '>': {
  300.  
  301.               addAttributeWithoutValue();
  302.               state = emitCurrentTagToken(PR_FALSE, pos);
  303.               if (shouldSuspend) {
  304.                 NS_HTML5_BREAK(stateloop);
  305.               }
  306.               NS_HTML5_CONTINUE(stateloop);
  307.             }
  308.             case '\0': {
  309.               c = 0xfffd;
  310.             }
  311.             case '<':
  312.             case '=':
  313.             case '`':
  314.             default: {
  315.               clearLongStrBufAndAppend(c);
  316.               state = NS_HTML5TOKENIZER_ATTRIBUTE_VALUE_UNQUOTED;
  317.  
  318.               NS_HTML5_CONTINUE(stateloop);
  319.             }
  320.           }
  321.         }
  322.         beforeattributevalueloop_end: ;
  323.       }
  324.       case NS_HTML5TOKENIZER_ATTRIBUTE_VALUE_DOUBLE_QUOTED: {
  325.         for (; ; ) {
  326.           if (reconsume) {
  327.             reconsume = PR_FALSE;
  328.           } else {
  329.             if (++pos == endPos) {
  330.               NS_HTML5_BREAK(stateloop);
  331.             }
  332.             c = checkChar(buf, pos);
  333.           }
  334.           switch(c) {
  335.             case '\"': {
  336.               addAttributeWithValue();
  337.               state = NS_HTML5TOKENIZER_AFTER_ATTRIBUTE_VALUE_QUOTED;
  338.               NS_HTML5_BREAK(attributevaluedoublequotedloop);
  339.             }
  340.             case '&': {
  341.               clearStrBufAndAppend(c);
  342.               setAdditionalAndRememberAmpersandLocation('\"');
  343.               returnState = state;
  344.               state = NS_HTML5TOKENIZER_CONSUME_CHARACTER_REFERENCE;
  345.               NS_HTML5_CONTINUE(stateloop);
  346.             }
  347.             case '\r': {
  348.               appendLongStrBufCarriageReturn();
  349.               NS_HTML5_BREAK(stateloop);
  350.             }
  351.             case '\n': {
  352.               appendLongStrBufLineFeed();
  353.               continue;
  354.             }
  355.             case '\0': {
  356.               c = 0xfffd;
  357.             }
  358.             default: {
  359.               appendLongStrBuf(c);
  360.               continue;
  361.             }
  362.           }
  363.         }
  364.         attributevaluedoublequotedloop_end: ;
  365.       }
  366.       case NS_HTML5TOKENIZER_AFTER_ATTRIBUTE_VALUE_QUOTED: {
  367.         for (; ; ) {
  368.           if (++pos == endPos) {
  369.             NS_HTML5_BREAK(stateloop);
  370.           }
  371.           c = checkChar(buf, pos);
  372.           switch(c) {
  373.             case '\r': {
  374.               silentCarriageReturn();
  375.               state = NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_NAME;
  376.               NS_HTML5_BREAK(stateloop);
  377.             }
  378.             case '\n': {
  379.               silentLineFeed();
  380.             }
  381.             case ' ':
  382.             case '\t':
  383.             case '\f': {
  384.               state = NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_NAME;
  385.               NS_HTML5_CONTINUE(stateloop);
  386.             }
  387.             case '/': {
  388.               state = NS_HTML5TOKENIZER_SELF_CLOSING_START_TAG;
  389.               NS_HTML5_BREAK(afterattributevaluequotedloop);
  390.             }
  391.             case '>': {
  392.               state = emitCurrentTagToken(PR_FALSE, pos);
  393.               if (shouldSuspend) {
  394.                 NS_HTML5_BREAK(stateloop);
  395.               }
  396.               NS_HTML5_CONTINUE(stateloop);
  397.             }
  398.             default: {
  399.  
  400.               state = NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_NAME;
  401.               reconsume = PR_TRUE;
  402.               NS_HTML5_CONTINUE(stateloop);
  403.             }
  404.           }
  405.         }
  406.         afterattributevaluequotedloop_end: ;
  407.       }
  408.       case NS_HTML5TOKENIZER_SELF_CLOSING_START_TAG: {
  409.         if (++pos == endPos) {
  410.           NS_HTML5_BREAK(stateloop);
  411.         }
  412.         c = checkChar(buf, pos);
  413.         switch(c) {
  414.           case '>': {
  415.             state = emitCurrentTagToken(PR_TRUE, pos);
  416.             if (shouldSuspend) {
  417.               NS_HTML5_BREAK(stateloop);
  418.             }
  419.             NS_HTML5_CONTINUE(stateloop);
  420.           }
  421.           default: {
  422.  
  423.             state = NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_NAME;
  424.             reconsume = PR_TRUE;
  425.             NS_HTML5_CONTINUE(stateloop);
  426.           }
  427.         }
  428.       }
  429.       case NS_HTML5TOKENIZER_ATTRIBUTE_VALUE_UNQUOTED: {
  430.         for (; ; ) {
  431.           if (reconsume) {
  432.             reconsume = PR_FALSE;
  433.           } else {
  434.             if (++pos == endPos) {
  435.               NS_HTML5_BREAK(stateloop);
  436.             }
  437.             c = checkChar(buf, pos);
  438.           }
  439.           switch(c) {
  440.             case '\r': {
  441.               silentCarriageReturn();
  442.               addAttributeWithValue();
  443.               state = NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_NAME;
  444.               NS_HTML5_BREAK(stateloop);
  445.             }
  446.             case '\n': {
  447.               silentLineFeed();
  448.             }
  449.             case ' ':
  450.             case '\t':
  451.             case '\f': {
  452.               addAttributeWithValue();
  453.               state = NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_NAME;
  454.               NS_HTML5_CONTINUE(stateloop);
  455.             }
  456.             case '&': {
  457.               clearStrBufAndAppend(c);
  458.               setAdditionalAndRememberAmpersandLocation('>');
  459.               returnState = state;
  460.               state = NS_HTML5TOKENIZER_CONSUME_CHARACTER_REFERENCE;
  461.               NS_HTML5_CONTINUE(stateloop);
  462.             }
  463.             case '>': {
  464.               addAttributeWithValue();
  465.               state = emitCurrentTagToken(PR_FALSE, pos);
  466.               if (shouldSuspend) {
  467.                 NS_HTML5_BREAK(stateloop);
  468.               }
  469.               NS_HTML5_CONTINUE(stateloop);
  470.             }
  471.             case '\0': {
  472.               c = 0xfffd;
  473.             }
  474.             case '<':
  475.             case '\"':
  476.             case '\'':
  477.             case '=':
  478.             case '`':
  479.             default: {
  480.  
  481.               appendLongStrBuf(c);
  482.               continue;
  483.             }
  484.           }
  485.         }
  486.       }
  487.       case NS_HTML5TOKENIZER_AFTER_ATTRIBUTE_NAME: {
  488.         for (; ; ) {
  489.           if (++pos == endPos) {
  490.             NS_HTML5_BREAK(stateloop);
  491.           }
  492.           c = checkChar(buf, pos);
  493.           switch(c) {
  494.             case '\r': {
  495.               silentCarriageReturn();
  496.               NS_HTML5_BREAK(stateloop);
  497.             }
  498.             case '\n': {
  499.               silentLineFeed();
  500.             }
  501.             case ' ':
  502.             case '\t':
  503.             case '\f': {
  504.               continue;
  505.             }
  506.             case '/': {
  507.               addAttributeWithoutValue();
  508.               state = NS_HTML5TOKENIZER_SELF_CLOSING_START_TAG;
  509.               NS_HTML5_CONTINUE(stateloop);
  510.             }
  511.             case '=': {
  512.               state = NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_VALUE;
  513.               NS_HTML5_CONTINUE(stateloop);
  514.             }
  515.             case '>': {
  516.               addAttributeWithoutValue();
  517.               state = emitCurrentTagToken(PR_FALSE, pos);
  518.               if (shouldSuspend) {
  519.                 NS_HTML5_BREAK(stateloop);
  520.               }
  521.               NS_HTML5_CONTINUE(stateloop);
  522.             }
  523.             case '\0': {
  524.               c = 0xfffd;
  525.             }
  526.             case '\"':
  527.             case '\'':
  528.             case '<':
  529.             default: {
  530.               addAttributeWithoutValue();
  531.               if (c >= 'A' && c <= 'Z') {
  532.                 c += 0x20;
  533.               }
  534.               clearStrBufAndAppend(c);
  535.               state = NS_HTML5TOKENIZER_ATTRIBUTE_NAME;
  536.               NS_HTML5_CONTINUE(stateloop);
  537.             }
  538.           }
  539.         }
  540.       }
  541.       case NS_HTML5TOKENIZER_MARKUP_DECLARATION_OPEN: {
  542.         for (; ; ) {
  543.           if (++pos == endPos) {
  544.             NS_HTML5_BREAK(stateloop);
  545.           }
  546.           c = checkChar(buf, pos);
  547.           switch(c) {
  548.             case '-': {
  549.               clearLongStrBufAndAppend(c);
  550.               state = NS_HTML5TOKENIZER_MARKUP_DECLARATION_HYPHEN;
  551.               NS_HTML5_BREAK(markupdeclarationopenloop);
  552.             }
  553.             case 'd':
  554.             case 'D': {
  555.               clearLongStrBufAndAppend(c);
  556.               index = 0;
  557.               state = NS_HTML5TOKENIZER_MARKUP_DECLARATION_OCTYPE;
  558.               NS_HTML5_CONTINUE(stateloop);
  559.             }
  560.             case '[': {
  561.               if (tokenHandler->cdataSectionAllowed()) {
  562.                 clearLongStrBufAndAppend(c);
  563.                 index = 0;
  564.                 state = NS_HTML5TOKENIZER_CDATA_START;
  565.                 NS_HTML5_CONTINUE(stateloop);
  566.               }
  567.             }
  568.             default: {
  569.  
  570.               clearLongStrBuf();
  571.               state = NS_HTML5TOKENIZER_BOGUS_COMMENT;
  572.               reconsume = PR_TRUE;
  573.               NS_HTML5_CONTINUE(stateloop);
  574.             }
  575.           }
  576.         }
  577.         markupdeclarationopenloop_end: ;
  578.       }
  579.       case NS_HTML5TOKENIZER_MARKUP_DECLARATION_HYPHEN: {
  580.         for (; ; ) {
  581.           if (++pos == endPos) {
  582.             NS_HTML5_BREAK(stateloop);
  583.           }
  584.           c = checkChar(buf, pos);
  585.           switch(c) {
  586.             case '\0': {
  587.               NS_HTML5_BREAK(stateloop);
  588.             }
  589.             case '-': {
  590.               clearLongStrBuf();
  591.               state = NS_HTML5TOKENIZER_COMMENT_START;
  592.               NS_HTML5_BREAK(markupdeclarationhyphenloop);
  593.             }
  594.             default: {
  595.  
  596.               state = NS_HTML5TOKENIZER_BOGUS_COMMENT;
  597.               reconsume = PR_TRUE;
  598.               NS_HTML5_CONTINUE(stateloop);
  599.             }
  600.           }
  601.         }
  602.         markupdeclarationhyphenloop_end: ;
  603.       }
  604.       case NS_HTML5TOKENIZER_COMMENT_START: {
  605.         for (; ; ) {
  606.           if (++pos == endPos) {
  607.             NS_HTML5_BREAK(stateloop);
  608.           }
  609.           c = checkChar(buf, pos);
  610.           switch(c) {
  611.             case '-': {
  612.               appendLongStrBuf(c);
  613.               state = NS_HTML5TOKENIZER_COMMENT_START_DASH;
  614.               NS_HTML5_CONTINUE(stateloop);
  615.             }
  616.             case '>': {
  617.  
  618.               emitComment(0, pos);
  619.               state = NS_HTML5TOKENIZER_DATA;
  620.               NS_HTML5_CONTINUE(stateloop);
  621.             }
  622.             case '\r': {
  623.               appendLongStrBufCarriageReturn();
  624.               state = NS_HTML5TOKENIZER_COMMENT;
  625.               NS_HTML5_BREAK(stateloop);
  626.             }
  627.             case '\n': {
  628.               appendLongStrBufLineFeed();
  629.               state = NS_HTML5TOKENIZER_COMMENT;
  630.               NS_HTML5_BREAK(commentstartloop);
  631.             }
  632.             case '\0': {
  633.               c = 0xfffd;
  634.             }
  635.             default: {
  636.               appendLongStrBuf(c);
  637.               state = NS_HTML5TOKENIZER_COMMENT;
  638.               NS_HTML5_BREAK(commentstartloop);
  639.             }
  640.           }
  641.         }
  642.         commentstartloop_end: ;
  643.       }
  644.       case NS_HTML5TOKENIZER_COMMENT: {
  645.         for (; ; ) {
  646.           if (++pos == endPos) {
  647.             NS_HTML5_BREAK(stateloop);
  648.           }
  649.           c = checkChar(buf, pos);
  650.           switch(c) {
  651.             case '-': {
  652.               appendLongStrBuf(c);
  653.               state = NS_HTML5TOKENIZER_COMMENT_END_DASH;
  654.               NS_HTML5_BREAK(commentloop);
  655.             }
  656.             case '\r': {
  657.               appendLongStrBufCarriageReturn();
  658.               NS_HTML5_BREAK(stateloop);
  659.             }
  660.             case '\n': {
  661.               appendLongStrBufLineFeed();
  662.               continue;
  663.             }
  664.             case '\0': {
  665.               c = 0xfffd;
  666.             }
  667.             default: {
  668.               appendLongStrBuf(c);
  669.               continue;
  670.             }
  671.           }
  672.         }
  673.         commentloop_end: ;
  674.       }
  675.       case NS_HTML5TOKENIZER_COMMENT_END_DASH: {
  676.         for (; ; ) {
  677.           if (++pos == endPos) {
  678.             NS_HTML5_BREAK(stateloop);
  679.           }
  680.           c = checkChar(buf, pos);
  681.           switch(c) {
  682.             case '-': {
  683.               appendLongStrBuf(c);
  684.               state = NS_HTML5TOKENIZER_COMMENT_END;
  685.               NS_HTML5_BREAK(commentenddashloop);
  686.             }
  687.             case '\r': {
  688.               appendLongStrBufCarriageReturn();
  689.               state = NS_HTML5TOKENIZER_COMMENT;
  690.               NS_HTML5_BREAK(stateloop);
  691.             }
  692.             case '\n': {
  693.               appendLongStrBufLineFeed();
  694.               state = NS_HTML5TOKENIZER_COMMENT;
  695.               NS_HTML5_CONTINUE(stateloop);
  696.             }
  697.             case '\0': {
  698.               c = 0xfffd;
  699.             }
  700.             default: {
  701.               appendLongStrBuf(c);
  702.               state = NS_HTML5TOKENIZER_COMMENT;
  703.               NS_HTML5_CONTINUE(stateloop);
  704.             }
  705.           }
  706.         }
  707.         commentenddashloop_end: ;
  708.       }
  709.       case NS_HTML5TOKENIZER_COMMENT_END: {
  710.         for (; ; ) {
  711.           if (++pos == endPos) {
  712.             NS_HTML5_BREAK(stateloop);
  713.           }
  714.           c = checkChar(buf, pos);
  715.           switch(c) {
  716.             case '>': {
  717.               emitComment(2, pos);
  718.               state = NS_HTML5TOKENIZER_DATA;
  719.               NS_HTML5_CONTINUE(stateloop);
  720.             }
  721.             case '-': {
  722.               adjustDoubleHyphenAndAppendToLongStrBufAndErr(c);
  723.               continue;
  724.             }
  725.             case '\r': {
  726.               adjustDoubleHyphenAndAppendToLongStrBufCarriageReturn();
  727.               state = NS_HTML5TOKENIZER_COMMENT;
  728.               NS_HTML5_BREAK(stateloop);
  729.             }
  730.             case '\n': {
  731.               adjustDoubleHyphenAndAppendToLongStrBufLineFeed();
  732.               state = NS_HTML5TOKENIZER_COMMENT;
  733.               NS_HTML5_CONTINUE(stateloop);
  734.             }
  735.             case '!': {
  736.  
  737.               appendLongStrBuf(c);
  738.               state = NS_HTML5TOKENIZER_COMMENT_END_BANG;
  739.               NS_HTML5_CONTINUE(stateloop);
  740.             }
  741.             case '\0': {
  742.               c = 0xfffd;
  743.             }
  744.             default: {
  745.               adjustDoubleHyphenAndAppendToLongStrBufAndErr(c);
  746.               state = NS_HTML5TOKENIZER_COMMENT;
  747.               NS_HTML5_CONTINUE(stateloop);
  748.             }
  749.           }
  750.         }
  751.  
  752.       }
  753.       case NS_HTML5TOKENIZER_COMMENT_END_BANG: {
  754.         for (; ; ) {
  755.           if (++pos == endPos) {
  756.             NS_HTML5_BREAK(stateloop);
  757.           }
  758.           c = checkChar(buf, pos);
  759.           switch(c) {
  760.             case '>': {
  761.               emitComment(3, pos);
  762.               state = NS_HTML5TOKENIZER_DATA;
  763.               NS_HTML5_CONTINUE(stateloop);
  764.             }
  765.             case '-': {
  766.               appendLongStrBuf(c);
  767.               state = NS_HTML5TOKENIZER_COMMENT_END_DASH;
  768.               NS_HTML5_CONTINUE(stateloop);
  769.             }
  770.             case '\r': {
  771.               appendLongStrBufCarriageReturn();
  772.               NS_HTML5_BREAK(stateloop);
  773.             }
  774.             case '\n': {
  775.               appendLongStrBufLineFeed();
  776.               continue;
  777.             }
  778.             case '\0': {
  779.               c = 0xfffd;
  780.             }
  781.             default: {
  782.               appendLongStrBuf(c);
  783.               state = NS_HTML5TOKENIZER_COMMENT;
  784.               NS_HTML5_CONTINUE(stateloop);
  785.             }
  786.           }
  787.         }
  788.       }
  789.       case NS_HTML5TOKENIZER_COMMENT_START_DASH: {
  790.         if (++pos == endPos) {
  791.           NS_HTML5_BREAK(stateloop);
  792.         }
  793.         c = checkChar(buf, pos);
  794.         switch(c) {
  795.           case '-': {
  796.             appendLongStrBuf(c);
  797.             state = NS_HTML5TOKENIZER_COMMENT_END;
  798.             NS_HTML5_CONTINUE(stateloop);
  799.           }
  800.           case '>': {
  801.  
  802.             emitComment(1, pos);
  803.             state = NS_HTML5TOKENIZER_DATA;
  804.             NS_HTML5_CONTINUE(stateloop);
  805.           }
  806.           case '\r': {
  807.             appendLongStrBufCarriageReturn();
  808.             state = NS_HTML5TOKENIZER_COMMENT;
  809.             NS_HTML5_BREAK(stateloop);
  810.           }
  811.           case '\n': {
  812.             appendLongStrBufLineFeed();
  813.             state = NS_HTML5TOKENIZER_COMMENT;
  814.             NS_HTML5_CONTINUE(stateloop);
  815.           }
  816.           case '\0': {
  817.             c = 0xfffd;
  818.           }
  819.           default: {
  820.             appendLongStrBuf(c);
  821.             state = NS_HTML5TOKENIZER_COMMENT;
  822.             NS_HTML5_CONTINUE(stateloop);
  823.           }
  824.         }
  825.       }
  826.       case NS_HTML5TOKENIZER_CDATA_START: {
  827.         for (; ; ) {
  828.           if (++pos == endPos) {
  829.             NS_HTML5_BREAK(stateloop);
  830.           }
  831.           c = checkChar(buf, pos);
  832.           if (index < 6) {
  833.             if (c == nsHtml5Tokenizer::CDATA_LSQB[index]) {
  834.               appendLongStrBuf(c);
  835.             } else {
  836.  
  837.               state = NS_HTML5TOKENIZER_BOGUS_COMMENT;
  838.               reconsume = PR_TRUE;
  839.               NS_HTML5_CONTINUE(stateloop);
  840.             }
  841.             index++;
  842.             continue;
  843.           } else {
  844.             cstart = pos;
  845.             state = NS_HTML5TOKENIZER_CDATA_SECTION;
  846.             reconsume = PR_TRUE;
  847.             break;
  848.           }
  849.         }
  850.       }
  851.       case NS_HTML5TOKENIZER_CDATA_SECTION: {
  852.         for (; ; ) {
  853.           if (reconsume) {
  854.             reconsume = PR_FALSE;
  855.           } else {
  856.             if (++pos == endPos) {
  857.               NS_HTML5_BREAK(stateloop);
  858.             }
  859.             c = checkChar(buf, pos);
  860.           }
  861.           switch(c) {
  862.             case ']': {
  863.               flushChars(buf, pos);
  864.               state = NS_HTML5TOKENIZER_CDATA_RSQB;
  865.               NS_HTML5_BREAK(cdatasectionloop);
  866.             }
  867.             case '\0': {
  868.               emitReplacementCharacter(buf, pos);
  869.               continue;
  870.             }
  871.             case '\r': {
  872.               emitCarriageReturn(buf, pos);
  873.               NS_HTML5_BREAK(stateloop);
  874.             }
  875.             case '\n': {
  876.               silentLineFeed();
  877.             }
  878.             default: {
  879.               continue;
  880.             }
  881.           }
  882.         }
  883.         cdatasectionloop_end: ;
  884.       }
  885.       case NS_HTML5TOKENIZER_CDATA_RSQB: {
  886.         for (; ; ) {
  887.           if (++pos == endPos) {
  888.             NS_HTML5_BREAK(stateloop);
  889.           }
  890.           c = checkChar(buf, pos);
  891.           switch(c) {
  892.             case ']': {
  893.               state = NS_HTML5TOKENIZER_CDATA_RSQB_RSQB;
  894.               NS_HTML5_BREAK(cdatarsqb);
  895.             }
  896.             default: {
  897.               tokenHandler->characters(nsHtml5Tokenizer::RSQB_RSQB, 0, 1);
  898.               cstart = pos;
  899.               state = NS_HTML5TOKENIZER_CDATA_SECTION;
  900.               reconsume = PR_TRUE;
  901.               NS_HTML5_CONTINUE(stateloop);
  902.             }
  903.           }
  904.         }
  905.         cdatarsqb_end: ;
  906.       }
  907.       case NS_HTML5TOKENIZER_CDATA_RSQB_RSQB: {
  908.         if (++pos == endPos) {
  909.           NS_HTML5_BREAK(stateloop);
  910.         }
  911.         c = checkChar(buf, pos);
  912.         switch(c) {
  913.           case '>': {
  914.             cstart = pos + 1;
  915.             state = NS_HTML5TOKENIZER_DATA;
  916.             NS_HTML5_CONTINUE(stateloop);
  917.           }
  918.           default: {
  919.             tokenHandler->characters(nsHtml5Tokenizer::RSQB_RSQB, 0, 2);
  920.             cstart = pos;
  921.             state = NS_HTML5TOKENIZER_CDATA_SECTION;
  922.             reconsume = PR_TRUE;
  923.             NS_HTML5_CONTINUE(stateloop);
  924.           }
  925.         }
  926.       }
  927.       case NS_HTML5TOKENIZER_ATTRIBUTE_VALUE_SINGLE_QUOTED: {
  928.         for (; ; ) {
  929.           if (reconsume) {
  930.             reconsume = PR_FALSE;
  931.           } else {
  932.             if (++pos == endPos) {
  933.               NS_HTML5_BREAK(stateloop);
  934.             }
  935.             c = checkChar(buf, pos);
  936.           }
  937.           switch(c) {
  938.             case '\'': {
  939.               addAttributeWithValue();
  940.               state = NS_HTML5TOKENIZER_AFTER_ATTRIBUTE_VALUE_QUOTED;
  941.               NS_HTML5_CONTINUE(stateloop);
  942.             }
  943.             case '&': {
  944.               clearStrBufAndAppend(c);
  945.               setAdditionalAndRememberAmpersandLocation('\'');
  946.               returnState = state;
  947.               state = NS_HTML5TOKENIZER_CONSUME_CHARACTER_REFERENCE;
  948.               NS_HTML5_BREAK(attributevaluesinglequotedloop);
  949.             }
  950.             case '\r': {
  951.               appendLongStrBufCarriageReturn();
  952.               NS_HTML5_BREAK(stateloop);
  953.             }
  954.             case '\n': {
  955.               appendLongStrBufLineFeed();
  956.               continue;
  957.             }
  958.             case '\0': {
  959.               c = 0xfffd;
  960.             }
  961.             default: {
  962.               appendLongStrBuf(c);
  963.               continue;
  964.             }
  965.           }
  966.         }
  967.         attributevaluesinglequotedloop_end: ;
  968.       }
  969.       case NS_HTML5TOKENIZER_CONSUME_CHARACTER_REFERENCE: {
  970.         if (++pos == endPos) {
  971.           NS_HTML5_BREAK(stateloop);
  972.         }
  973.         c = checkChar(buf, pos);
  974.         if (c == '\0') {
  975.           NS_HTML5_BREAK(stateloop);
  976.         }
  977.         switch(c) {
  978.           case ' ':
  979.           case '\t':
  980.           case '\n':
  981.           case '\r':
  982.           case '\f':
  983.           case '<':
  984.           case '&': {
  985.             emitOrAppendStrBuf(returnState);
  986.             if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  987.               cstart = pos;
  988.             }
  989.             state = returnState;
  990.             reconsume = PR_TRUE;
  991.             NS_HTML5_CONTINUE(stateloop);
  992.           }
  993.           case '#': {
  994.             appendStrBuf('#');
  995.             state = NS_HTML5TOKENIZER_CONSUME_NCR;
  996.             NS_HTML5_CONTINUE(stateloop);
  997.           }
  998.           default: {
  999.             if (c == additional) {
  1000.               emitOrAppendStrBuf(returnState);
  1001.               state = returnState;
  1002.               reconsume = PR_TRUE;
  1003.               NS_HTML5_CONTINUE(stateloop);
  1004.             }
  1005.             if (c >= 'a' && c <= 'z') {
  1006.               firstCharKey = c - 'a' + 26;
  1007.             } else if (c >= 'A' && c <= 'Z') {
  1008.               firstCharKey = c - 'A';
  1009.             } else {
  1010.  
  1011.               emitOrAppendStrBuf(returnState);
  1012.               if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1013.                 cstart = pos;
  1014.               }
  1015.               state = returnState;
  1016.               reconsume = PR_TRUE;
  1017.               NS_HTML5_CONTINUE(stateloop);
  1018.             }
  1019.             appendStrBuf(c);
  1020.             state = NS_HTML5TOKENIZER_CHARACTER_REFERENCE_HILO_LOOKUP;
  1021.           }
  1022.         }
  1023.       }
  1024.       case NS_HTML5TOKENIZER_CHARACTER_REFERENCE_HILO_LOOKUP: {
  1025.         {
  1026.           if (++pos == endPos) {
  1027.             NS_HTML5_BREAK(stateloop);
  1028.           }
  1029.           c = checkChar(buf, pos);
  1030.           if (c == '\0') {
  1031.             NS_HTML5_BREAK(stateloop);
  1032.           }
  1033.           PRInt32 hilo = 0;
  1034.           if (c <= 'z') {
  1035.             const PRInt32* row = nsHtml5NamedCharactersAccel::HILO_ACCEL[c];
  1036.             if (row) {
  1037.               hilo = row[firstCharKey];
  1038.             }
  1039.           }
  1040.           if (!hilo) {
  1041.  
  1042.             emitOrAppendStrBuf(returnState);
  1043.             if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1044.               cstart = pos;
  1045.             }
  1046.             state = returnState;
  1047.             reconsume = PR_TRUE;
  1048.             NS_HTML5_CONTINUE(stateloop);
  1049.           }
  1050.           appendStrBuf(c);
  1051.           lo = hilo & 0xFFFF;
  1052.           hi = hilo >> 16;
  1053.           entCol = -1;
  1054.           candidate = -1;
  1055.           strBufMark = 0;
  1056.           state = NS_HTML5TOKENIZER_CHARACTER_REFERENCE_TAIL;
  1057.         }
  1058.       }
  1059.       case NS_HTML5TOKENIZER_CHARACTER_REFERENCE_TAIL: {
  1060.         for (; ; ) {
  1061.           if (++pos == endPos) {
  1062.             NS_HTML5_BREAK(stateloop);
  1063.           }
  1064.           c = checkChar(buf, pos);
  1065.           if (c == '\0') {
  1066.             NS_HTML5_BREAK(stateloop);
  1067.           }
  1068.           entCol++;
  1069.           for (; ; ) {
  1070.             if (hi < lo) {
  1071.               NS_HTML5_BREAK(outer);
  1072.             }
  1073.             if (entCol == nsHtml5NamedCharacters::NAMES[lo].length()) {
  1074.               candidate = lo;
  1075.               strBufMark = strBufLen;
  1076.               lo++;
  1077.             } else if (entCol > nsHtml5NamedCharacters::NAMES[lo].length()) {
  1078.               NS_HTML5_BREAK(outer);
  1079.             } else if (c > nsHtml5NamedCharacters::NAMES[lo].charAt(entCol)) {
  1080.               lo++;
  1081.             } else {
  1082.               NS_HTML5_BREAK(loloop);
  1083.             }
  1084.           }
  1085.           loloop_end: ;
  1086.           for (; ; ) {
  1087.             if (hi < lo) {
  1088.               NS_HTML5_BREAK(outer);
  1089.             }
  1090.             if (entCol == nsHtml5NamedCharacters::NAMES[hi].length()) {
  1091.               NS_HTML5_BREAK(hiloop);
  1092.             }
  1093.             if (entCol > nsHtml5NamedCharacters::NAMES[hi].length()) {
  1094.               NS_HTML5_BREAK(outer);
  1095.             } else if (c < nsHtml5NamedCharacters::NAMES[hi].charAt(entCol)) {
  1096.               hi--;
  1097.             } else {
  1098.               NS_HTML5_BREAK(hiloop);
  1099.             }
  1100.           }
  1101.           hiloop_end: ;
  1102.           if (hi < lo) {
  1103.             NS_HTML5_BREAK(outer);
  1104.           }
  1105.           appendStrBuf(c);
  1106.           continue;
  1107.         }
  1108.         outer_end: ;
  1109.         if (candidate == -1) {
  1110.  
  1111.           emitOrAppendStrBuf(returnState);
  1112.           if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1113.             cstart = pos;
  1114.           }
  1115.           state = returnState;
  1116.           reconsume = PR_TRUE;
  1117.           NS_HTML5_CONTINUE(stateloop);
  1118.         } else {
  1119.           const nsHtml5CharacterName& candidateName = nsHtml5NamedCharacters::NAMES[candidate];
  1120.           if (!candidateName.length() || candidateName.charAt(candidateName.length() - 1) != ';') {
  1121.             if ((returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1122.               PRUnichar ch;
  1123.               if (strBufMark == strBufLen) {
  1124.                 ch = c;
  1125.               } else {
  1126.                 ch = strBuf[strBufMark];
  1127.               }
  1128.               if (ch == '=' || (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
  1129.  
  1130.                 appendStrBufToLongStrBuf();
  1131.                 state = returnState;
  1132.                 reconsume = PR_TRUE;
  1133.                 NS_HTML5_CONTINUE(stateloop);
  1134.               }
  1135.             }
  1136.  
  1137.           }
  1138.           const PRUnichar* val = nsHtml5NamedCharacters::VALUES[candidate];
  1139.           if (!val[1]) {
  1140.             emitOrAppendOne(val, returnState);
  1141.           } else {
  1142.             emitOrAppendTwo(val, returnState);
  1143.           }
  1144.           if (strBufMark < strBufLen) {
  1145.             if ((returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1146.               for (PRInt32 i = strBufMark; i < strBufLen; i++) {
  1147.                 appendLongStrBuf(strBuf[i]);
  1148.               }
  1149.             } else {
  1150.               tokenHandler->characters(strBuf, strBufMark, strBufLen - strBufMark);
  1151.             }
  1152.           }
  1153.           if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1154.             cstart = pos;
  1155.           }
  1156.           state = returnState;
  1157.           reconsume = PR_TRUE;
  1158.           NS_HTML5_CONTINUE(stateloop);
  1159.         }
  1160.       }
  1161.       case NS_HTML5TOKENIZER_CONSUME_NCR: {
  1162.         if (++pos == endPos) {
  1163.           NS_HTML5_BREAK(stateloop);
  1164.         }
  1165.         c = checkChar(buf, pos);
  1166.         prevValue = -1;
  1167.         value = 0;
  1168.         seenDigits = PR_FALSE;
  1169.         switch(c) {
  1170.           case 'x':
  1171.           case 'X': {
  1172.             appendStrBuf(c);
  1173.             state = NS_HTML5TOKENIZER_HEX_NCR_LOOP;
  1174.             NS_HTML5_CONTINUE(stateloop);
  1175.           }
  1176.           default: {
  1177.             state = NS_HTML5TOKENIZER_DECIMAL_NRC_LOOP;
  1178.             reconsume = PR_TRUE;
  1179.           }
  1180.         }
  1181.       }
  1182.       case NS_HTML5TOKENIZER_DECIMAL_NRC_LOOP: {
  1183.         for (; ; ) {
  1184.           if (reconsume) {
  1185.             reconsume = PR_FALSE;
  1186.           } else {
  1187.             if (++pos == endPos) {
  1188.               NS_HTML5_BREAK(stateloop);
  1189.             }
  1190.             c = checkChar(buf, pos);
  1191.           }
  1192.           if (value < prevValue) {
  1193.             value = 0x110000;
  1194.           }
  1195.           prevValue = value;
  1196.           if (c >= '0' && c <= '9') {
  1197.             seenDigits = PR_TRUE;
  1198.             value *= 10;
  1199.             value += c - '0';
  1200.             continue;
  1201.           } else if (c == ';') {
  1202.             if (seenDigits) {
  1203.               if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1204.                 cstart = pos + 1;
  1205.               }
  1206.               state = NS_HTML5TOKENIZER_HANDLE_NCR_VALUE;
  1207.               NS_HTML5_BREAK(decimalloop);
  1208.             } else {
  1209.  
  1210.               appendStrBuf(';');
  1211.               emitOrAppendStrBuf(returnState);
  1212.               if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1213.                 cstart = pos + 1;
  1214.               }
  1215.               state = returnState;
  1216.               NS_HTML5_CONTINUE(stateloop);
  1217.             }
  1218.           } else {
  1219.             if (!seenDigits) {
  1220.  
  1221.               emitOrAppendStrBuf(returnState);
  1222.               if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1223.                 cstart = pos;
  1224.               }
  1225.               state = returnState;
  1226.               reconsume = PR_TRUE;
  1227.               NS_HTML5_CONTINUE(stateloop);
  1228.             } else {
  1229.  
  1230.               if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1231.                 cstart = pos;
  1232.               }
  1233.               state = NS_HTML5TOKENIZER_HANDLE_NCR_VALUE;
  1234.               reconsume = PR_TRUE;
  1235.               NS_HTML5_BREAK(decimalloop);
  1236.             }
  1237.           }
  1238.         }
  1239.         decimalloop_end: ;
  1240.       }
  1241.       case NS_HTML5TOKENIZER_HANDLE_NCR_VALUE: {
  1242.         handleNcrValue(returnState);
  1243.         state = returnState;
  1244.         NS_HTML5_CONTINUE(stateloop);
  1245.       }
  1246.       case NS_HTML5TOKENIZER_HEX_NCR_LOOP: {
  1247.         for (; ; ) {
  1248.           if (++pos == endPos) {
  1249.             NS_HTML5_BREAK(stateloop);
  1250.           }
  1251.           c = checkChar(buf, pos);
  1252.           if (value < prevValue) {
  1253.             value = 0x110000;
  1254.           }
  1255.           prevValue = value;
  1256.           if (c >= '0' && c <= '9') {
  1257.             seenDigits = PR_TRUE;
  1258.             value *= 16;
  1259.             value += c - '0';
  1260.             continue;
  1261.           } else if (c >= 'A' && c <= 'F') {
  1262.             seenDigits = PR_TRUE;
  1263.             value *= 16;
  1264.             value += c - 'A' + 10;
  1265.             continue;
  1266.           } else if (c >= 'a' && c <= 'f') {
  1267.             seenDigits = PR_TRUE;
  1268.             value *= 16;
  1269.             value += c - 'a' + 10;
  1270.             continue;
  1271.           } else if (c == ';') {
  1272.             if (seenDigits) {
  1273.               if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1274.                 cstart = pos + 1;
  1275.               }
  1276.               state = NS_HTML5TOKENIZER_HANDLE_NCR_VALUE;
  1277.               NS_HTML5_CONTINUE(stateloop);
  1278.             } else {
  1279.  
  1280.               appendStrBuf(';');
  1281.               emitOrAppendStrBuf(returnState);
  1282.               if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1283.                 cstart = pos + 1;
  1284.               }
  1285.               state = returnState;
  1286.               NS_HTML5_CONTINUE(stateloop);
  1287.             }
  1288.           } else {
  1289.             if (!seenDigits) {
  1290.  
  1291.               emitOrAppendStrBuf(returnState);
  1292.               if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1293.                 cstart = pos;
  1294.               }
  1295.               state = returnState;
  1296.               reconsume = PR_TRUE;
  1297.               NS_HTML5_CONTINUE(stateloop);
  1298.             } else {
  1299.  
  1300.               if (!(returnState & NS_HTML5TOKENIZER_DATA_AND_RCDATA_MASK)) {
  1301.                 cstart = pos;
  1302.               }
  1303.               state = NS_HTML5TOKENIZER_HANDLE_NCR_VALUE;
  1304.               reconsume = PR_TRUE;
  1305.               NS_HTML5_CONTINUE(stateloop);
  1306.             }
  1307.           }
  1308.         }
  1309.       }
  1310.       case NS_HTML5TOKENIZER_PLAINTEXT: {
  1311.         for (; ; ) {
  1312.           if (reconsume) {
  1313.             reconsume = PR_FALSE;
  1314.           } else {
  1315.             if (++pos == endPos) {
  1316.               NS_HTML5_BREAK(stateloop);
  1317.             }
  1318.             c = checkChar(buf, pos);
  1319.           }
  1320.           switch(c) {
  1321.             case '\0': {
  1322.               emitPlaintextReplacementCharacter(buf, pos);
  1323.               continue;
  1324.             }
  1325.             case '\r': {
  1326.               emitCarriageReturn(buf, pos);
  1327.               NS_HTML5_BREAK(stateloop);
  1328.             }
  1329.             case '\n': {
  1330.               silentLineFeed();
  1331.             }
  1332.             default: {
  1333.               continue;
  1334.             }
  1335.           }
  1336.         }
  1337.  
  1338.       }
  1339.       case NS_HTML5TOKENIZER_CLOSE_TAG_OPEN: {
  1340.         if (++pos == endPos) {
  1341.           NS_HTML5_BREAK(stateloop);
  1342.         }
  1343.         c = checkChar(buf, pos);
  1344.         switch(c) {
  1345.           case '>': {
  1346.  
  1347.             cstart = pos + 1;
  1348.             state = NS_HTML5TOKENIZER_DATA;
  1349.             NS_HTML5_CONTINUE(stateloop);
  1350.           }
  1351.           case '\r': {
  1352.             silentCarriageReturn();
  1353.  
  1354.             clearLongStrBufAndAppend('\n');
  1355.             state = NS_HTML5TOKENIZER_BOGUS_COMMENT;
  1356.             NS_HTML5_BREAK(stateloop);
  1357.           }
  1358.           case '\n': {
  1359.             silentLineFeed();
  1360.  
  1361.             clearLongStrBufAndAppend('\n');
  1362.             state = NS_HTML5TOKENIZER_BOGUS_COMMENT;
  1363.             NS_HTML5_CONTINUE(stateloop);
  1364.           }
  1365.           case '\0': {
  1366.             c = 0xfffd;
  1367.           }
  1368.           default: {
  1369.             if (c >= 'A' && c <= 'Z') {
  1370.               c += 0x20;
  1371.             }
  1372.             if (c >= 'a' && c <= 'z') {
  1373.               endTag = PR_TRUE;
  1374.               clearStrBufAndAppend(c);
  1375.               state = NS_HTML5TOKENIZER_TAG_NAME;
  1376.               NS_HTML5_CONTINUE(stateloop);
  1377.             } else {
  1378.  
  1379.               clearLongStrBufAndAppend(c);
  1380.               state = NS_HTML5TOKENIZER_BOGUS_COMMENT;
  1381.               NS_HTML5_CONTINUE(stateloop);
  1382.             }
  1383.           }
  1384.         }
  1385.       }
  1386.       case NS_HTML5TOKENIZER_RCDATA: {
  1387.         for (; ; ) {
  1388.           if (reconsume) {
  1389.             reconsume = PR_FALSE;
  1390.           } else {
  1391.             if (++pos == endPos) {
  1392.               NS_HTML5_BREAK(stateloop);
  1393.             }
  1394.             c = checkChar(buf, pos);
  1395.           }
  1396.           switch(c) {
  1397.             case '&': {
  1398.               flushChars(buf, pos);
  1399.               clearStrBufAndAppend(c);
  1400.               additional = '\0';
  1401.               returnState = state;
  1402.               state = NS_HTML5TOKENIZER_CONSUME_CHARACTER_REFERENCE;
  1403.               NS_HTML5_CONTINUE(stateloop);
  1404.             }
  1405.             case '<': {
  1406.               flushChars(buf, pos);
  1407.               returnState = state;
  1408.               state = NS_HTML5TOKENIZER_RAWTEXT_RCDATA_LESS_THAN_SIGN;
  1409.               NS_HTML5_CONTINUE(stateloop);
  1410.             }
  1411.             case '\0': {
  1412.               emitReplacementCharacter(buf, pos);
  1413.               continue;
  1414.             }
  1415.             case '\r': {
  1416.               emitCarriageReturn(buf, pos);
  1417.               NS_HTML5_BREAK(stateloop);
  1418.             }
  1419.             case '\n': {
  1420.               silentLineFeed();
  1421.             }
  1422.             default: {
  1423.               continue;
  1424.             }
  1425.           }
  1426.         }
  1427.  
  1428.       }
  1429.       case NS_HTML5TOKENIZER_RAWTEXT: {
  1430.         for (; ; ) {
  1431.           if (reconsume) {
  1432.             reconsume = PR_FALSE;
  1433.           } else {
  1434.             if (++pos == endPos) {
  1435.               NS_HTML5_BREAK(stateloop);
  1436.             }
  1437.             c = checkChar(buf, pos);
  1438.           }
  1439.           switch(c) {
  1440.             case '<': {
  1441.               flushChars(buf, pos);
  1442.               returnState = state;
  1443.               state = NS_HTML5TOKENIZER_RAWTEXT_RCDATA_LESS_THAN_SIGN;
  1444.               NS_HTML5_BREAK(rawtextloop);
  1445.             }
  1446.             case '\0': {
  1447.               emitReplacementCharacter(buf, pos);
  1448.               continue;
  1449.             }
  1450.             case '\r': {
  1451.               emitCarriageReturn(buf, pos);
  1452.               NS_HTML5_BREAK(stateloop);
  1453.             }
  1454.             case '\n': {
  1455.               silentLineFeed();
  1456.             }
  1457.             default: {
  1458.               continue;
  1459.             }
  1460.           }
  1461.         }
  1462.         rawtextloop_end: ;
  1463.       }
  1464.       case NS_HTML5TOKENIZER_RAWTEXT_RCDATA_LESS_THAN_SIGN: {
  1465.         for (; ; ) {
  1466.           if (++pos == endPos) {
  1467.             NS_HTML5_BREAK(stateloop);
  1468.           }
  1469.           c = checkChar(buf, pos);
  1470.           switch(c) {
  1471.             case '/': {
  1472.               index = 0;
  1473.               clearStrBuf();
  1474.               state = NS_HTML5TOKENIZER_NON_DATA_END_TAG_NAME;
  1475.               NS_HTML5_BREAK(rawtextrcdatalessthansignloop);
  1476.             }
  1477.             default: {
  1478.               tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
  1479.               cstart = pos;
  1480.               state = returnState;
  1481.               reconsume = PR_TRUE;
  1482.               NS_HTML5_CONTINUE(stateloop);
  1483.             }
  1484.           }
  1485.         }
  1486.         rawtextrcdatalessthansignloop_end: ;
  1487.       }
  1488.       case NS_HTML5TOKENIZER_NON_DATA_END_TAG_NAME: {
  1489.         for (; ; ) {
  1490.           if (++pos == endPos) {
  1491.             NS_HTML5_BREAK(stateloop);
  1492.           }
  1493.           c = checkChar(buf, pos);
  1494.           if (index < endTagExpectationAsArray.length) {
  1495.             PRUnichar e = endTagExpectationAsArray[index];
  1496.             PRUnichar folded = c;
  1497.             if (c >= 'A' && c <= 'Z') {
  1498.               folded += 0x20;
  1499.             }
  1500.             if (folded != e) {
  1501.               tokenHandler->characters(nsHtml5Tokenizer::LT_SOLIDUS, 0, 2);
  1502.               emitStrBuf();
  1503.               cstart = pos;
  1504.               state = returnState;
  1505.               reconsume = PR_TRUE;
  1506.               NS_HTML5_CONTINUE(stateloop);
  1507.             }
  1508.             appendStrBuf(c);
  1509.             index++;
  1510.             continue;
  1511.           } else {
  1512.             endTag = PR_TRUE;
  1513.             tagName = endTagExpectation;
  1514.             switch(c) {
  1515.               case '\r': {
  1516.                 silentCarriageReturn();
  1517.                 state = NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_NAME;
  1518.                 NS_HTML5_BREAK(stateloop);
  1519.               }
  1520.               case '\n': {
  1521.                 silentLineFeed();
  1522.               }
  1523.               case ' ':
  1524.               case '\t':
  1525.               case '\f': {
  1526.                 state = NS_HTML5TOKENIZER_BEFORE_ATTRIBUTE_NAME;
  1527.                 NS_HTML5_CONTINUE(stateloop);
  1528.               }
  1529.               case '/': {
  1530.                 state = NS_HTML5TOKENIZER_SELF_CLOSING_START_TAG;
  1531.                 NS_HTML5_CONTINUE(stateloop);
  1532.               }
  1533.               case '>': {
  1534.                 state = emitCurrentTagToken(PR_FALSE, pos);
  1535.                 if (shouldSuspend) {
  1536.                   NS_HTML5_BREAK(stateloop);
  1537.                 }
  1538.                 NS_HTML5_CONTINUE(stateloop);
  1539.               }
  1540.               default: {
  1541.                 tokenHandler->characters(nsHtml5Tokenizer::LT_SOLIDUS, 0, 2);
  1542.                 emitStrBuf();
  1543.                 if (c == '\0') {
  1544.                   emitReplacementCharacter(buf, pos);
  1545.                 } else {
  1546.                   cstart = pos;
  1547.                 }
  1548.                 state = returnState;
  1549.                 NS_HTML5_CONTINUE(stateloop);
  1550.               }
  1551.             }
  1552.           }
  1553.         }
  1554.       }
  1555.       case NS_HTML5TOKENIZER_BOGUS_COMMENT: {
  1556.         for (; ; ) {
  1557.           if (reconsume) {
  1558.             reconsume = PR_FALSE;
  1559.           } else {
  1560.             if (++pos == endPos) {
  1561.               NS_HTML5_BREAK(stateloop);
  1562.             }
  1563.             c = checkChar(buf, pos);
  1564.           }
  1565.           switch(c) {
  1566.             case '>': {
  1567.               emitComment(0, pos);
  1568.               state = NS_HTML5TOKENIZER_DATA;
  1569.               NS_HTML5_CONTINUE(stateloop);
  1570.             }
  1571.             case '-': {
  1572.               appendLongStrBuf(c);
  1573.               state = NS_HTML5TOKENIZER_BOGUS_COMMENT_HYPHEN;
  1574.               NS_HTML5_BREAK(boguscommentloop);
  1575.             }
  1576.             case '\r': {
  1577.               appendLongStrBufCarriageReturn();
  1578.               NS_HTML5_BREAK(stateloop);
  1579.             }
  1580.             case '\n': {
  1581.               appendLongStrBufLineFeed();
  1582.               continue;
  1583.             }
  1584.             case '\0': {
  1585.               c = 0xfffd;
  1586.             }
  1587.             default: {
  1588.               appendLongStrBuf(c);
  1589.               continue;
  1590.             }
  1591.           }
  1592.         }
  1593.         boguscommentloop_end: ;
  1594.       }
  1595.       case NS_HTML5TOKENIZER_BOGUS_COMMENT_HYPHEN: {
  1596.         boguscommenthyphenloop: for (; ; ) {
  1597.           if (++pos == endPos) {
  1598.             NS_HTML5_BREAK(stateloop);
  1599.           }
  1600.           c = checkChar(buf, pos);
  1601.           switch(c) {
  1602.             case '>': {
  1603.               emitComment(0, pos);
  1604.               state = NS_HTML5TOKENIZER_DATA;
  1605.               NS_HTML5_CONTINUE(stateloop);
  1606.             }
  1607.             case '-': {
  1608.               appendSecondHyphenToBogusComment();
  1609.               NS_HTML5_CONTINUE(boguscommenthyphenloop);
  1610.             }
  1611.             case '\r': {
  1612.               appendLongStrBufCarriageReturn();
  1613.               state = NS_HTML5TOKENIZER_BOGUS_COMMENT;
  1614.               NS_HTML5_BREAK(stateloop);
  1615.             }
  1616.             case '\n': {
  1617.               appendLongStrBufLineFeed();
  1618.               state = NS_HTML5TOKENIZER_BOGUS_COMMENT;
  1619.               NS_HTML5_CONTINUE(stateloop);
  1620.             }
  1621.             case '\0': {
  1622.               c = 0xfffd;
  1623.             }
  1624.             default: {
  1625.               appendLongStrBuf(c);
  1626.               state = NS_HTML5TOKENIZER_BOGUS_COMMENT;
  1627.               NS_HTML5_CONTINUE(stateloop);
  1628.             }
  1629.           }
  1630.         }
  1631.  
  1632.       }
  1633.       case NS_HTML5TOKENIZER_SCRIPT_DATA: {
  1634.         for (; ; ) {
  1635.           if (reconsume) {
  1636.             reconsume = PR_FALSE;
  1637.           } else {
  1638.             if (++pos == endPos) {
  1639.               NS_HTML5_BREAK(stateloop);
  1640.             }
  1641.             c = checkChar(buf, pos);
  1642.           }
  1643.           switch(c) {
  1644.             case '<': {
  1645.               flushChars(buf, pos);
  1646.               returnState = state;
  1647.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_LESS_THAN_SIGN;
  1648.               NS_HTML5_BREAK(scriptdataloop);
  1649.             }
  1650.             case '\0': {
  1651.               emitReplacementCharacter(buf, pos);
  1652.               continue;
  1653.             }
  1654.             case '\r': {
  1655.               emitCarriageReturn(buf, pos);
  1656.               NS_HTML5_BREAK(stateloop);
  1657.             }
  1658.             case '\n': {
  1659.               silentLineFeed();
  1660.             }
  1661.             default: {
  1662.               continue;
  1663.             }
  1664.           }
  1665.         }
  1666.         scriptdataloop_end: ;
  1667.       }
  1668.       case NS_HTML5TOKENIZER_SCRIPT_DATA_LESS_THAN_SIGN: {
  1669.         for (; ; ) {
  1670.           if (++pos == endPos) {
  1671.             NS_HTML5_BREAK(stateloop);
  1672.           }
  1673.           c = checkChar(buf, pos);
  1674.           switch(c) {
  1675.             case '/': {
  1676.               index = 0;
  1677.               clearStrBuf();
  1678.               state = NS_HTML5TOKENIZER_NON_DATA_END_TAG_NAME;
  1679.               NS_HTML5_CONTINUE(stateloop);
  1680.             }
  1681.             case '!': {
  1682.               tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
  1683.               cstart = pos;
  1684.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPE_START;
  1685.               NS_HTML5_BREAK(scriptdatalessthansignloop);
  1686.             }
  1687.             default: {
  1688.               tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
  1689.               cstart = pos;
  1690.               state = NS_HTML5TOKENIZER_SCRIPT_DATA;
  1691.               reconsume = PR_TRUE;
  1692.               NS_HTML5_CONTINUE(stateloop);
  1693.             }
  1694.           }
  1695.         }
  1696.         scriptdatalessthansignloop_end: ;
  1697.       }
  1698.       case NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPE_START: {
  1699.         for (; ; ) {
  1700.           if (++pos == endPos) {
  1701.             NS_HTML5_BREAK(stateloop);
  1702.           }
  1703.           c = checkChar(buf, pos);
  1704.           switch(c) {
  1705.             case '-': {
  1706.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPE_START_DASH;
  1707.               NS_HTML5_BREAK(scriptdataescapestartloop);
  1708.             }
  1709.             default: {
  1710.               state = NS_HTML5TOKENIZER_SCRIPT_DATA;
  1711.               reconsume = PR_TRUE;
  1712.               NS_HTML5_CONTINUE(stateloop);
  1713.             }
  1714.           }
  1715.         }
  1716.         scriptdataescapestartloop_end: ;
  1717.       }
  1718.       case NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPE_START_DASH: {
  1719.         for (; ; ) {
  1720.           if (++pos == endPos) {
  1721.             NS_HTML5_BREAK(stateloop);
  1722.           }
  1723.           c = checkChar(buf, pos);
  1724.           switch(c) {
  1725.             case '-': {
  1726.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED_DASH_DASH;
  1727.               NS_HTML5_BREAK(scriptdataescapestartdashloop);
  1728.             }
  1729.             default: {
  1730.               state = NS_HTML5TOKENIZER_SCRIPT_DATA;
  1731.               reconsume = PR_TRUE;
  1732.               NS_HTML5_CONTINUE(stateloop);
  1733.             }
  1734.           }
  1735.         }
  1736.         scriptdataescapestartdashloop_end: ;
  1737.       }
  1738.       case NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED_DASH_DASH: {
  1739.         for (; ; ) {
  1740.           if (++pos == endPos) {
  1741.             NS_HTML5_BREAK(stateloop);
  1742.           }
  1743.           c = checkChar(buf, pos);
  1744.           switch(c) {
  1745.             case '-': {
  1746.               continue;
  1747.             }
  1748.             case '<': {
  1749.               flushChars(buf, pos);
  1750.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
  1751.               NS_HTML5_CONTINUE(stateloop);
  1752.             }
  1753.             case '>': {
  1754.               state = NS_HTML5TOKENIZER_SCRIPT_DATA;
  1755.               NS_HTML5_CONTINUE(stateloop);
  1756.             }
  1757.             case '\0': {
  1758.               emitReplacementCharacter(buf, pos);
  1759.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED;
  1760.               NS_HTML5_BREAK(scriptdataescapeddashdashloop);
  1761.             }
  1762.             case '\r': {
  1763.               emitCarriageReturn(buf, pos);
  1764.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED;
  1765.               NS_HTML5_BREAK(stateloop);
  1766.             }
  1767.             case '\n': {
  1768.               silentLineFeed();
  1769.             }
  1770.             default: {
  1771.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED;
  1772.               NS_HTML5_BREAK(scriptdataescapeddashdashloop);
  1773.             }
  1774.           }
  1775.         }
  1776.         scriptdataescapeddashdashloop_end: ;
  1777.       }
  1778.       case NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED: {
  1779.         for (; ; ) {
  1780.           if (reconsume) {
  1781.             reconsume = PR_FALSE;
  1782.           } else {
  1783.             if (++pos == endPos) {
  1784.               NS_HTML5_BREAK(stateloop);
  1785.             }
  1786.             c = checkChar(buf, pos);
  1787.           }
  1788.           switch(c) {
  1789.             case '-': {
  1790.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED_DASH;
  1791.               NS_HTML5_BREAK(scriptdataescapedloop);
  1792.             }
  1793.             case '<': {
  1794.               flushChars(buf, pos);
  1795.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
  1796.               NS_HTML5_CONTINUE(stateloop);
  1797.             }
  1798.             case '\0': {
  1799.               emitReplacementCharacter(buf, pos);
  1800.               continue;
  1801.             }
  1802.             case '\r': {
  1803.               emitCarriageReturn(buf, pos);
  1804.               NS_HTML5_BREAK(stateloop);
  1805.             }
  1806.             case '\n': {
  1807.               silentLineFeed();
  1808.             }
  1809.             default: {
  1810.               continue;
  1811.             }
  1812.           }
  1813.         }
  1814.         scriptdataescapedloop_end: ;
  1815.       }
  1816.       case NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED_DASH: {
  1817.         for (; ; ) {
  1818.           if (++pos == endPos) {
  1819.             NS_HTML5_BREAK(stateloop);
  1820.           }
  1821.           c = checkChar(buf, pos);
  1822.           switch(c) {
  1823.             case '-': {
  1824.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED_DASH_DASH;
  1825.               NS_HTML5_CONTINUE(stateloop);
  1826.             }
  1827.             case '<': {
  1828.               flushChars(buf, pos);
  1829.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
  1830.               NS_HTML5_BREAK(scriptdataescapeddashloop);
  1831.             }
  1832.             case '\0': {
  1833.               emitReplacementCharacter(buf, pos);
  1834.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED;
  1835.               NS_HTML5_CONTINUE(stateloop);
  1836.             }
  1837.             case '\r': {
  1838.               emitCarriageReturn(buf, pos);
  1839.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED;
  1840.               NS_HTML5_BREAK(stateloop);
  1841.             }
  1842.             case '\n': {
  1843.               silentLineFeed();
  1844.             }
  1845.             default: {
  1846.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED;
  1847.               NS_HTML5_CONTINUE(stateloop);
  1848.             }
  1849.           }
  1850.         }
  1851.         scriptdataescapeddashloop_end: ;
  1852.       }
  1853.       case NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN: {
  1854.         for (; ; ) {
  1855.           if (++pos == endPos) {
  1856.             NS_HTML5_BREAK(stateloop);
  1857.           }
  1858.           c = checkChar(buf, pos);
  1859.           switch(c) {
  1860.             case '/': {
  1861.               index = 0;
  1862.               clearStrBuf();
  1863.               returnState = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED;
  1864.               state = NS_HTML5TOKENIZER_NON_DATA_END_TAG_NAME;
  1865.               NS_HTML5_CONTINUE(stateloop);
  1866.             }
  1867.             case 'S':
  1868.             case 's': {
  1869.               tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
  1870.               cstart = pos;
  1871.               index = 1;
  1872.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPE_START;
  1873.               NS_HTML5_BREAK(scriptdataescapedlessthanloop);
  1874.             }
  1875.             default: {
  1876.               tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
  1877.               cstart = pos;
  1878.               reconsume = PR_TRUE;
  1879.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED;
  1880.               NS_HTML5_CONTINUE(stateloop);
  1881.             }
  1882.           }
  1883.         }
  1884.         scriptdataescapedlessthanloop_end: ;
  1885.       }
  1886.       case NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPE_START: {
  1887.         for (; ; ) {
  1888.           if (++pos == endPos) {
  1889.             NS_HTML5_BREAK(stateloop);
  1890.           }
  1891.           c = checkChar(buf, pos);
  1892.  
  1893.           if (index < 6) {
  1894.             PRUnichar folded = c;
  1895.             if (c >= 'A' && c <= 'Z') {
  1896.               folded += 0x20;
  1897.             }
  1898.             if (folded != nsHtml5Tokenizer::SCRIPT_ARR[index]) {
  1899.               reconsume = PR_TRUE;
  1900.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED;
  1901.               NS_HTML5_CONTINUE(stateloop);
  1902.             }
  1903.             index++;
  1904.             continue;
  1905.           }
  1906.           switch(c) {
  1907.             case '\r': {
  1908.               emitCarriageReturn(buf, pos);
  1909.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED;
  1910.               NS_HTML5_BREAK(stateloop);
  1911.             }
  1912.             case '\n': {
  1913.               silentLineFeed();
  1914.             }
  1915.             case ' ':
  1916.             case '\t':
  1917.             case '\f':
  1918.             case '/':
  1919.             case '>': {
  1920.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED;
  1921.               NS_HTML5_BREAK(scriptdatadoubleescapestartloop);
  1922.             }
  1923.             default: {
  1924.               reconsume = PR_TRUE;
  1925.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED;
  1926.               NS_HTML5_CONTINUE(stateloop);
  1927.             }
  1928.           }
  1929.         }
  1930.         scriptdatadoubleescapestartloop_end: ;
  1931.       }
  1932.       case NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED: {
  1933.         for (; ; ) {
  1934.           if (reconsume) {
  1935.             reconsume = PR_FALSE;
  1936.           } else {
  1937.             if (++pos == endPos) {
  1938.               NS_HTML5_BREAK(stateloop);
  1939.             }
  1940.             c = checkChar(buf, pos);
  1941.           }
  1942.           switch(c) {
  1943.             case '-': {
  1944.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED_DASH;
  1945.               NS_HTML5_BREAK(scriptdatadoubleescapedloop);
  1946.             }
  1947.             case '<': {
  1948.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
  1949.               NS_HTML5_CONTINUE(stateloop);
  1950.             }
  1951.             case '\0': {
  1952.               emitReplacementCharacter(buf, pos);
  1953.               continue;
  1954.             }
  1955.             case '\r': {
  1956.               emitCarriageReturn(buf, pos);
  1957.               NS_HTML5_BREAK(stateloop);
  1958.             }
  1959.             case '\n': {
  1960.               silentLineFeed();
  1961.             }
  1962.             default: {
  1963.               continue;
  1964.             }
  1965.           }
  1966.         }
  1967.         scriptdatadoubleescapedloop_end: ;
  1968.       }
  1969.       case NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED_DASH: {
  1970.         for (; ; ) {
  1971.           if (++pos == endPos) {
  1972.             NS_HTML5_BREAK(stateloop);
  1973.           }
  1974.           c = checkChar(buf, pos);
  1975.           switch(c) {
  1976.             case '-': {
  1977.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH;
  1978.               NS_HTML5_BREAK(scriptdatadoubleescapeddashloop);
  1979.             }
  1980.             case '<': {
  1981.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
  1982.               NS_HTML5_CONTINUE(stateloop);
  1983.             }
  1984.             case '\0': {
  1985.               emitReplacementCharacter(buf, pos);
  1986.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED;
  1987.               NS_HTML5_CONTINUE(stateloop);
  1988.             }
  1989.             case '\r': {
  1990.               emitCarriageReturn(buf, pos);
  1991.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED;
  1992.               NS_HTML5_BREAK(stateloop);
  1993.             }
  1994.             case '\n': {
  1995.               silentLineFeed();
  1996.             }
  1997.             default: {
  1998.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED;
  1999.               NS_HTML5_CONTINUE(stateloop);
  2000.             }
  2001.           }
  2002.         }
  2003.         scriptdatadoubleescapeddashloop_end: ;
  2004.       }
  2005.       case NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH: {
  2006.         for (; ; ) {
  2007.           if (++pos == endPos) {
  2008.             NS_HTML5_BREAK(stateloop);
  2009.           }
  2010.           c = checkChar(buf, pos);
  2011.           switch(c) {
  2012.             case '-': {
  2013.               continue;
  2014.             }
  2015.             case '<': {
  2016.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
  2017.               NS_HTML5_BREAK(scriptdatadoubleescapeddashdashloop);
  2018.             }
  2019.             case '>': {
  2020.               state = NS_HTML5TOKENIZER_SCRIPT_DATA;
  2021.               NS_HTML5_CONTINUE(stateloop);
  2022.             }
  2023.             case '\0': {
  2024.               emitReplacementCharacter(buf, pos);
  2025.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED;
  2026.               NS_HTML5_CONTINUE(stateloop);
  2027.             }
  2028.             case '\r': {
  2029.               emitCarriageReturn(buf, pos);
  2030.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED;
  2031.               NS_HTML5_BREAK(stateloop);
  2032.             }
  2033.             case '\n': {
  2034.               silentLineFeed();
  2035.             }
  2036.             default: {
  2037.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED;
  2038.               NS_HTML5_CONTINUE(stateloop);
  2039.             }
  2040.           }
  2041.         }
  2042.         scriptdatadoubleescapeddashdashloop_end: ;
  2043.       }
  2044.       case NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN: {
  2045.         for (; ; ) {
  2046.           if (++pos == endPos) {
  2047.             NS_HTML5_BREAK(stateloop);
  2048.           }
  2049.           c = checkChar(buf, pos);
  2050.           switch(c) {
  2051.             case '/': {
  2052.               index = 0;
  2053.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPE_END;
  2054.               NS_HTML5_BREAK(scriptdatadoubleescapedlessthanloop);
  2055.             }
  2056.             default: {
  2057.               reconsume = PR_TRUE;
  2058.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED;
  2059.               NS_HTML5_CONTINUE(stateloop);
  2060.             }
  2061.           }
  2062.         }
  2063.         scriptdatadoubleescapedlessthanloop_end: ;
  2064.       }
  2065.       case NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPE_END: {
  2066.         for (; ; ) {
  2067.           if (++pos == endPos) {
  2068.             NS_HTML5_BREAK(stateloop);
  2069.           }
  2070.           c = checkChar(buf, pos);
  2071.           if (index < 6) {
  2072.             PRUnichar folded = c;
  2073.             if (c >= 'A' && c <= 'Z') {
  2074.               folded += 0x20;
  2075.             }
  2076.             if (folded != nsHtml5Tokenizer::SCRIPT_ARR[index]) {
  2077.               reconsume = PR_TRUE;
  2078.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED;
  2079.               NS_HTML5_CONTINUE(stateloop);
  2080.             }
  2081.             index++;
  2082.             continue;
  2083.           }
  2084.           switch(c) {
  2085.             case '\r': {
  2086.               emitCarriageReturn(buf, pos);
  2087.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED;
  2088.               NS_HTML5_BREAK(stateloop);
  2089.             }
  2090.             case '\n': {
  2091.               silentLineFeed();
  2092.             }
  2093.             case ' ':
  2094.             case '\t':
  2095.             case '\f':
  2096.             case '/':
  2097.             case '>': {
  2098.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_ESCAPED;
  2099.               NS_HTML5_CONTINUE(stateloop);
  2100.             }
  2101.             default: {
  2102.               reconsume = PR_TRUE;
  2103.               state = NS_HTML5TOKENIZER_SCRIPT_DATA_DOUBLE_ESCAPED;
  2104.               NS_HTML5_CONTINUE(stateloop);
  2105.             }
  2106.           }
  2107.         }
  2108.  
  2109.       }
  2110.       case NS_HTML5TOKENIZER_MARKUP_DECLARATION_OCTYPE: {
  2111.         for (; ; ) {
  2112.           if (++pos == endPos) {
  2113.             NS_HTML5_BREAK(stateloop);
  2114.           }
  2115.           c = checkChar(buf, pos);
  2116.           if (index < 6) {
  2117.             PRUnichar folded = c;
  2118.             if (c >= 'A' && c <= 'Z') {
  2119.               folded += 0x20;
  2120.             }
  2121.             if (folded == nsHtml5Tokenizer::OCTYPE[index]) {
  2122.               appendLongStrBuf(c);
  2123.             } else {
  2124.  
  2125.               state = NS_HTML5TOKENIZER_BOGUS_COMMENT;
  2126.               reconsume = PR_TRUE;
  2127.               NS_HTML5_CONTINUE(stateloop);
  2128.             }
  2129.             index++;
  2130.             continue;
  2131.           } else {
  2132.             state = NS_HTML5TOKENIZER_DOCTYPE;
  2133.             reconsume = PR_TRUE;
  2134.             NS_HTML5_BREAK(markupdeclarationdoctypeloop);
  2135.           }
  2136.         }
  2137.         markupdeclarationdoctypeloop_end: ;
  2138.       }
  2139.       case NS_HTML5TOKENIZER_DOCTYPE: {
  2140.         for (; ; ) {
  2141.           if (reconsume) {
  2142.             reconsume = PR_FALSE;
  2143.           } else {
  2144.             if (++pos == endPos) {
  2145.               NS_HTML5_BREAK(stateloop);
  2146.             }
  2147.             c = checkChar(buf, pos);
  2148.           }
  2149.           initDoctypeFields();
  2150.           switch(c) {
  2151.             case '\r': {
  2152.               silentCarriageReturn();
  2153.               state = NS_HTML5TOKENIZER_BEFORE_DOCTYPE_NAME;
  2154.               NS_HTML5_BREAK(stateloop);
  2155.             }
  2156.             case '\n': {
  2157.               silentLineFeed();
  2158.             }
  2159.             case ' ':
  2160.             case '\t':
  2161.             case '\f': {
  2162.               state = NS_HTML5TOKENIZER_BEFORE_DOCTYPE_NAME;
  2163.               NS_HTML5_BREAK(doctypeloop);
  2164.             }
  2165.             default: {
  2166.  
  2167.               state = NS_HTML5TOKENIZER_BEFORE_DOCTYPE_NAME;
  2168.               reconsume = PR_TRUE;
  2169.               NS_HTML5_BREAK(doctypeloop);
  2170.             }
  2171.           }
  2172.         }
  2173.         doctypeloop_end: ;
  2174.       }
  2175.       case NS_HTML5TOKENIZER_BEFORE_DOCTYPE_NAME: {
  2176.         for (; ; ) {
  2177.           if (reconsume) {
  2178.             reconsume = PR_FALSE;
  2179.           } else {
  2180.             if (++pos == endPos) {
  2181.               NS_HTML5_BREAK(stateloop);
  2182.             }
  2183.             c = checkChar(buf, pos);
  2184.           }
  2185.           switch(c) {
  2186.             case '\r': {
  2187.               silentCarriageReturn();
  2188.               NS_HTML5_BREAK(stateloop);
  2189.             }
  2190.             case '\n': {
  2191.               silentLineFeed();
  2192.             }
  2193.             case ' ':
  2194.             case '\t':
  2195.             case '\f': {
  2196.               continue;
  2197.             }
  2198.             case '>': {
  2199.  
  2200.               forceQuirks = PR_TRUE;
  2201.               emitDoctypeToken(pos);
  2202.               state = NS_HTML5TOKENIZER_DATA;
  2203.               NS_HTML5_CONTINUE(stateloop);
  2204.             }
  2205.             case '\0': {
  2206.               c = 0xfffd;
  2207.             }
  2208.             default: {
  2209.               if (c >= 'A' && c <= 'Z') {
  2210.                 c += 0x20;
  2211.               }
  2212.               clearStrBufAndAppend(c);
  2213.               state = NS_HTML5TOKENIZER_DOCTYPE_NAME;
  2214.               NS_HTML5_BREAK(beforedoctypenameloop);
  2215.             }
  2216.           }
  2217.         }
  2218.         beforedoctypenameloop_end: ;
  2219.       }
  2220.       case NS_HTML5TOKENIZER_DOCTYPE_NAME: {
  2221.         for (; ; ) {
  2222.           if (++pos == endPos) {
  2223.             NS_HTML5_BREAK(stateloop);
  2224.           }
  2225.           c = checkChar(buf, pos);
  2226.           switch(c) {
  2227.             case '\r': {
  2228.               silentCarriageReturn();
  2229.               strBufToDoctypeName();
  2230.               state = NS_HTML5TOKENIZER_AFTER_DOCTYPE_NAME;
  2231.               NS_HTML5_BREAK(stateloop);
  2232.             }
  2233.             case '\n': {
  2234.               silentLineFeed();
  2235.             }
  2236.             case ' ':
  2237.             case '\t':
  2238.             case '\f': {
  2239.               strBufToDoctypeName();
  2240.               state = NS_HTML5TOKENIZER_AFTER_DOCTYPE_NAME;
  2241.               NS_HTML5_BREAK(doctypenameloop);
  2242.             }
  2243.             case '>': {
  2244.               strBufToDoctypeName();
  2245.               emitDoctypeToken(pos);
  2246.               state = NS_HTML5TOKENIZER_DATA;
  2247.               NS_HTML5_CONTINUE(stateloop);
  2248.             }
  2249.             case '\0': {
  2250.               c = 0xfffd;
  2251.             }
  2252.             default: {
  2253.               if (c >= 'A' && c <= 'Z') {
  2254.                 c += 0x0020;
  2255.               }
  2256.               appendStrBuf(c);
  2257.               continue;
  2258.             }
  2259.           }
  2260.         }
  2261.         doctypenameloop_end: ;
  2262.       }
  2263.       case NS_HTML5TOKENIZER_AFTER_DOCTYPE_NAME: {
  2264.         for (; ; ) {
  2265.           if (++pos == endPos) {
  2266.             NS_HTML5_BREAK(stateloop);
  2267.           }
  2268.           c = checkChar(buf, pos);
  2269.           switch(c) {
  2270.             case '\r': {
  2271.               silentCarriageReturn();
  2272.               NS_HTML5_BREAK(stateloop);
  2273.             }
  2274.             case '\n': {
  2275.               silentLineFeed();
  2276.             }
  2277.             case ' ':
  2278.             case '\t':
  2279.             case '\f': {
  2280.               continue;
  2281.             }
  2282.             case '>': {
  2283.               emitDoctypeToken(pos);
  2284.               state = NS_HTML5TOKENIZER_DATA;
  2285.               NS_HTML5_CONTINUE(stateloop);
  2286.             }
  2287.             case 'p':
  2288.             case 'P': {
  2289.               index = 0;
  2290.               state = NS_HTML5TOKENIZER_DOCTYPE_UBLIC;
  2291.               NS_HTML5_BREAK(afterdoctypenameloop);
  2292.             }
  2293.             case 's':
  2294.             case 'S': {
  2295.               index = 0;
  2296.               state = NS_HTML5TOKENIZER_DOCTYPE_YSTEM;
  2297.               NS_HTML5_CONTINUE(stateloop);
  2298.             }
  2299.             default: {
  2300.               bogusDoctype();
  2301.               state = NS_HTML5TOKENIZER_BOGUS_DOCTYPE;
  2302.               NS_HTML5_CONTINUE(stateloop);
  2303.             }
  2304.           }
  2305.         }
  2306.         afterdoctypenameloop_end: ;
  2307.       }
  2308.       case NS_HTML5TOKENIZER_DOCTYPE_UBLIC: {
  2309.         for (; ; ) {
  2310.           if (++pos == endPos) {
  2311.             NS_HTML5_BREAK(stateloop);
  2312.           }
  2313.           c = checkChar(buf, pos);
  2314.           if (index < 5) {
  2315.             PRUnichar folded = c;
  2316.             if (c >= 'A' && c <= 'Z') {
  2317.               folded += 0x20;
  2318.             }
  2319.             if (folded != nsHtml5Tokenizer::UBLIC[index]) {
  2320.               bogusDoctype();
  2321.               state = NS_HTML5TOKENIZER_BOGUS_DOCTYPE;
  2322.               reconsume = PR_TRUE;
  2323.               NS_HTML5_CONTINUE(stateloop);
  2324.             }
  2325.             index++;
  2326.             continue;
  2327.           } else {
  2328.             state = NS_HTML5TOKENIZER_AFTER_DOCTYPE_PUBLIC_KEYWORD;
  2329.             reconsume = PR_TRUE;
  2330.             NS_HTML5_BREAK(doctypeublicloop);
  2331.           }
  2332.         }
  2333.         doctypeublicloop_end: ;
  2334.       }
  2335.       case NS_HTML5TOKENIZER_AFTER_DOCTYPE_PUBLIC_KEYWORD: {
  2336.         for (; ; ) {
  2337.           if (reconsume) {
  2338.             reconsume = PR_FALSE;
  2339.           } else {
  2340.             if (++pos == endPos) {
  2341.               NS_HTML5_BREAK(stateloop);
  2342.             }
  2343.             c = checkChar(buf, pos);
  2344.           }
  2345.           switch(c) {
  2346.             case '\r': {
  2347.               silentCarriageReturn();
  2348.               state = NS_HTML5TOKENIZER_BEFORE_DOCTYPE_PUBLIC_IDENTIFIER;
  2349.               NS_HTML5_BREAK(stateloop);
  2350.             }
  2351.             case '\n': {
  2352.               silentLineFeed();
  2353.             }
  2354.             case ' ':
  2355.             case '\t':
  2356.             case '\f': {
  2357.               state = NS_HTML5TOKENIZER_BEFORE_DOCTYPE_PUBLIC_IDENTIFIER;
  2358.               NS_HTML5_BREAK(afterdoctypepublickeywordloop);
  2359.             }
  2360.             case '\"': {
  2361.  
  2362.               clearLongStrBuf();
  2363.               state = NS_HTML5TOKENIZER_DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;
  2364.               NS_HTML5_CONTINUE(stateloop);
  2365.             }
  2366.             case '\'': {
  2367.  
  2368.               clearLongStrBuf();
  2369.               state = NS_HTML5TOKENIZER_DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;
  2370.               NS_HTML5_CONTINUE(stateloop);
  2371.             }
  2372.             case '>': {
  2373.  
  2374.               forceQuirks = PR_TRUE;
  2375.               emitDoctypeToken(pos);
  2376.               state = NS_HTML5TOKENIZER_DATA;
  2377.               NS_HTML5_CONTINUE(stateloop);
  2378.             }
  2379.             default: {
  2380.               bogusDoctype();
  2381.               state = NS_HTML5TOKENIZER_BOGUS_DOCTYPE;
  2382.               NS_HTML5_CONTINUE(stateloop);
  2383.             }
  2384.           }
  2385.         }
  2386.         afterdoctypepublickeywordloop_end: ;
  2387.       }
  2388.       case NS_HTML5TOKENIZER_BEFORE_DOCTYPE_PUBLIC_IDENTIFIER: {
  2389.         for (; ; ) {
  2390.           if (++pos == endPos) {
  2391.             NS_HTML5_BREAK(stateloop);
  2392.           }
  2393.           c = checkChar(buf, pos);
  2394.           switch(c) {
  2395.             case '\r': {
  2396.               silentCarriageReturn();
  2397.               NS_HTML5_BREAK(stateloop);
  2398.             }
  2399.             case '\n': {
  2400.               silentLineFeed();
  2401.             }
  2402.             case ' ':
  2403.             case '\t':
  2404.             case '\f': {
  2405.               continue;
  2406.             }
  2407.             case '\"': {
  2408.               clearLongStrBuf();
  2409.               state = NS_HTML5TOKENIZER_DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;
  2410.               NS_HTML5_BREAK(beforedoctypepublicidentifierloop);
  2411.             }
  2412.             case '\'': {
  2413.               clearLongStrBuf();
  2414.               state = NS_HTML5TOKENIZER_DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;
  2415.               NS_HTML5_CONTINUE(stateloop);
  2416.             }
  2417.             case '>': {
  2418.  
  2419.               forceQuirks = PR_TRUE;
  2420.               emitDoctypeToken(pos);
  2421.               state = NS_HTML5TOKENIZER_DATA;
  2422.               NS_HTML5_CONTINUE(stateloop);
  2423.             }
  2424.             default: {
  2425.               bogusDoctype();
  2426.               state = NS_HTML5TOKENIZER_BOGUS_DOCTYPE;
  2427.               NS_HTML5_CONTINUE(stateloop);
  2428.             }
  2429.           }
  2430.         }
  2431.         beforedoctypepublicidentifierloop_end: ;
  2432.       }
  2433.       case NS_HTML5TOKENIZER_DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED: {
  2434.         for (; ; ) {
  2435.           if (++pos == endPos) {
  2436.             NS_HTML5_BREAK(stateloop);
  2437.           }
  2438.           c = checkChar(buf, pos);
  2439.           switch(c) {
  2440.             case '\"': {
  2441.               publicIdentifier = longStrBufToString();
  2442.               state = NS_HTML5TOKENIZER_AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
  2443.               NS_HTML5_BREAK(doctypepublicidentifierdoublequotedloop);
  2444.             }
  2445.             case '>': {
  2446.  
  2447.               forceQuirks = PR_TRUE;
  2448.               publicIdentifier = longStrBufToString();
  2449.               emitDoctypeToken(pos);
  2450.               state = NS_HTML5TOKENIZER_DATA;
  2451.               NS_HTML5_CONTINUE(stateloop);
  2452.             }
  2453.             case '\r': {
  2454.               appendLongStrBufCarriageReturn();
  2455.               NS_HTML5_BREAK(stateloop);
  2456.             }
  2457.             case '\n': {
  2458.               appendLongStrBufLineFeed();
  2459.               continue;
  2460.             }
  2461.             case '\0': {
  2462.               c = 0xfffd;
  2463.             }
  2464.             default: {
  2465.               appendLongStrBuf(c);
  2466.               continue;
  2467.             }
  2468.           }
  2469.         }
  2470.         doctypepublicidentifierdoublequotedloop_end: ;
  2471.       }
  2472.       case NS_HTML5TOKENIZER_AFTER_DOCTYPE_PUBLIC_IDENTIFIER: {
  2473.         for (; ; ) {
  2474.           if (++pos == endPos) {
  2475.             NS_HTML5_BREAK(stateloop);
  2476.           }
  2477.           c = checkChar(buf, pos);
  2478.           switch(c) {
  2479.             case '\r': {
  2480.               silentCarriageReturn();
  2481.               state = NS_HTML5TOKENIZER_BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS;
  2482.               NS_HTML5_BREAK(stateloop);
  2483.             }
  2484.             case '\n': {
  2485.               silentLineFeed();
  2486.             }
  2487.             case ' ':
  2488.             case '\t':
  2489.             case '\f': {
  2490.               state = NS_HTML5TOKENIZER_BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS;
  2491.               NS_HTML5_BREAK(afterdoctypepublicidentifierloop);
  2492.             }
  2493.             case '>': {
  2494.               emitDoctypeToken(pos);
  2495.               state = NS_HTML5TOKENIZER_DATA;
  2496.               NS_HTML5_CONTINUE(stateloop);
  2497.             }
  2498.             case '\"': {
  2499.  
  2500.               clearLongStrBuf();
  2501.               state = NS_HTML5TOKENIZER_DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
  2502.               NS_HTML5_CONTINUE(stateloop);
  2503.             }
  2504.             case '\'': {
  2505.  
  2506.               clearLongStrBuf();
  2507.               state = NS_HTML5TOKENIZER_DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
  2508.               NS_HTML5_CONTINUE(stateloop);
  2509.             }
  2510.             default: {
  2511.               bogusDoctype();
  2512.               state = NS_HTML5TOKENIZER_BOGUS_DOCTYPE;
  2513.               NS_HTML5_CONTINUE(stateloop);
  2514.             }
  2515.           }
  2516.         }
  2517.         afterdoctypepublicidentifierloop_end: ;
  2518.       }
  2519.       case NS_HTML5TOKENIZER_BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS: {
  2520.         for (; ; ) {
  2521.           if (++pos == endPos) {
  2522.             NS_HTML5_BREAK(stateloop);
  2523.           }
  2524.           c = checkChar(buf, pos);
  2525.           switch(c) {
  2526.             case '\r': {
  2527.               silentCarriageReturn();
  2528.               NS_HTML5_BREAK(stateloop);
  2529.             }
  2530.             case '\n': {
  2531.               silentLineFeed();
  2532.             }
  2533.             case ' ':
  2534.             case '\t':
  2535.             case '\f': {
  2536.               continue;
  2537.             }
  2538.             case '>': {
  2539.               emitDoctypeToken(pos);
  2540.               state = NS_HTML5TOKENIZER_DATA;
  2541.               NS_HTML5_CONTINUE(stateloop);
  2542.             }
  2543.             case '\"': {
  2544.               clearLongStrBuf();
  2545.               state = NS_HTML5TOKENIZER_DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
  2546.               NS_HTML5_BREAK(betweendoctypepublicandsystemidentifiersloop);
  2547.             }
  2548.             case '\'': {
  2549.               clearLongStrBuf();
  2550.               state = NS_HTML5TOKENIZER_DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
  2551.               NS_HTML5_CONTINUE(stateloop);
  2552.             }
  2553.             default: {
  2554.               bogusDoctype();
  2555.               state = NS_HTML5TOKENIZER_BOGUS_DOCTYPE;
  2556.               NS_HTML5_CONTINUE(stateloop);
  2557.             }
  2558.           }
  2559.         }
  2560.         betweendoctypepublicandsystemidentifiersloop_end: ;
  2561.       }
  2562.       case NS_HTML5TOKENIZER_DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED: {
  2563.         for (; ; ) {
  2564.           if (++pos == endPos) {
  2565.             NS_HTML5_BREAK(stateloop);
  2566.           }
  2567.           c = checkChar(buf, pos);
  2568.           switch(c) {
  2569.             case '\"': {
  2570.               systemIdentifier = longStrBufToString();
  2571.               state = NS_HTML5TOKENIZER_AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
  2572.               NS_HTML5_CONTINUE(stateloop);
  2573.             }
  2574.             case '>': {
  2575.  
  2576.               forceQuirks = PR_TRUE;
  2577.               systemIdentifier = longStrBufToString();
  2578.               emitDoctypeToken(pos);
  2579.               state = NS_HTML5TOKENIZER_DATA;
  2580.               NS_HTML5_CONTINUE(stateloop);
  2581.             }
  2582.             case '\r': {
  2583.               appendLongStrBufCarriageReturn();
  2584.               NS_HTML5_BREAK(stateloop);
  2585.             }
  2586.             case '\n': {
  2587.               appendLongStrBufLineFeed();
  2588.               continue;
  2589.             }
  2590.             case '\0': {
  2591.               c = 0xfffd;
  2592.             }
  2593.             default: {
  2594.               appendLongStrBuf(c);
  2595.               continue;
  2596.             }
  2597.           }
  2598.         }
  2599.  
  2600.       }
  2601.       case NS_HTML5TOKENIZER_AFTER_DOCTYPE_SYSTEM_IDENTIFIER: {
  2602.         for (; ; ) {
  2603.           if (++pos == endPos) {
  2604.             NS_HTML5_BREAK(stateloop);
  2605.           }
  2606.           c = checkChar(buf, pos);
  2607.           switch(c) {
  2608.             case '\r': {
  2609.               silentCarriageReturn();
  2610.               NS_HTML5_BREAK(stateloop);
  2611.             }
  2612.             case '\n': {
  2613.               silentLineFeed();
  2614.             }
  2615.             case ' ':
  2616.             case '\t':
  2617.             case '\f': {
  2618.               continue;
  2619.             }
  2620.             case '>': {
  2621.               emitDoctypeToken(pos);
  2622.               state = NS_HTML5TOKENIZER_DATA;
  2623.               NS_HTML5_CONTINUE(stateloop);
  2624.             }
  2625.             default: {
  2626.               bogusDoctypeWithoutQuirks();
  2627.               state = NS_HTML5TOKENIZER_BOGUS_DOCTYPE;
  2628.               NS_HTML5_BREAK(afterdoctypesystemidentifierloop);
  2629.             }
  2630.           }
  2631.         }
  2632.         afterdoctypesystemidentifierloop_end: ;
  2633.       }
  2634.       case NS_HTML5TOKENIZER_BOGUS_DOCTYPE: {
  2635.         for (; ; ) {
  2636.           if (reconsume) {
  2637.             reconsume = PR_FALSE;
  2638.           } else {
  2639.             if (++pos == endPos) {
  2640.               NS_HTML5_BREAK(stateloop);
  2641.             }
  2642.             c = checkChar(buf, pos);
  2643.           }
  2644.           switch(c) {
  2645.             case '>': {
  2646.               emitDoctypeToken(pos);
  2647.               state = NS_HTML5TOKENIZER_DATA;
  2648.               NS_HTML5_CONTINUE(stateloop);
  2649.             }
  2650.             case '\r': {
  2651.               silentCarriageReturn();
  2652.               NS_HTML5_BREAK(stateloop);
  2653.             }
  2654.             case '\n': {
  2655.               silentLineFeed();
  2656.             }
  2657.             default: {
  2658.               continue;
  2659.             }
  2660.           }
  2661.         }
  2662.       }
  2663.       case NS_HTML5TOKENIZER_DOCTYPE_YSTEM: {
  2664.         for (; ; ) {
  2665.           if (++pos == endPos) {
  2666.             NS_HTML5_BREAK(stateloop);
  2667.           }
  2668.           c = checkChar(buf, pos);
  2669.           if (index < 5) {
  2670.             PRUnichar folded = c;
  2671.             if (c >= 'A' && c <= 'Z') {
  2672.               folded += 0x20;
  2673.             }
  2674.             if (folded != nsHtml5Tokenizer::YSTEM[index]) {
  2675.               bogusDoctype();
  2676.               state = NS_HTML5TOKENIZER_BOGUS_DOCTYPE;
  2677.               reconsume = PR_TRUE;
  2678.               NS_HTML5_CONTINUE(stateloop);
  2679.             }
  2680.             index++;
  2681.             NS_HTML5_CONTINUE(stateloop);
  2682.           } else {
  2683.             state = NS_HTML5TOKENIZER_AFTER_DOCTYPE_SYSTEM_KEYWORD;
  2684.             reconsume = PR_TRUE;
  2685.             NS_HTML5_BREAK(doctypeystemloop);
  2686.           }
  2687.         }
  2688.         doctypeystemloop_end: ;
  2689.       }
  2690.       case NS_HTML5TOKENIZER_AFTER_DOCTYPE_SYSTEM_KEYWORD: {
  2691.         for (; ; ) {
  2692.           if (reconsume) {
  2693.             reconsume = PR_FALSE;
  2694.           } else {
  2695.             if (++pos == endPos) {
  2696.               NS_HTML5_BREAK(stateloop);
  2697.             }
  2698.             c = checkChar(buf, pos);
  2699.           }
  2700.           switch(c) {
  2701.             case '\r': {
  2702.               silentCarriageReturn();
  2703.               state = NS_HTML5TOKENIZER_BEFORE_DOCTYPE_SYSTEM_IDENTIFIER;
  2704.               NS_HTML5_BREAK(stateloop);
  2705.             }
  2706.             case '\n': {
  2707.               silentLineFeed();
  2708.             }
  2709.             case ' ':
  2710.             case '\t':
  2711.             case '\f': {
  2712.               state = NS_HTML5TOKENIZER_BEFORE_DOCTYPE_SYSTEM_IDENTIFIER;
  2713.               NS_HTML5_BREAK(afterdoctypesystemkeywordloop);
  2714.             }
  2715.             case '\"': {
  2716.  
  2717.               clearLongStrBuf();
  2718.               state = NS_HTML5TOKENIZER_DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
  2719.               NS_HTML5_CONTINUE(stateloop);
  2720.             }
  2721.             case '\'': {
  2722.  
  2723.               clearLongStrBuf();
  2724.               state = NS_HTML5TOKENIZER_DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
  2725.               NS_HTML5_CONTINUE(stateloop);
  2726.             }
  2727.             case '>': {
  2728.  
  2729.               forceQuirks = PR_TRUE;
  2730.               emitDoctypeToken(pos);
  2731.               state = NS_HTML5TOKENIZER_DATA;
  2732.               NS_HTML5_CONTINUE(stateloop);
  2733.             }
  2734.             default: {
  2735.               bogusDoctype();
  2736.               state = NS_HTML5TOKENIZER_BOGUS_DOCTYPE;
  2737.               NS_HTML5_CONTINUE(stateloop);
  2738.             }
  2739.           }
  2740.         }
  2741.         afterdoctypesystemkeywordloop_end: ;
  2742.       }
  2743.       case NS_HTML5TOKENIZER_BEFORE_DOCTYPE_SYSTEM_IDENTIFIER: {
  2744.         for (; ; ) {
  2745.           if (++pos == endPos) {
  2746.             NS_HTML5_BREAK(stateloop);
  2747.           }
  2748.           c = checkChar(buf, pos);
  2749.           switch(c) {
  2750.             case '\r': {
  2751.               silentCarriageReturn();
  2752.               NS_HTML5_BREAK(stateloop);
  2753.             }
  2754.             case '\n': {
  2755.               silentLineFeed();
  2756.             }
  2757.             case ' ':
  2758.             case '\t':
  2759.             case '\f': {
  2760.               continue;
  2761.             }
  2762.             case '\"': {
  2763.               clearLongStrBuf();
  2764.               state = NS_HTML5TOKENIZER_DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
  2765.               NS_HTML5_CONTINUE(stateloop);
  2766.             }
  2767.             case '\'': {
  2768.               clearLongStrBuf();
  2769.               state = NS_HTML5TOKENIZER_DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
  2770.               NS_HTML5_BREAK(beforedoctypesystemidentifierloop);
  2771.             }
  2772.             case '>': {
  2773.  
  2774.               forceQuirks = PR_TRUE;
  2775.               emitDoctypeToken(pos);
  2776.               state = NS_HTML5TOKENIZER_DATA;
  2777.               NS_HTML5_CONTINUE(stateloop);
  2778.             }
  2779.             default: {
  2780.               bogusDoctype();
  2781.               state = NS_HTML5TOKENIZER_BOGUS_DOCTYPE;
  2782.               NS_HTML5_CONTINUE(stateloop);
  2783.             }
  2784.           }
  2785.         }
  2786.         beforedoctypesystemidentifierloop_end: ;
  2787.       }
  2788.       case NS_HTML5TOKENIZER_DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED: {
  2789.         for (; ; ) {
  2790.           if (++pos == endPos) {
  2791.             NS_HTML5_BREAK(stateloop);
  2792.           }
  2793.           c = checkChar(buf, pos);
  2794.           switch(c) {
  2795.             case '\'': {
  2796.               systemIdentifier = longStrBufToString();
  2797.               state = NS_HTML5TOKENIZER_AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
  2798.               NS_HTML5_CONTINUE(stateloop);
  2799.             }
  2800.             case '>': {
  2801.  
  2802.               forceQuirks = PR_TRUE;
  2803.               systemIdentifier = longStrBufToString();
  2804.               emitDoctypeToken(pos);
  2805.               state = NS_HTML5TOKENIZER_DATA;
  2806.               NS_HTML5_CONTINUE(stateloop);
  2807.             }
  2808.             case '\r': {
  2809.               appendLongStrBufCarriageReturn();
  2810.               NS_HTML5_BREAK(stateloop);
  2811.             }
  2812.             case '\n': {
  2813.               appendLongStrBufLineFeed();
  2814.               continue;
  2815.             }
  2816.             case '\0': {
  2817.               c = 0xfffd;
  2818.             }
  2819.             default: {
  2820.               appendLongStrBuf(c);
  2821.               continue;
  2822.             }
  2823.           }
  2824.         }
  2825.       }
  2826.       case NS_HTML5TOKENIZER_DOCTYPE_8PUBLIC_IDENTIFIER_SINGLE_QUOTED: {
  2827.         for (; ; ) {
  2828.           if (++pos == endPos) {
  2829.             NS_HTML5_BREAK(stateloop);
  2830.           }
  2831.           c = checkChar(buf, pos);
  2832.           switch(c) {
  2833.             case '\'': {
  2834.               publicIdentifier = longStrBufToString();
  2835.               state = NS_HTML5TOKENIZER_AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
  2836.               NS_HTML5_CONTINUE(stateloop);
  2837.             }
  2838.             case '>': {
  2839.  
  2840.               forceQuirks = PR_TRUE;
  2841.               publicIdentifier = longStrBufToString();
  2842.               emitDoctypeToken(pos);
  2843.               state = NS_HTML5TOKENIZER_DATA;
  2844.               NS_HTML5_CONTINUE(stateloop);
  2845.             }
  2846.             case '\r': {
  2847.               appendLongStrBufCarriageReturn();
  2848.               NS_HTML5_BREAK(stateloop);
  2849.             }
  2850.             case '\n': {
  2851.               appendLongStrBufLineFeed();
  2852.               continue;
  2853.             }
  2854.             case '\0': {
  2855.               c = 0xfffd;
  2856.             }
  2857.             default: {
  2858.               appendLongStrBuf(c);
  2859.               continue;
  2860.             }
  2861.           }
  2862.         }
  2863.       }
  2864.     }
  2865.   }
  2866.   stateloop_end: ;
  2867.   flushChars(buf, pos);
  2868.   stateSave = state;
  2869.   returnStateSave = returnState;
  2870.   return pos;
  2871. }
  2872.  
  2873.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!