Changeset 92249 in webkit
- Timestamp:
- Aug 2, 2011 5:04:06 PM (13 years ago)
- Location:
- trunk/Source/WebCore
- Files:
-
- 4 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/WebCore/ChangeLog
r92248 r92249 1 2011-08-02 Jeffrey Pfau <jpfau@apple.com> 2 3 Add namespace prefix support in XML tokenizer 4 https://bugs.webkit.org/show_bug.cgi?id=65578 5 6 Reviewed by Adam Barth. 7 8 This also changes markup debug printing to print to stderr instead of stdout 9 10 * xml/parser/MarkupTokenBase.h: 11 (WebCore::MarkupTokenBase::printString): 12 * xml/parser/XMLToken.h: 13 (WebCore::XMLToken::XMLDeclarationData::XMLDeclarationData): 14 (WebCore::XMLToken::clear): 15 (WebCore::XMLToken::appendToName): 16 (WebCore::XMLToken::name): 17 (WebCore::XMLToken::target): 18 (WebCore::XMLToken::data): 19 (WebCore::XMLToken::prefix): 20 (WebCore::XMLToken::xmlDeclarationData): 21 (WebCore::XMLToken::endPrefix): 22 (WebCore::XMLToken::hasPrefix): 23 (WebCore::XMLToken::endAttributePrefix): 24 (WebCore::XMLToken::attributeHasPrefix): 25 (WebCore::XMLToken::printAttrs): 26 (WebCore::XMLToken::print): 27 * xml/parser/XMLTokenizer.cpp: 28 (WebCore::XMLTokenizer::nextToken): 29 1 30 2011-08-02 Zhenyao Mo <zmo@google.com> 2 31 -
trunk/Source/WebCore/xml/parser/MarkupTokenBase.h
r91643 r92249 52 52 WTF::Vector<UChar> m_systemIdentifier; 53 53 }; 54 55 template<typename TypeSet, typename DoctypeData = DoctypeDataBase> 54 55 class AttributeBase { 56 public: 57 class Range { 58 public: 59 int m_start; 60 int m_end; 61 }; 62 63 Range m_nameRange; 64 Range m_valueRange; 65 WTF::Vector<UChar, 32> m_name; 66 WTF::Vector<UChar, 32> m_value; 67 }; 68 69 template<typename TypeSet, typename DoctypeData = DoctypeDataBase, typename AttributeType = AttributeBase> 56 70 class MarkupTokenBase { 57 71 WTF_MAKE_NONCOPYABLE(MarkupTokenBase); … … 59 73 public: 60 74 typedef TypeSet Type; 61 62 class Range { 63 public: 64 int m_start; 65 int m_end; 66 }; 67 68 class Attribute { 69 public: 70 Range m_nameRange; 71 Range m_valueRange; 72 WTF::Vector<UChar, 32> m_name; 73 WTF::Vector<UChar, 32> m_value; 74 }; 75 typedef AttributeType Attribute; 75 76 76 77 typedef WTF::Vector<Attribute, 10> AttributeList; … … 335 336 DataVector::const_iterator iter = string.begin(); 336 337 for (; iter != string.end(); ++iter) 337 printf("%lc", wchar_t(*iter)); 338 } 339 340 void printAttrs() const 341 { 342 typename AttributeList::const_iterator iter = m_attributes.begin(); 343 for (; iter != m_attributes.end(); ++iter) { 344 printf(" "); 345 printString(iter->m_name); 346 printf("=\""); 347 printString(iter->m_value); 348 printf("\""); 349 } 338 fprintf(stderr, "%lc", wchar_t(*iter)); 350 339 } 351 340 #endif // NDEBUG … … 368 357 369 358 typename Type::Type m_type; 370 Range m_range; // Always starts at zero.359 typename Attribute::Range m_range; // Always starts at zero. 371 360 int m_baseOffset; 372 361 DataVector m_data; -
trunk/Source/WebCore/xml/parser/XMLToken.h
r91811 r92249 28 28 #define XMLToken_h 29 29 30 #include "Element.h" 30 31 #include "MarkupTokenBase.h" 31 32 … … 39 40 XMLDeclaration, 40 41 DOCTYPE, 41 AttributeListDeclaration,42 ElementDeclaration,43 EntityDeclaration,44 42 CDATA, 45 43 StartTag, … … 52 50 }; 53 51 54 class XMLToken : public MarkupTokenBase<XMLTokenTypes>{52 class PrefixedAttribute : public AttributeBase { 55 53 public: 56 virtual void clear() 57 { 58 MarkupTokenBase<XMLTokenTypes>::clear(); 59 m_target.clear(); 60 } 61 62 void appendToName(UChar character) 63 { 64 ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag || m_type == XMLTokenTypes::DOCTYPE || m_type == XMLTokenTypes::Entity); 65 MarkupTokenBase<XMLTokenTypes>::appendToName(character); 66 } 67 68 const DataVector& name() const 69 { 70 ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag || m_type == XMLTokenTypes::DOCTYPE || m_type == XMLTokenTypes::Entity); 71 return MarkupTokenBase<XMLTokenTypes>::name(); 72 } 73 74 void beginDOCTYPE() 75 { 76 ASSERT(m_type == XMLTokenTypes::Uninitialized); 77 m_type = XMLTokenTypes::DOCTYPE; 78 m_doctypeData = adoptPtr(new DoctypeData()); 79 } 80 81 void beginDOCTYPE(UChar character) 82 { 83 ASSERT(character); 84 beginDOCTYPE(); 85 m_data.append(character); 86 } 87 88 void beginXMLDeclaration() 89 { 90 ASSERT(m_type == XMLTokenTypes::Uninitialized); 91 m_type = XMLTokenTypes::XMLDeclaration; 92 m_xmlDeclarationData = adoptPtr(new XMLDeclarationData()); 93 } 94 95 void appendToXMLVersion(UChar character) 96 { 97 ASSERT(character); 98 ASSERT(m_type == XMLTokenTypes::XMLDeclaration); 99 ASSERT(m_xmlDeclarationData); 100 m_xmlDeclarationData->m_version.append(character); 101 } 102 103 void beginXMLEncoding(UChar character) 104 { 105 ASSERT(character); 106 ASSERT(m_type == XMLTokenTypes::XMLDeclaration); 107 ASSERT(m_xmlDeclarationData); 108 m_xmlDeclarationData->m_hasEncoding = true; 109 m_xmlDeclarationData->m_encoding.append(character); 110 } 111 112 void appendToXMLEncoding(UChar character) 113 { 114 ASSERT(character); 115 ASSERT(m_type == XMLTokenTypes::XMLDeclaration); 116 ASSERT(m_xmlDeclarationData); 117 ASSERT(m_xmlDeclarationData->m_hasEncoding); 118 m_xmlDeclarationData->m_encoding.append(character); 119 } 120 121 void setXMLStandalone(bool standalone) 122 { 123 ASSERT(m_type == XMLTokenTypes::XMLDeclaration); 124 ASSERT(m_xmlDeclarationData); 125 m_xmlDeclarationData->m_hasStandalone = true; 126 m_xmlDeclarationData->m_standalone = standalone; 127 } 128 129 void beginProcessingInstruction() 130 { 131 ASSERT(m_type == XMLTokenTypes::Uninitialized); 132 m_type = XMLTokenTypes::ProcessingInstruction; 133 } 134 135 void beginProcessingInstruction(UChar character) 136 { 137 ASSERT(character); 138 beginProcessingInstruction(); 139 m_target.append(character); 140 } 141 142 void appendToProcessingInstructionTarget(UChar character) 143 { 144 ASSERT(m_type == XMLTokenTypes::ProcessingInstruction); 145 ASSERT(character); 146 m_target.append(character); 147 } 148 149 void appendToProcessingInstructionData(UChar character) 150 { 151 ASSERT(m_type == XMLTokenTypes::ProcessingInstruction); 152 ASSERT(character); 153 m_data.append(character); 154 } 155 156 void beginCDATA() 157 { 158 ASSERT(m_type == XMLTokenTypes::Uninitialized); 159 m_type = XMLTokenTypes::CDATA; 160 } 161 162 void appendToCDATA(UChar character) 163 { 164 ASSERT(m_type == XMLTokenTypes::CDATA); 165 ASSERT(character); 166 m_data.append(character); 167 } 168 169 void beginEntity() 170 { 171 ASSERT(m_type == XMLTokenTypes::Uninitialized); 172 m_type = XMLTokenTypes::Entity; 173 } 174 175 void beginEntity(UChar character) 176 { 177 ASSERT(character); 178 beginEntity(); 179 m_data.append(character); 180 } 181 182 #ifndef NDEBUG 183 void print() const 184 { 185 switch (m_type) { 186 case XMLTokenTypes::Uninitialized: 187 printf("UNITIALIZED"); 188 break; 189 190 case XMLTokenTypes::ProcessingInstruction: 191 printf("ProcessingInstruction: "); 192 printf("<?"); 193 printString(m_target); 194 printf(" "); 195 printString(m_data); 196 printf("?>"); 197 break; 198 199 case XMLTokenTypes::XMLDeclaration: 200 printf("XML Declaration: "); 201 printf("<?xml version=\""); 202 ASSERT(m_xmlDeclarationData); 203 printString(m_xmlDeclarationData->m_version); 204 printf("\""); 205 if (m_xmlDeclarationData->m_hasEncoding) { 206 printf(" encoding=\""); 207 printString(m_xmlDeclarationData->m_encoding); 208 printf("\""); 209 } 210 if (m_xmlDeclarationData->m_hasStandalone) 211 printf(" standalone=\"%s\"", m_xmlDeclarationData->m_standalone ? "yes" : "no"); 212 printf("?>"); 213 break; 214 215 case XMLTokenTypes::DOCTYPE: 216 printf("DOCTYPE: "); 217 ASSERT(m_doctypeData); 218 printf("<!DOCTYPE "); 219 printString(m_data); 220 if (m_doctypeData->m_hasPublicIdentifier) { 221 printf(" PUBLIC \""); 222 printString(m_doctypeData->m_publicIdentifier); 223 printf("\""); 224 if (m_doctypeData->m_hasSystemIdentifier) { 225 printf(" \""); 226 printString(m_doctypeData->m_systemIdentifier); 227 printf("\""); 228 } 229 } else if (m_doctypeData->m_hasSystemIdentifier) { 230 printf(" SYSTEM \""); 231 printString(m_doctypeData->m_systemIdentifier); 232 printf("\""); 233 } 234 printf(">"); 235 break; 236 237 case XMLTokenTypes::AttributeListDeclaration: 238 printf("Attribute List: "); 239 printf("<!ATTLIST>"); 240 break; 241 242 case XMLTokenTypes::ElementDeclaration: 243 printf("Element Declaration: "); 244 printf("<!ELEMENT>"); 245 break; 246 247 case XMLTokenTypes::EntityDeclaration: 248 printf("Entity Declaration: "); 249 printf("<!ENTITY>"); 250 break; 251 252 case XMLTokenTypes::CDATA: 253 printf("CDATA: "); 254 printf("<![CDATA["); 255 printString(m_data); 256 printf("]]>"); 257 break; 258 259 case XMLTokenTypes::StartTag: 260 printf("Start Tag: "); 261 printf("<"); 262 printString(m_data); 263 printAttrs(); 264 if (selfClosing()) 265 printf("/"); 266 printf(">"); 267 break; 268 269 case XMLTokenTypes::EndTag: 270 printf("End Tag: "); 271 printf("</"); 272 printString(m_data); 273 printf(">"); 274 break; 275 276 case XMLTokenTypes::Comment: 277 printf("Comment: "); 278 printf("<!--"); 279 printString(m_data); 280 printf("-->"); 281 break; 282 283 case XMLTokenTypes::Character: 284 printf("Characters: "); 285 printString(m_data); 286 break; 287 288 case XMLTokenTypes::Entity: 289 printf("Entity: "); 290 printf("&"); 291 printString(m_data); 292 printf(";"); 293 break; 294 295 case XMLTokenTypes::EndOfFile: 296 printf("EOF"); 297 break; 298 } 299 300 printf("\n"); 301 } 302 #endif // NDEBUG 303 304 private: 305 typedef DoctypeDataBase DoctypeData; 306 54 Range m_prefixRange; 55 WTF::Vector<UChar, 32> m_prefix; 56 }; 57 58 class XMLToken : public MarkupTokenBase<XMLTokenTypes, DoctypeDataBase, PrefixedAttribute> { 59 public: 307 60 class XMLDeclarationData { 308 61 WTF_MAKE_NONCOPYABLE(XMLDeclarationData); … … 314 67 { 315 68 } 316 69 317 70 bool m_hasStandalone; 318 71 bool m_hasEncoding; … … 322 75 }; 323 76 324 // "target" for ProcessingInstruction 77 virtual void clear() 78 { 79 MarkupTokenBase<XMLTokenTypes, DoctypeDataBase, PrefixedAttribute>::clear(); 80 m_target.clear(); 81 } 82 83 void appendToName(UChar character) 84 { 85 ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag || m_type == XMLTokenTypes::DOCTYPE || m_type == XMLTokenTypes::Entity); 86 MarkupTokenBase<XMLTokenTypes, DoctypeDataBase, PrefixedAttribute>::appendToName(character); 87 } 88 89 const DataVector& name() const 90 { 91 ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag || m_type == XMLTokenTypes::DOCTYPE || m_type == XMLTokenTypes::Entity); 92 return MarkupTokenBase<XMLTokenTypes, DoctypeDataBase, PrefixedAttribute>::name(); 93 } 94 95 const DataVector& target() const 96 { 97 ASSERT(m_type == XMLTokenTypes::ProcessingInstruction); 98 return m_target; 99 } 100 101 const DataVector& data() const 102 { 103 ASSERT(m_type == XMLTokenTypes::CDATA || m_type == XMLTokenTypes::ProcessingInstruction); 104 return m_data; 105 } 106 107 const DataVector& prefix() const 108 { 109 ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag); 110 return m_target; 111 } 112 113 const XMLDeclarationData& xmlDeclarationData() const 114 { 115 ASSERT(m_type == XMLTokenTypes::XMLDeclaration); 116 ASSERT(m_xmlDeclarationData); 117 return *m_xmlDeclarationData.get(); 118 } 119 120 void beginDOCTYPE() 121 { 122 ASSERT(m_type == XMLTokenTypes::Uninitialized); 123 m_type = XMLTokenTypes::DOCTYPE; 124 m_doctypeData = adoptPtr(new DoctypeData()); 125 } 126 127 void beginDOCTYPE(UChar character) 128 { 129 ASSERT(character); 130 beginDOCTYPE(); 131 m_data.append(character); 132 } 133 134 void beginXMLDeclaration() 135 { 136 ASSERT(m_type == XMLTokenTypes::Uninitialized); 137 m_type = XMLTokenTypes::XMLDeclaration; 138 m_xmlDeclarationData = adoptPtr(new XMLDeclarationData()); 139 } 140 141 void appendToXMLVersion(UChar character) 142 { 143 ASSERT(character); 144 ASSERT(m_type == XMLTokenTypes::XMLDeclaration); 145 ASSERT(m_xmlDeclarationData); 146 m_xmlDeclarationData->m_version.append(character); 147 } 148 149 void beginXMLEncoding(UChar character) 150 { 151 ASSERT(character); 152 ASSERT(m_type == XMLTokenTypes::XMLDeclaration); 153 ASSERT(m_xmlDeclarationData); 154 m_xmlDeclarationData->m_hasEncoding = true; 155 m_xmlDeclarationData->m_encoding.append(character); 156 } 157 158 void appendToXMLEncoding(UChar character) 159 { 160 ASSERT(character); 161 ASSERT(m_type == XMLTokenTypes::XMLDeclaration); 162 ASSERT(m_xmlDeclarationData); 163 ASSERT(m_xmlDeclarationData->m_hasEncoding); 164 m_xmlDeclarationData->m_encoding.append(character); 165 } 166 167 void setXMLStandalone(bool standalone) 168 { 169 ASSERT(m_type == XMLTokenTypes::XMLDeclaration); 170 ASSERT(m_xmlDeclarationData); 171 m_xmlDeclarationData->m_hasStandalone = true; 172 m_xmlDeclarationData->m_standalone = standalone; 173 } 174 175 void beginProcessingInstruction() 176 { 177 ASSERT(m_type == XMLTokenTypes::Uninitialized); 178 m_type = XMLTokenTypes::ProcessingInstruction; 179 } 180 181 void beginProcessingInstruction(UChar character) 182 { 183 ASSERT(character); 184 beginProcessingInstruction(); 185 m_target.append(character); 186 } 187 188 void appendToProcessingInstructionTarget(UChar character) 189 { 190 ASSERT(m_type == XMLTokenTypes::ProcessingInstruction); 191 ASSERT(character); 192 m_target.append(character); 193 } 194 195 void appendToProcessingInstructionData(UChar character) 196 { 197 ASSERT(m_type == XMLTokenTypes::ProcessingInstruction); 198 ASSERT(character); 199 m_data.append(character); 200 } 201 202 void endPrefix() 203 { 204 ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag); 205 ASSERT(m_target.isEmpty()); 206 // FIXME: see if we can avoid the copy inherent with this swap 207 m_target.swap(m_data); 208 } 209 210 bool hasPrefix() const 211 { 212 ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag); 213 return m_target.size(); 214 } 215 216 void beginCDATA() 217 { 218 ASSERT(m_type == XMLTokenTypes::Uninitialized); 219 m_type = XMLTokenTypes::CDATA; 220 } 221 222 void appendToCDATA(UChar character) 223 { 224 ASSERT(m_type == XMLTokenTypes::CDATA); 225 ASSERT(character); 226 m_data.append(character); 227 } 228 229 void beginEntity() 230 { 231 ASSERT(m_type == XMLTokenTypes::Uninitialized); 232 m_type = XMLTokenTypes::Entity; 233 } 234 235 void beginEntity(UChar character) 236 { 237 ASSERT(character); 238 beginEntity(); 239 m_data.append(character); 240 } 241 242 void endAttributePrefix(int offset) 243 { 244 ASSERT(m_type == XMLTokenTypes::StartTag); 245 int index = offset - m_baseOffset; 246 m_currentAttribute->m_prefix.swap(m_currentAttribute->m_name); 247 m_currentAttribute->m_prefixRange.m_start = m_currentAttribute->m_valueRange.m_start; 248 m_currentAttribute->m_prefixRange.m_end = index; 249 m_currentAttribute->m_nameRange.m_start = index; 250 m_currentAttribute->m_nameRange.m_end = index; 251 } 252 253 bool attributeHasPrefix() 254 { 255 ASSERT(m_type == XMLTokenTypes::StartTag); 256 return !m_currentAttribute->m_prefix.isEmpty(); 257 } 258 259 #ifndef NDEBUG 260 void printAttrs() const 261 { 262 AttributeList::const_iterator iter = m_attributes.begin(); 263 for (; iter != m_attributes.end(); ++iter) { 264 fprintf(stderr, " "); 265 if (!iter->m_prefix.isEmpty()) { 266 printString(iter->m_prefix); 267 fprintf(stderr, ":"); 268 } 269 printString(iter->m_name); 270 fprintf(stderr, "=\""); 271 printString(iter->m_value); 272 fprintf(stderr, "\""); 273 } 274 } 275 276 void print() const 277 { 278 switch (m_type) { 279 case XMLTokenTypes::Uninitialized: 280 fprintf(stderr, "UNITIALIZED"); 281 break; 282 283 case XMLTokenTypes::ProcessingInstruction: 284 fprintf(stderr, "ProcessingInstruction: "); 285 fprintf(stderr, "<?"); 286 printString(m_target); 287 fprintf(stderr, " "); 288 printString(m_data); 289 fprintf(stderr, "?>"); 290 break; 291 292 case XMLTokenTypes::XMLDeclaration: 293 fprintf(stderr, "XML Declaration: "); 294 fprintf(stderr, "<?xml version=\""); 295 ASSERT(m_xmlDeclarationData); 296 printString(m_xmlDeclarationData->m_version); 297 fprintf(stderr, "\""); 298 if (m_xmlDeclarationData->m_hasEncoding) { 299 fprintf(stderr, " encoding=\""); 300 printString(m_xmlDeclarationData->m_encoding); 301 fprintf(stderr, "\""); 302 } 303 if (m_xmlDeclarationData->m_hasStandalone) 304 fprintf(stderr, " standalone=\"%s\"", m_xmlDeclarationData->m_standalone ? "yes" : "no"); 305 fprintf(stderr, "?>"); 306 break; 307 308 case XMLTokenTypes::DOCTYPE: 309 fprintf(stderr, "DOCTYPE: "); 310 ASSERT(m_doctypeData); 311 fprintf(stderr, "<!DOCTYPE "); 312 printString(m_data); 313 if (m_doctypeData->m_hasPublicIdentifier) { 314 fprintf(stderr, " PUBLIC \""); 315 printString(m_doctypeData->m_publicIdentifier); 316 fprintf(stderr, "\""); 317 if (m_doctypeData->m_hasSystemIdentifier) { 318 fprintf(stderr, " \""); 319 printString(m_doctypeData->m_systemIdentifier); 320 fprintf(stderr, "\""); 321 } 322 } else if (m_doctypeData->m_hasSystemIdentifier) { 323 fprintf(stderr, " SYSTEM \""); 324 printString(m_doctypeData->m_systemIdentifier); 325 fprintf(stderr, "\""); 326 } 327 fprintf(stderr, ">"); 328 break; 329 330 case XMLTokenTypes::CDATA: 331 fprintf(stderr, "CDATA: "); 332 fprintf(stderr, "<![CDATA["); 333 printString(m_data); 334 fprintf(stderr, "]]>"); 335 break; 336 337 case XMLTokenTypes::StartTag: 338 fprintf(stderr, "Start Tag: "); 339 fprintf(stderr, "<"); 340 if (hasPrefix()) { 341 printString(m_target); 342 fprintf(stderr, ":"); 343 } 344 printString(m_data); 345 printAttrs(); 346 if (selfClosing()) 347 fprintf(stderr, "/"); 348 fprintf(stderr, ">"); 349 break; 350 351 case XMLTokenTypes::EndTag: 352 fprintf(stderr, "End Tag: "); 353 fprintf(stderr, "</"); 354 if (hasPrefix()) { 355 printString(m_target); 356 fprintf(stderr, ":"); 357 } 358 printString(m_data); 359 fprintf(stderr, ">"); 360 break; 361 362 case XMLTokenTypes::Comment: 363 fprintf(stderr, "Comment: "); 364 fprintf(stderr, "<!--"); 365 printString(m_data); 366 fprintf(stderr, "-->"); 367 break; 368 369 case XMLTokenTypes::Character: 370 fprintf(stderr, "Characters: "); 371 printString(m_data); 372 break; 373 374 case XMLTokenTypes::Entity: 375 fprintf(stderr, "Entity: "); 376 fprintf(stderr, "&"); 377 printString(m_data); 378 fprintf(stderr, ";"); 379 break; 380 381 case XMLTokenTypes::EndOfFile: 382 fprintf(stderr, "EOF"); 383 break; 384 } 385 386 fprintf(stderr, "\n"); 387 } 388 #endif // NDEBUG 389 390 private: 391 392 typedef DoctypeDataBase DoctypeData; 393 394 // "target" for ProcessingInstruction, "prefix" for StartTag and EndTag 325 395 DataVector m_target; 326 396 327 397 // For XML Declaration 328 398 OwnPtr<XMLDeclarationData> m_xmlDeclarationData; -
trunk/Source/WebCore/xml/parser/XMLTokenizer.cpp
r91811 r92249 115 115 if (cc < 0x30) 116 116 return false; 117 if (cc < 0x3 B)117 if (cc < 0x3A) 118 118 return true; 119 119 if (cc < 0x0300) … … 302 302 m_token->appendToName(cc); 303 303 XML_ADVANCE_TO(TagNameState); 304 } else if (cc == ':' && !m_token->hasPrefix()) { 305 m_token->endPrefix(); 306 XML_ADVANCE_TO(TagNameState); 304 307 } else { 305 308 parseError(); … … 316 319 else if (isValidNameChar(cc)) { 317 320 m_token->appendToName(cc); 321 XML_ADVANCE_TO(EndTagNameState); 322 } else if (cc == ':' && !m_token->hasPrefix()) { 323 m_token->endPrefix(); 318 324 XML_ADVANCE_TO(EndTagNameState); 319 325 } else { … … 364 370 } else if (isValidNameChar(cc)) { 365 371 m_token->appendToAttributeName(cc); 372 XML_ADVANCE_TO(AttributeNameState); 373 } else if (cc == ':' && !m_token->attributeHasPrefix()) { 374 m_token->endAttributePrefix(source.numberOfCharactersConsumed()); 366 375 XML_ADVANCE_TO(AttributeNameState); 367 376 } else {
Note: See TracChangeset
for help on using the changeset viewer.