1 /* 2 * HTMLparser.c : an HTML 4.0 non-verifying parser 3 * 4 * See Copyright for the status of this software. 5 * 6 * daniel@veillard.com 7 */ 8 9 #define IN_LIBXML 10 #include "libxml.h" 11 #ifdef LIBXML_HTML_ENABLED 12 13 #include <string.h> 14 #include <ctype.h> 15 #include <stdlib.h> 16 17 #include <libxml/xmlmemory.h> 18 #include <libxml/tree.h> 19 #include <libxml/parser.h> 20 #include <libxml/parserInternals.h> 21 #include <libxml/xmlerror.h> 22 #include <libxml/HTMLparser.h> 23 #include <libxml/HTMLtree.h> 24 #include <libxml/entities.h> 25 #include <libxml/encoding.h> 26 #include <libxml/valid.h> 27 #include <libxml/xmlIO.h> 28 #include <libxml/globals.h> 29 #include <libxml/uri.h> 30 31 #include "buf.h" 32 #include "enc.h" 33 34 #define HTML_MAX_NAMELEN 1000 35 #define HTML_PARSER_BIG_BUFFER_SIZE 1000 36 #define HTML_PARSER_BUFFER_SIZE 100 37 38 /* #define DEBUG */ 39 /* #define DEBUG_PUSH */ 40 41 static int htmlOmittedDefaultValue = 1; 42 43 xmlChar * htmlDecodeEntities(htmlParserCtxtPtr ctxt, int len, 44 xmlChar end, xmlChar end2, xmlChar end3); 45 static void htmlParseComment(htmlParserCtxtPtr ctxt); 46 47 /************************************************************************ 48 * * 49 * Some factorized error routines * 50 * * 51 ************************************************************************/ 52 53 /** 54 * htmlErrMemory: 55 * @ctxt: an HTML parser context 56 * @extra: extra information 57 * 58 * Handle a redefinition of attribute error 59 */ 60 static void 61 htmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra) 62 { 63 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 64 (ctxt->instate == XML_PARSER_EOF)) 65 return; 66 if (ctxt != NULL) { 67 ctxt->errNo = XML_ERR_NO_MEMORY; 68 ctxt->instate = XML_PARSER_EOF; 69 ctxt->disableSAX = 1; 70 } 71 if (extra) 72 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, 73 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra, 74 NULL, NULL, 0, 0, 75 "Memory allocation failed : %s\n", extra); 76 else 77 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, 78 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL, 79 NULL, NULL, 0, 0, "Memory allocation failed\n"); 80 } 81 82 /** 83 * htmlParseErr: 84 * @ctxt: an HTML parser context 85 * @error: the error number 86 * @msg: the error message 87 * @str1: string infor 88 * @str2: string infor 89 * 90 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 91 */ 92 static void LIBXML_ATTR_FORMAT(3,0) 93 htmlParseErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, 94 const char *msg, const xmlChar *str1, const xmlChar *str2) 95 { 96 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 97 (ctxt->instate == XML_PARSER_EOF)) 98 return; 99 if (ctxt != NULL) 100 ctxt->errNo = error; 101 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_HTML, error, 102 XML_ERR_ERROR, NULL, 0, 103 (const char *) str1, (const char *) str2, 104 NULL, 0, 0, 105 msg, str1, str2); 106 if (ctxt != NULL) 107 ctxt->wellFormed = 0; 108 } 109 110 /** 111 * htmlParseErrInt: 112 * @ctxt: an HTML parser context 113 * @error: the error number 114 * @msg: the error message 115 * @val: integer info 116 * 117 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 118 */ 119 static void LIBXML_ATTR_FORMAT(3,0) 120 htmlParseErrInt(xmlParserCtxtPtr ctxt, xmlParserErrors error, 121 const char *msg, int val) 122 { 123 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 124 (ctxt->instate == XML_PARSER_EOF)) 125 return; 126 if (ctxt != NULL) 127 ctxt->errNo = error; 128 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_HTML, error, 129 XML_ERR_ERROR, NULL, 0, NULL, NULL, 130 NULL, val, 0, msg, val); 131 if (ctxt != NULL) 132 ctxt->wellFormed = 0; 133 } 134 135 /************************************************************************ 136 * * 137 * Parser stacks related functions and macros * 138 * * 139 ************************************************************************/ 140 141 /** 142 * htmlnamePush: 143 * @ctxt: an HTML parser context 144 * @value: the element name 145 * 146 * Pushes a new element name on top of the name stack 147 * 148 * Returns 0 in case of error, the index in the stack otherwise 149 */ 150 static int 151 htmlnamePush(htmlParserCtxtPtr ctxt, const xmlChar * value) 152 { 153 if ((ctxt->html < 3) && (xmlStrEqual(value, BAD_CAST "head"))) 154 ctxt->html = 3; 155 if ((ctxt->html < 10) && (xmlStrEqual(value, BAD_CAST "body"))) 156 ctxt->html = 10; 157 if (ctxt->nameNr >= ctxt->nameMax) { 158 ctxt->nameMax *= 2; 159 ctxt->nameTab = (const xmlChar * *) 160 xmlRealloc((xmlChar * *)ctxt->nameTab, 161 ctxt->nameMax * 162 sizeof(ctxt->nameTab[0])); 163 if (ctxt->nameTab == NULL) { 164 htmlErrMemory(ctxt, NULL); 165 return (0); 166 } 167 } 168 ctxt->nameTab[ctxt->nameNr] = value; 169 ctxt->name = value; 170 return (ctxt->nameNr++); 171 } 172 /** 173 * htmlnamePop: 174 * @ctxt: an HTML parser context 175 * 176 * Pops the top element name from the name stack 177 * 178 * Returns the name just removed 179 */ 180 static const xmlChar * 181 htmlnamePop(htmlParserCtxtPtr ctxt) 182 { 183 const xmlChar *ret; 184 185 if (ctxt->nameNr <= 0) 186 return (NULL); 187 ctxt->nameNr--; 188 if (ctxt->nameNr < 0) 189 return (NULL); 190 if (ctxt->nameNr > 0) 191 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1]; 192 else 193 ctxt->name = NULL; 194 ret = ctxt->nameTab[ctxt->nameNr]; 195 ctxt->nameTab[ctxt->nameNr] = NULL; 196 return (ret); 197 } 198 199 /** 200 * htmlNodeInfoPush: 201 * @ctxt: an HTML parser context 202 * @value: the node info 203 * 204 * Pushes a new element name on top of the node info stack 205 * 206 * Returns 0 in case of error, the index in the stack otherwise 207 */ 208 static int 209 htmlNodeInfoPush(htmlParserCtxtPtr ctxt, htmlParserNodeInfo *value) 210 { 211 if (ctxt->nodeInfoNr >= ctxt->nodeInfoMax) { 212 if (ctxt->nodeInfoMax == 0) 213 ctxt->nodeInfoMax = 5; 214 ctxt->nodeInfoMax *= 2; 215 ctxt->nodeInfoTab = (htmlParserNodeInfo *) 216 xmlRealloc((htmlParserNodeInfo *)ctxt->nodeInfoTab, 217 ctxt->nodeInfoMax * 218 sizeof(ctxt->nodeInfoTab[0])); 219 if (ctxt->nodeInfoTab == NULL) { 220 htmlErrMemory(ctxt, NULL); 221 return (0); 222 } 223 } 224 ctxt->nodeInfoTab[ctxt->nodeInfoNr] = *value; 225 ctxt->nodeInfo = &ctxt->nodeInfoTab[ctxt->nodeInfoNr]; 226 return (ctxt->nodeInfoNr++); 227 } 228 229 /** 230 * htmlNodeInfoPop: 231 * @ctxt: an HTML parser context 232 * 233 * Pops the top element name from the node info stack 234 * 235 * Returns 0 in case of error, the pointer to NodeInfo otherwise 236 */ 237 static htmlParserNodeInfo * 238 htmlNodeInfoPop(htmlParserCtxtPtr ctxt) 239 { 240 if (ctxt->nodeInfoNr <= 0) 241 return (NULL); 242 ctxt->nodeInfoNr--; 243 if (ctxt->nodeInfoNr < 0) 244 return (NULL); 245 if (ctxt->nodeInfoNr > 0) 246 ctxt->nodeInfo = &ctxt->nodeInfoTab[ctxt->nodeInfoNr - 1]; 247 else 248 ctxt->nodeInfo = NULL; 249 return &ctxt->nodeInfoTab[ctxt->nodeInfoNr]; 250 } 251 252 /* 253 * Macros for accessing the content. Those should be used only by the parser, 254 * and not exported. 255 * 256 * Dirty macros, i.e. one need to make assumption on the context to use them 257 * 258 * CUR_PTR return the current pointer to the xmlChar to be parsed. 259 * CUR returns the current xmlChar value, i.e. a 8 bit value if compiled 260 * in ISO-Latin or UTF-8, and the current 16 bit value if compiled 261 * in UNICODE mode. This should be used internally by the parser 262 * only to compare to ASCII values otherwise it would break when 263 * running with UTF-8 encoding. 264 * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only 265 * to compare on ASCII based substring. 266 * UPP(n) returns the n'th next xmlChar converted to uppercase. Same as CUR 267 * it should be used only to compare on ASCII based substring. 268 * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined 269 * strings without newlines within the parser. 270 * 271 * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding 272 * 273 * CURRENT Returns the current char value, with the full decoding of 274 * UTF-8 if we are using this mode. It returns an int. 275 * NEXT Skip to the next character, this does the proper decoding 276 * in UTF-8 mode. It also pop-up unfinished entities on the fly. 277 * NEXTL(l) Skip the current unicode character of l xmlChars long. 278 * COPY(to) copy one char to *to, increment CUR_PTR and to accordingly 279 */ 280 281 #define UPPER (toupper(*ctxt->input->cur)) 282 283 #define SKIP(val) ctxt->input->cur += (val),ctxt->input->col+=(val) 284 285 #define NXT(val) ctxt->input->cur[(val)] 286 287 #define UPP(val) (toupper(ctxt->input->cur[(val)])) 288 289 #define CUR_PTR ctxt->input->cur 290 #define BASE_PTR ctxt->input->base 291 292 #define SHRINK if ((ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \ 293 (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \ 294 xmlParserInputShrink(ctxt->input) 295 296 #define GROW if ((ctxt->progressive == 0) && \ 297 (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \ 298 xmlParserInputGrow(ctxt->input, INPUT_CHUNK) 299 300 #define CURRENT ((int) (*ctxt->input->cur)) 301 302 #define SKIP_BLANKS htmlSkipBlankChars(ctxt) 303 304 /* Imported from XML */ 305 306 /* #define CUR (ctxt->token ? ctxt->token : (int) (*ctxt->input->cur)) */ 307 #define CUR ((int) (*ctxt->input->cur)) 308 #define NEXT xmlNextChar(ctxt) 309 310 #define RAW (ctxt->token ? -1 : (*ctxt->input->cur)) 311 312 313 #define NEXTL(l) do { \ 314 if (*(ctxt->input->cur) == '\n') { \ 315 ctxt->input->line++; ctxt->input->col = 1; \ 316 } else ctxt->input->col++; \ 317 ctxt->token = 0; ctxt->input->cur += l; \ 318 } while (0) 319 320 /************ 321 \ 322 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \ 323 if (*ctxt->input->cur == '&') xmlParserHandleReference(ctxt); 324 ************/ 325 326 #define CUR_CHAR(l) htmlCurrentChar(ctxt, &l) 327 #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l) 328 329 #define COPY_BUF(l,b,i,v) \ 330 if (l == 1) b[i++] = (xmlChar) v; \ 331 else i += xmlCopyChar(l,&b[i],v) 332 333 /** 334 * htmlFindEncoding: 335 * @the HTML parser context 336 * 337 * Ty to find and encoding in the current data available in the input 338 * buffer this is needed to try to switch to the proper encoding when 339 * one face a character error. 340 * That's an heuristic, since it's operating outside of parsing it could 341 * try to use a meta which had been commented out, that's the reason it 342 * should only be used in case of error, not as a default. 343 * 344 * Returns an encoding string or NULL if not found, the string need to 345 * be freed 346 */ 347 static xmlChar * 348 htmlFindEncoding(xmlParserCtxtPtr ctxt) { 349 const xmlChar *start, *cur, *end; 350 351 if ((ctxt == NULL) || (ctxt->input == NULL) || 352 (ctxt->input->encoding != NULL) || (ctxt->input->buf == NULL) || 353 (ctxt->input->buf->encoder != NULL)) 354 return(NULL); 355 if ((ctxt->input->cur == NULL) || (ctxt->input->end == NULL)) 356 return(NULL); 357 358 start = ctxt->input->cur; 359 end = ctxt->input->end; 360 /* we also expect the input buffer to be zero terminated */ 361 if (*end != 0) 362 return(NULL); 363 364 cur = xmlStrcasestr(start, BAD_CAST "HTTP-EQUIV"); 365 if (cur == NULL) 366 return(NULL); 367 cur = xmlStrcasestr(cur, BAD_CAST "CONTENT"); 368 if (cur == NULL) 369 return(NULL); 370 cur = xmlStrcasestr(cur, BAD_CAST "CHARSET="); 371 if (cur == NULL) 372 return(NULL); 373 cur += 8; 374 start = cur; 375 while (((*cur >= 'A') && (*cur <= 'Z')) || 376 ((*cur >= 'a') && (*cur <= 'z')) || 377 ((*cur >= '0') && (*cur <= '9')) || 378 (*cur == '-') || (*cur == '_') || (*cur == ':') || (*cur == '/')) 379 cur++; 380 if (cur == start) 381 return(NULL); 382 return(xmlStrndup(start, cur - start)); 383 } 384 385 /** 386 * htmlCurrentChar: 387 * @ctxt: the HTML parser context 388 * @len: pointer to the length of the char read 389 * 390 * The current char value, if using UTF-8 this may actually span multiple 391 * bytes in the input buffer. Implement the end of line normalization: 392 * 2.11 End-of-Line Handling 393 * If the encoding is unspecified, in the case we find an ISO-Latin-1 394 * char, then the encoding converter is plugged in automatically. 395 * 396 * Returns the current char value and its length 397 */ 398 399 static int 400 htmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) { 401 const unsigned char *cur; 402 unsigned char c; 403 unsigned int val; 404 405 if (ctxt->instate == XML_PARSER_EOF) 406 return(0); 407 408 if (ctxt->token != 0) { 409 *len = 0; 410 return(ctxt->token); 411 } 412 if (ctxt->charset != XML_CHAR_ENCODING_UTF8) { 413 xmlChar * guess; 414 xmlCharEncodingHandlerPtr handler; 415 416 /* 417 * Assume it's a fixed length encoding (1) with 418 * a compatible encoding for the ASCII set, since 419 * HTML constructs only use < 128 chars 420 */ 421 if ((int) *ctxt->input->cur < 0x80) { 422 *len = 1; 423 if ((*ctxt->input->cur == 0) && 424 (ctxt->input->cur < ctxt->input->end)) { 425 htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR, 426 "Char 0x%X out of allowed range\n", 0); 427 return(' '); 428 } 429 return((int) *ctxt->input->cur); 430 } 431 432 /* 433 * Humm this is bad, do an automatic flow conversion 434 */ 435 guess = htmlFindEncoding(ctxt); 436 if (guess == NULL) { 437 xmlSwitchEncoding(ctxt, XML_CHAR_ENCODING_8859_1); 438 } else { 439 if (ctxt->input->encoding != NULL) 440 xmlFree((xmlChar *) ctxt->input->encoding); 441 ctxt->input->encoding = guess; 442 handler = xmlFindCharEncodingHandler((const char *) guess); 443 if (handler != NULL) { 444 /* 445 * Don't use UTF-8 encoder which isn't required and 446 * can produce invalid UTF-8. 447 */ 448 if (!xmlStrEqual(BAD_CAST handler->name, BAD_CAST "UTF-8")) 449 xmlSwitchToEncoding(ctxt, handler); 450 } else { 451 htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING, 452 "Unsupported encoding %s", guess, NULL); 453 } 454 } 455 ctxt->charset = XML_CHAR_ENCODING_UTF8; 456 } 457 458 /* 459 * We are supposed to handle UTF8, check it's valid 460 * From rfc2044: encoding of the Unicode values on UTF-8: 461 * 462 * UCS-4 range (hex.) UTF-8 octet sequence (binary) 463 * 0000 0000-0000 007F 0xxxxxxx 464 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx 465 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx 466 * 467 * Check for the 0x110000 limit too 468 */ 469 cur = ctxt->input->cur; 470 c = *cur; 471 if (c & 0x80) { 472 if ((c & 0x40) == 0) 473 goto encoding_error; 474 if (cur[1] == 0) { 475 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 476 cur = ctxt->input->cur; 477 } 478 if ((cur[1] & 0xc0) != 0x80) 479 goto encoding_error; 480 if ((c & 0xe0) == 0xe0) { 481 482 if (cur[2] == 0) { 483 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 484 cur = ctxt->input->cur; 485 } 486 if ((cur[2] & 0xc0) != 0x80) 487 goto encoding_error; 488 if ((c & 0xf0) == 0xf0) { 489 if (cur[3] == 0) { 490 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 491 cur = ctxt->input->cur; 492 } 493 if (((c & 0xf8) != 0xf0) || 494 ((cur[3] & 0xc0) != 0x80)) 495 goto encoding_error; 496 /* 4-byte code */ 497 *len = 4; 498 val = (cur[0] & 0x7) << 18; 499 val |= (cur[1] & 0x3f) << 12; 500 val |= (cur[2] & 0x3f) << 6; 501 val |= cur[3] & 0x3f; 502 if (val < 0x10000) 503 goto encoding_error; 504 } else { 505 /* 3-byte code */ 506 *len = 3; 507 val = (cur[0] & 0xf) << 12; 508 val |= (cur[1] & 0x3f) << 6; 509 val |= cur[2] & 0x3f; 510 if (val < 0x800) 511 goto encoding_error; 512 } 513 } else { 514 /* 2-byte code */ 515 *len = 2; 516 val = (cur[0] & 0x1f) << 6; 517 val |= cur[1] & 0x3f; 518 if (val < 0x80) 519 goto encoding_error; 520 } 521 if (!IS_CHAR(val)) { 522 htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR, 523 "Char 0x%X out of allowed range\n", val); 524 } 525 return(val); 526 } else { 527 if ((*ctxt->input->cur == 0) && 528 (ctxt->input->cur < ctxt->input->end)) { 529 htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR, 530 "Char 0x%X out of allowed range\n", 0); 531 *len = 1; 532 return(' '); 533 } 534 /* 1-byte code */ 535 *len = 1; 536 return((int) *ctxt->input->cur); 537 } 538 539 encoding_error: 540 /* 541 * If we detect an UTF8 error that probably mean that the 542 * input encoding didn't get properly advertised in the 543 * declaration header. Report the error and switch the encoding 544 * to ISO-Latin-1 (if you don't like this policy, just declare the 545 * encoding !) 546 */ 547 { 548 char buffer[150]; 549 550 if (ctxt->input->end - ctxt->input->cur >= 4) { 551 snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n", 552 ctxt->input->cur[0], ctxt->input->cur[1], 553 ctxt->input->cur[2], ctxt->input->cur[3]); 554 } else { 555 snprintf(buffer, 149, "Bytes: 0x%02X\n", ctxt->input->cur[0]); 556 } 557 htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING, 558 "Input is not proper UTF-8, indicate encoding !\n", 559 BAD_CAST buffer, NULL); 560 } 561 562 /* 563 * Don't switch encodings twice. Note that if there's an encoder, we 564 * shouldn't receive invalid UTF-8 anyway. 565 * 566 * Note that if ctxt->input->buf == NULL, switching encodings is 567 * impossible, see Gitlab issue #34. 568 */ 569 if ((ctxt->input->buf != NULL) && 570 (ctxt->input->buf->encoder == NULL)) 571 xmlSwitchEncoding(ctxt, XML_CHAR_ENCODING_8859_1); 572 *len = 1; 573 return((int) *ctxt->input->cur); 574 } 575 576 /** 577 * htmlSkipBlankChars: 578 * @ctxt: the HTML parser context 579 * 580 * skip all blanks character found at that point in the input streams. 581 * 582 * Returns the number of space chars skipped 583 */ 584 585 static int 586 htmlSkipBlankChars(xmlParserCtxtPtr ctxt) { 587 int res = 0; 588 589 while (IS_BLANK_CH(*(ctxt->input->cur))) { 590 if ((*ctxt->input->cur == 0) && 591 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) { 592 xmlPopInput(ctxt); 593 } else { 594 if (*(ctxt->input->cur) == '\n') { 595 ctxt->input->line++; ctxt->input->col = 1; 596 } else ctxt->input->col++; 597 ctxt->input->cur++; 598 if (*ctxt->input->cur == 0) 599 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 600 } 601 if (res < INT_MAX) 602 res++; 603 } 604 return(res); 605 } 606 607 608 609 /************************************************************************ 610 * * 611 * The list of HTML elements and their properties * 612 * * 613 ************************************************************************/ 614 615 /* 616 * Start Tag: 1 means the start tag can be omitted 617 * End Tag: 1 means the end tag can be omitted 618 * 2 means it's forbidden (empty elements) 619 * 3 means the tag is stylistic and should be closed easily 620 * Depr: this element is deprecated 621 * DTD: 1 means that this element is valid only in the Loose DTD 622 * 2 means that this element is valid only in the Frameset DTD 623 * 624 * Name,Start Tag,End Tag,Save End,Empty,Deprecated,DTD,inline,Description 625 , subElements , impliedsubelt , Attributes, userdata 626 */ 627 628 /* Definitions and a couple of vars for HTML Elements */ 629 630 #define FONTSTYLE "tt", "i", "b", "u", "s", "strike", "big", "small" 631 #define NB_FONTSTYLE 8 632 #define PHRASE "em", "strong", "dfn", "code", "samp", "kbd", "var", "cite", "abbr", "acronym" 633 #define NB_PHRASE 10 634 #define SPECIAL "a", "img", "applet", "embed", "object", "font", "basefont", "br", "script", "map", "q", "sub", "sup", "span", "bdo", "iframe" 635 #define NB_SPECIAL 16 636 #define INLINE FONTSTYLE, PHRASE, SPECIAL, FORMCTRL 637 #define NB_INLINE NB_PCDATA + NB_FONTSTYLE + NB_PHRASE + NB_SPECIAL + NB_FORMCTRL 638 #define BLOCK HEADING, LIST, "pre", "p", "dl", "div", "center", "noscript", "noframes", "blockquote", "form", "isindex", "hr", "table", "fieldset", "address" 639 #define NB_BLOCK NB_HEADING + NB_LIST + 14 640 #define FORMCTRL "input", "select", "textarea", "label", "button" 641 #define NB_FORMCTRL 5 642 #define PCDATA 643 #define NB_PCDATA 0 644 #define HEADING "h1", "h2", "h3", "h4", "h5", "h6" 645 #define NB_HEADING 6 646 #define LIST "ul", "ol", "dir", "menu" 647 #define NB_LIST 4 648 #define MODIFIER 649 #define NB_MODIFIER 0 650 #define FLOW BLOCK,INLINE 651 #define NB_FLOW NB_BLOCK + NB_INLINE 652 #define EMPTY NULL 653 654 655 static const char* const html_flow[] = { FLOW, NULL } ; 656 static const char* const html_inline[] = { INLINE, NULL } ; 657 658 /* placeholders: elts with content but no subelements */ 659 static const char* const html_pcdata[] = { NULL } ; 660 #define html_cdata html_pcdata 661 662 663 /* ... and for HTML Attributes */ 664 665 #define COREATTRS "id", "class", "style", "title" 666 #define NB_COREATTRS 4 667 #define I18N "lang", "dir" 668 #define NB_I18N 2 669 #define EVENTS "onclick", "ondblclick", "onmousedown", "onmouseup", "onmouseover", "onmouseout", "onkeypress", "onkeydown", "onkeyup" 670 #define NB_EVENTS 9 671 #define ATTRS COREATTRS,I18N,EVENTS 672 #define NB_ATTRS NB_NB_COREATTRS + NB_I18N + NB_EVENTS 673 #define CELLHALIGN "align", "char", "charoff" 674 #define NB_CELLHALIGN 3 675 #define CELLVALIGN "valign" 676 #define NB_CELLVALIGN 1 677 678 static const char* const html_attrs[] = { ATTRS, NULL } ; 679 static const char* const core_i18n_attrs[] = { COREATTRS, I18N, NULL } ; 680 static const char* const core_attrs[] = { COREATTRS, NULL } ; 681 static const char* const i18n_attrs[] = { I18N, NULL } ; 682 683 684 /* Other declarations that should go inline ... */ 685 static const char* const a_attrs[] = { ATTRS, "charset", "type", "name", 686 "href", "hreflang", "rel", "rev", "accesskey", "shape", "coords", 687 "tabindex", "onfocus", "onblur", NULL } ; 688 static const char* const target_attr[] = { "target", NULL } ; 689 static const char* const rows_cols_attr[] = { "rows", "cols", NULL } ; 690 static const char* const alt_attr[] = { "alt", NULL } ; 691 static const char* const src_alt_attrs[] = { "src", "alt", NULL } ; 692 static const char* const href_attrs[] = { "href", NULL } ; 693 static const char* const clear_attrs[] = { "clear", NULL } ; 694 static const char* const inline_p[] = { INLINE, "p", NULL } ; 695 696 static const char* const flow_param[] = { FLOW, "param", NULL } ; 697 static const char* const applet_attrs[] = { COREATTRS , "codebase", 698 "archive", "alt", "name", "height", "width", "align", 699 "hspace", "vspace", NULL } ; 700 static const char* const area_attrs[] = { "shape", "coords", "href", "nohref", 701 "tabindex", "accesskey", "onfocus", "onblur", NULL } ; 702 static const char* const basefont_attrs[] = 703 { "id", "size", "color", "face", NULL } ; 704 static const char* const quote_attrs[] = { ATTRS, "cite", NULL } ; 705 static const char* const body_contents[] = { FLOW, "ins", "del", NULL } ; 706 static const char* const body_attrs[] = { ATTRS, "onload", "onunload", NULL } ; 707 static const char* const body_depr[] = { "background", "bgcolor", "text", 708 "link", "vlink", "alink", NULL } ; 709 static const char* const button_attrs[] = { ATTRS, "name", "value", "type", 710 "disabled", "tabindex", "accesskey", "onfocus", "onblur", NULL } ; 711 712 713 static const char* const col_attrs[] = { ATTRS, "span", "width", CELLHALIGN, CELLVALIGN, NULL } ; 714 static const char* const col_elt[] = { "col", NULL } ; 715 static const char* const edit_attrs[] = { ATTRS, "datetime", "cite", NULL } ; 716 static const char* const compact_attrs[] = { ATTRS, "compact", NULL } ; 717 static const char* const dl_contents[] = { "dt", "dd", NULL } ; 718 static const char* const compact_attr[] = { "compact", NULL } ; 719 static const char* const label_attr[] = { "label", NULL } ; 720 static const char* const fieldset_contents[] = { FLOW, "legend" } ; 721 static const char* const font_attrs[] = { COREATTRS, I18N, "size", "color", "face" , NULL } ; 722 static const char* const form_contents[] = { HEADING, LIST, INLINE, "pre", "p", "div", "center", "noscript", "noframes", "blockquote", "isindex", "hr", "table", "fieldset", "address", NULL } ; 723 static const char* const form_attrs[] = { ATTRS, "method", "enctype", "accept", "name", "onsubmit", "onreset", "accept-charset", NULL } ; 724 static const char* const frame_attrs[] = { COREATTRS, "longdesc", "name", "src", "frameborder", "marginwidth", "marginheight", "noresize", "scrolling" , NULL } ; 725 static const char* const frameset_attrs[] = { COREATTRS, "rows", "cols", "onload", "onunload", NULL } ; 726 static const char* const frameset_contents[] = { "frameset", "frame", "noframes", NULL } ; 727 static const char* const head_attrs[] = { I18N, "profile", NULL } ; 728 static const char* const head_contents[] = { "title", "isindex", "base", "script", "style", "meta", "link", "object", NULL } ; 729 static const char* const hr_depr[] = { "align", "noshade", "size", "width", NULL } ; 730 static const char* const version_attr[] = { "version", NULL } ; 731 static const char* const html_content[] = { "head", "body", "frameset", NULL } ; 732 static const char* const iframe_attrs[] = { COREATTRS, "longdesc", "name", "src", "frameborder", "marginwidth", "marginheight", "scrolling", "align", "height", "width", NULL } ; 733 static const char* const img_attrs[] = { ATTRS, "longdesc", "name", "height", "width", "usemap", "ismap", NULL } ; 734 static const char* const embed_attrs[] = { COREATTRS, "align", "alt", "border", "code", "codebase", "frameborder", "height", "hidden", "hspace", "name", "palette", "pluginspace", "pluginurl", "src", "type", "units", "vspace", "width", NULL } ; 735 static const char* const input_attrs[] = { ATTRS, "type", "name", "value", "checked", "disabled", "readonly", "size", "maxlength", "src", "alt", "usemap", "ismap", "tabindex", "accesskey", "onfocus", "onblur", "onselect", "onchange", "accept", NULL } ; 736 static const char* const prompt_attrs[] = { COREATTRS, I18N, "prompt", NULL } ; 737 static const char* const label_attrs[] = { ATTRS, "for", "accesskey", "onfocus", "onblur", NULL } ; 738 static const char* const legend_attrs[] = { ATTRS, "accesskey", NULL } ; 739 static const char* const align_attr[] = { "align", NULL } ; 740 static const char* const link_attrs[] = { ATTRS, "charset", "href", "hreflang", "type", "rel", "rev", "media", NULL } ; 741 static const char* const map_contents[] = { BLOCK, "area", NULL } ; 742 static const char* const name_attr[] = { "name", NULL } ; 743 static const char* const action_attr[] = { "action", NULL } ; 744 static const char* const blockli_elt[] = { BLOCK, "li", NULL } ; 745 static const char* const meta_attrs[] = { I18N, "http-equiv", "name", "scheme", "charset", NULL } ; 746 static const char* const content_attr[] = { "content", NULL } ; 747 static const char* const type_attr[] = { "type", NULL } ; 748 static const char* const noframes_content[] = { "body", FLOW MODIFIER, NULL } ; 749 static const char* const object_contents[] = { FLOW, "param", NULL } ; 750 static const char* const object_attrs[] = { ATTRS, "declare", "classid", "codebase", "data", "type", "codetype", "archive", "standby", "height", "width", "usemap", "name", "tabindex", NULL } ; 751 static const char* const object_depr[] = { "align", "border", "hspace", "vspace", NULL } ; 752 static const char* const ol_attrs[] = { "type", "compact", "start", NULL} ; 753 static const char* const option_elt[] = { "option", NULL } ; 754 static const char* const optgroup_attrs[] = { ATTRS, "disabled", NULL } ; 755 static const char* const option_attrs[] = { ATTRS, "disabled", "label", "selected", "value", NULL } ; 756 static const char* const param_attrs[] = { "id", "value", "valuetype", "type", NULL } ; 757 static const char* const width_attr[] = { "width", NULL } ; 758 static const char* const pre_content[] = { PHRASE, "tt", "i", "b", "u", "s", "strike", "a", "br", "script", "map", "q", "span", "bdo", "iframe", NULL } ; 759 static const char* const script_attrs[] = { "charset", "src", "defer", "event", "for", NULL } ; 760 static const char* const language_attr[] = { "language", NULL } ; 761 static const char* const select_content[] = { "optgroup", "option", NULL } ; 762 static const char* const select_attrs[] = { ATTRS, "name", "size", "multiple", "disabled", "tabindex", "onfocus", "onblur", "onchange", NULL } ; 763 static const char* const style_attrs[] = { I18N, "media", "title", NULL } ; 764 static const char* const table_attrs[] = { ATTRS, "summary", "width", "border", "frame", "rules", "cellspacing", "cellpadding", "datapagesize", NULL } ; 765 static const char* const table_depr[] = { "align", "bgcolor", NULL } ; 766 static const char* const table_contents[] = { "caption", "col", "colgroup", "thead", "tfoot", "tbody", "tr", NULL} ; 767 static const char* const tr_elt[] = { "tr", NULL } ; 768 static const char* const talign_attrs[] = { ATTRS, CELLHALIGN, CELLVALIGN, NULL} ; 769 static const char* const th_td_depr[] = { "nowrap", "bgcolor", "width", "height", NULL } ; 770 static const char* const th_td_attr[] = { ATTRS, "abbr", "axis", "headers", "scope", "rowspan", "colspan", CELLHALIGN, CELLVALIGN, NULL } ; 771 static const char* const textarea_attrs[] = { ATTRS, "name", "disabled", "readonly", "tabindex", "accesskey", "onfocus", "onblur", "onselect", "onchange", NULL } ; 772 static const char* const tr_contents[] = { "th", "td", NULL } ; 773 static const char* const bgcolor_attr[] = { "bgcolor", NULL } ; 774 static const char* const li_elt[] = { "li", NULL } ; 775 static const char* const ul_depr[] = { "type", "compact", NULL} ; 776 static const char* const dir_attr[] = { "dir", NULL} ; 777 778 #define DECL (const char**) 779 780 static const htmlElemDesc 781 html40ElementTable[] = { 782 { "a", 0, 0, 0, 0, 0, 0, 1, "anchor ", 783 DECL html_inline , NULL , DECL a_attrs , DECL target_attr, NULL 784 }, 785 { "abbr", 0, 0, 0, 0, 0, 0, 1, "abbreviated form", 786 DECL html_inline , NULL , DECL html_attrs, NULL, NULL 787 }, 788 { "acronym", 0, 0, 0, 0, 0, 0, 1, "", 789 DECL html_inline , NULL , DECL html_attrs, NULL, NULL 790 }, 791 { "address", 0, 0, 0, 0, 0, 0, 0, "information on author ", 792 DECL inline_p , NULL , DECL html_attrs, NULL, NULL 793 }, 794 { "applet", 0, 0, 0, 0, 1, 1, 2, "java applet ", 795 DECL flow_param , NULL , NULL , DECL applet_attrs, NULL 796 }, 797 { "area", 0, 2, 2, 1, 0, 0, 0, "client-side image map area ", 798 EMPTY , NULL , DECL area_attrs , DECL target_attr, DECL alt_attr 799 }, 800 { "b", 0, 3, 0, 0, 0, 0, 1, "bold text style", 801 DECL html_inline , NULL , DECL html_attrs, NULL, NULL 802 }, 803 { "base", 0, 2, 2, 1, 0, 0, 0, "document base uri ", 804 EMPTY , NULL , NULL , DECL target_attr, DECL href_attrs 805 }, 806 { "basefont", 0, 2, 2, 1, 1, 1, 1, "base font size " , 807 EMPTY , NULL , NULL, DECL basefont_attrs, NULL 808 }, 809 { "bdo", 0, 0, 0, 0, 0, 0, 1, "i18n bidi over-ride ", 810 DECL html_inline , NULL , DECL core_i18n_attrs, NULL, DECL dir_attr 811 }, 812 { "big", 0, 3, 0, 0, 0, 0, 1, "large text style", 813 DECL html_inline , NULL , DECL html_attrs, NULL, NULL 814 }, 815 { "blockquote", 0, 0, 0, 0, 0, 0, 0, "long quotation ", 816 DECL html_flow , NULL , DECL quote_attrs , NULL, NULL 817 }, 818 { "body", 1, 1, 0, 0, 0, 0, 0, "document body ", 819 DECL body_contents , "div" , DECL body_attrs, DECL body_depr, NULL 820 }, 821 { "br", 0, 2, 2, 1, 0, 0, 1, "forced line break ", 822 EMPTY , NULL , DECL core_attrs, DECL clear_attrs , NULL 823 }, 824 { "button", 0, 0, 0, 0, 0, 0, 2, "push button ", 825 DECL html_flow MODIFIER , NULL , DECL button_attrs, NULL, NULL 826 }, 827 { "caption", 0, 0, 0, 0, 0, 0, 0, "table caption ", 828 DECL html_inline , NULL , DECL html_attrs, NULL, NULL 829 }, 830 { "center", 0, 3, 0, 0, 1, 1, 0, "shorthand for div align=center ", 831 DECL html_flow , NULL , NULL, DECL html_attrs, NULL 832 }, 833 { "cite", 0, 0, 0, 0, 0, 0, 1, "citation", 834 DECL html_inline , NULL , DECL html_attrs, NULL, NULL 835 }, 836 { "code", 0, 0, 0, 0, 0, 0, 1, "computer code fragment", 837 DECL html_inline , NULL , DECL html_attrs, NULL, NULL 838 }, 839 { "col", 0, 2, 2, 1, 0, 0, 0, "table column ", 840 EMPTY , NULL , DECL col_attrs , NULL, NULL 841 }, 842 { "colgroup", 0, 1, 0, 0, 0, 0, 0, "table column group ", 843 DECL col_elt , "col" , DECL col_attrs , NULL, NULL 844 }, 845 { "dd", 0, 1, 0, 0, 0, 0, 0, "definition description ", 846 DECL html_flow , NULL , DECL html_attrs, NULL, NULL 847 }, 848 { "del", 0, 0, 0, 0, 0, 0, 2, "deleted text ", 849 DECL html_flow , NULL , DECL edit_attrs , NULL, NULL 850 }, 851 { "dfn", 0, 0, 0, 0, 0, 0, 1, "instance definition", 852 DECL html_inline , NULL , DECL html_attrs, NULL, NULL 853 }, 854 { "dir", 0, 0, 0, 0, 1, 1, 0, "directory list", 855 DECL blockli_elt, "li" , NULL, DECL compact_attrs, NULL 856 }, 857 { "div", 0, 0, 0, 0, 0, 0, 0, "generic language/style container", 858 DECL html_flow, NULL, DECL html_attrs, DECL align_attr, NULL 859 }, 860 { "dl", 0, 0, 0, 0, 0, 0, 0, "definition list ", 861 DECL dl_contents , "dd" , DECL html_attrs, DECL compact_attr, NULL 862 }, 863 { "dt", 0, 1, 0, 0, 0, 0, 0, "definition term ", 864 DECL html_inline, NULL, DECL html_attrs, NULL, NULL 865 }, 866 { "em", 0, 3, 0, 0, 0, 0, 1, "emphasis", 867 DECL html_inline, NULL, DECL html_attrs, NULL, NULL 868 }, 869 { "embed", 0, 1, 0, 0, 1, 1, 1, "generic embedded object ", 870 EMPTY, NULL, DECL embed_attrs, NULL, NULL 871 }, 872 { "fieldset", 0, 0, 0, 0, 0, 0, 0, "form control group ", 873 DECL fieldset_contents , NULL, DECL html_attrs, NULL, NULL 874 }, 875 { "font", 0, 3, 0, 0, 1, 1, 1, "local change to font ", 876 DECL html_inline, NULL, NULL, DECL font_attrs, NULL 877 }, 878 { "form", 0, 0, 0, 0, 0, 0, 0, "interactive form ", 879 DECL form_contents, "fieldset", DECL form_attrs , DECL target_attr, DECL action_attr 880 }, 881 { "frame", 0, 2, 2, 1, 0, 2, 0, "subwindow " , 882 EMPTY, NULL, NULL, DECL frame_attrs, NULL 883 }, 884 { "frameset", 0, 0, 0, 0, 0, 2, 0, "window subdivision" , 885 DECL frameset_contents, "noframes" , NULL , DECL frameset_attrs, NULL 886 }, 887 { "h1", 0, 0, 0, 0, 0, 0, 0, "heading ", 888 DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL 889 }, 890 { "h2", 0, 0, 0, 0, 0, 0, 0, "heading ", 891 DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL 892 }, 893 { "h3", 0, 0, 0, 0, 0, 0, 0, "heading ", 894 DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL 895 }, 896 { "h4", 0, 0, 0, 0, 0, 0, 0, "heading ", 897 DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL 898 }, 899 { "h5", 0, 0, 0, 0, 0, 0, 0, "heading ", 900 DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL 901 }, 902 { "h6", 0, 0, 0, 0, 0, 0, 0, "heading ", 903 DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL 904 }, 905 { "head", 1, 1, 0, 0, 0, 0, 0, "document head ", 906 DECL head_contents, NULL, DECL head_attrs, NULL, NULL 907 }, 908 { "hr", 0, 2, 2, 1, 0, 0, 0, "horizontal rule " , 909 EMPTY, NULL, DECL html_attrs, DECL hr_depr, NULL 910 }, 911 { "html", 1, 1, 0, 0, 0, 0, 0, "document root element ", 912 DECL html_content , NULL , DECL i18n_attrs, DECL version_attr, NULL 913 }, 914 { "i", 0, 3, 0, 0, 0, 0, 1, "italic text style", 915 DECL html_inline, NULL, DECL html_attrs, NULL, NULL 916 }, 917 { "iframe", 0, 0, 0, 0, 0, 1, 2, "inline subwindow ", 918 DECL html_flow, NULL, NULL, DECL iframe_attrs, NULL 919 }, 920 { "img", 0, 2, 2, 1, 0, 0, 1, "embedded image ", 921 EMPTY, NULL, DECL img_attrs, DECL align_attr, DECL src_alt_attrs 922 }, 923 { "input", 0, 2, 2, 1, 0, 0, 1, "form control ", 924 EMPTY, NULL, DECL input_attrs , DECL align_attr, NULL 925 }, 926 { "ins", 0, 0, 0, 0, 0, 0, 2, "inserted text", 927 DECL html_flow, NULL, DECL edit_attrs, NULL, NULL 928 }, 929 { "isindex", 0, 2, 2, 1, 1, 1, 0, "single line prompt ", 930 EMPTY, NULL, NULL, DECL prompt_attrs, NULL 931 }, 932 { "kbd", 0, 0, 0, 0, 0, 0, 1, "text to be entered by the user", 933 DECL html_inline, NULL, DECL html_attrs, NULL, NULL 934 }, 935 { "label", 0, 0, 0, 0, 0, 0, 1, "form field label text ", 936 DECL html_inline MODIFIER, NULL, DECL label_attrs , NULL, NULL 937 }, 938 { "legend", 0, 0, 0, 0, 0, 0, 0, "fieldset legend ", 939 DECL html_inline, NULL, DECL legend_attrs , DECL align_attr, NULL 940 }, 941 { "li", 0, 1, 1, 0, 0, 0, 0, "list item ", 942 DECL html_flow, NULL, DECL html_attrs, NULL, NULL 943 }, 944 { "link", 0, 2, 2, 1, 0, 0, 0, "a media-independent link ", 945 EMPTY, NULL, DECL link_attrs, DECL target_attr, NULL 946 }, 947 { "map", 0, 0, 0, 0, 0, 0, 2, "client-side image map ", 948 DECL map_contents , NULL, DECL html_attrs , NULL, DECL name_attr 949 }, 950 { "menu", 0, 0, 0, 0, 1, 1, 0, "menu list ", 951 DECL blockli_elt , NULL, NULL, DECL compact_attrs, NULL 952 }, 953 { "meta", 0, 2, 2, 1, 0, 0, 0, "generic metainformation ", 954 EMPTY, NULL, DECL meta_attrs , NULL , DECL content_attr 955 }, 956 { "noframes", 0, 0, 0, 0, 0, 2, 0, "alternate content container for non frame-based rendering ", 957 DECL noframes_content, "body" , DECL html_attrs, NULL, NULL 958 }, 959 { "noscript", 0, 0, 0, 0, 0, 0, 0, "alternate content container for non script-based rendering ", 960 DECL html_flow, "div", DECL html_attrs, NULL, NULL 961 }, 962 { "object", 0, 0, 0, 0, 0, 0, 2, "generic embedded object ", 963 DECL object_contents , "div" , DECL object_attrs, DECL object_depr, NULL 964 }, 965 { "ol", 0, 0, 0, 0, 0, 0, 0, "ordered list ", 966 DECL li_elt , "li" , DECL html_attrs, DECL ol_attrs, NULL 967 }, 968 { "optgroup", 0, 0, 0, 0, 0, 0, 0, "option group ", 969 DECL option_elt , "option", DECL optgroup_attrs, NULL, DECL label_attr 970 }, 971 { "option", 0, 1, 0, 0, 0, 0, 0, "selectable choice " , 972 DECL html_pcdata, NULL, DECL option_attrs, NULL, NULL 973 }, 974 { "p", 0, 1, 0, 0, 0, 0, 0, "paragraph ", 975 DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL 976 }, 977 { "param", 0, 2, 2, 1, 0, 0, 0, "named property value ", 978 EMPTY, NULL, DECL param_attrs, NULL, DECL name_attr 979 }, 980 { "pre", 0, 0, 0, 0, 0, 0, 0, "preformatted text ", 981 DECL pre_content, NULL, DECL html_attrs, DECL width_attr, NULL 982 }, 983 { "q", 0, 0, 0, 0, 0, 0, 1, "short inline quotation ", 984 DECL html_inline, NULL, DECL quote_attrs, NULL, NULL 985 }, 986 { "s", 0, 3, 0, 0, 1, 1, 1, "strike-through text style", 987 DECL html_inline, NULL, NULL, DECL html_attrs, NULL 988 }, 989 { "samp", 0, 0, 0, 0, 0, 0, 1, "sample program output, scripts, etc.", 990 DECL html_inline, NULL, DECL html_attrs, NULL, NULL 991 }, 992 { "script", 0, 0, 0, 0, 0, 0, 2, "script statements ", 993 DECL html_cdata, NULL, DECL script_attrs, DECL language_attr, DECL type_attr 994 }, 995 { "select", 0, 0, 0, 0, 0, 0, 1, "option selector ", 996 DECL select_content, NULL, DECL select_attrs, NULL, NULL 997 }, 998 { "small", 0, 3, 0, 0, 0, 0, 1, "small text style", 999 DECL html_inline, NULL, DECL html_attrs, NULL, NULL 1000 }, 1001 { "span", 0, 0, 0, 0, 0, 0, 1, "generic language/style container ", 1002 DECL html_inline, NULL, DECL html_attrs, NULL, NULL 1003 }, 1004 { "strike", 0, 3, 0, 0, 1, 1, 1, "strike-through text", 1005 DECL html_inline, NULL, NULL, DECL html_attrs, NULL 1006 }, 1007 { "strong", 0, 3, 0, 0, 0, 0, 1, "strong emphasis", 1008 DECL html_inline, NULL, DECL html_attrs, NULL, NULL 1009 }, 1010 { "style", 0, 0, 0, 0, 0, 0, 0, "style info ", 1011 DECL html_cdata, NULL, DECL style_attrs, NULL, DECL type_attr 1012 }, 1013 { "sub", 0, 3, 0, 0, 0, 0, 1, "subscript", 1014 DECL html_inline, NULL, DECL html_attrs, NULL, NULL 1015 }, 1016 { "sup", 0, 3, 0, 0, 0, 0, 1, "superscript ", 1017 DECL html_inline, NULL, DECL html_attrs, NULL, NULL 1018 }, 1019 { "table", 0, 0, 0, 0, 0, 0, 0, "", 1020 DECL table_contents , "tr" , DECL table_attrs , DECL table_depr, NULL 1021 }, 1022 { "tbody", 1, 0, 0, 0, 0, 0, 0, "table body ", 1023 DECL tr_elt , "tr" , DECL talign_attrs, NULL, NULL 1024 }, 1025 { "td", 0, 0, 0, 0, 0, 0, 0, "table data cell", 1026 DECL html_flow, NULL, DECL th_td_attr, DECL th_td_depr, NULL 1027 }, 1028 { "textarea", 0, 0, 0, 0, 0, 0, 1, "multi-line text field ", 1029 DECL html_pcdata, NULL, DECL textarea_attrs, NULL, DECL rows_cols_attr 1030 }, 1031 { "tfoot", 0, 1, 0, 0, 0, 0, 0, "table footer ", 1032 DECL tr_elt , "tr" , DECL talign_attrs, NULL, NULL 1033 }, 1034 { "th", 0, 1, 0, 0, 0, 0, 0, "table header cell", 1035 DECL html_flow, NULL, DECL th_td_attr, DECL th_td_depr, NULL 1036 }, 1037 { "thead", 0, 1, 0, 0, 0, 0, 0, "table header ", 1038 DECL tr_elt , "tr" , DECL talign_attrs, NULL, NULL 1039 }, 1040 { "title", 0, 0, 0, 0, 0, 0, 0, "document title ", 1041 DECL html_pcdata, NULL, DECL i18n_attrs, NULL, NULL 1042 }, 1043 { "tr", 0, 0, 0, 0, 0, 0, 0, "table row ", 1044 DECL tr_contents , "td" , DECL talign_attrs, DECL bgcolor_attr, NULL 1045 }, 1046 { "tt", 0, 3, 0, 0, 0, 0, 1, "teletype or monospaced text style", 1047 DECL html_inline, NULL, DECL html_attrs, NULL, NULL 1048 }, 1049 { "u", 0, 3, 0, 0, 1, 1, 1, "underlined text style", 1050 DECL html_inline, NULL, NULL, DECL html_attrs, NULL 1051 }, 1052 { "ul", 0, 0, 0, 0, 0, 0, 0, "unordered list ", 1053 DECL li_elt , "li" , DECL html_attrs, DECL ul_depr, NULL 1054 }, 1055 { "var", 0, 0, 0, 0, 0, 0, 1, "instance of a variable or program argument", 1056 DECL html_inline, NULL, DECL html_attrs, NULL, NULL 1057 } 1058 }; 1059 1060 typedef struct { 1061 const char *oldTag; 1062 const char *newTag; 1063 } htmlStartCloseEntry; 1064 1065 /* 1066 * start tags that imply the end of current element 1067 */ 1068 static const htmlStartCloseEntry htmlStartClose[] = { 1069 { "a", "a" }, 1070 { "a", "fieldset" }, 1071 { "a", "table" }, 1072 { "a", "td" }, 1073 { "a", "th" }, 1074 { "address", "dd" }, 1075 { "address", "dl" }, 1076 { "address", "dt" }, 1077 { "address", "form" }, 1078 { "address", "li" }, 1079 { "address", "ul" }, 1080 { "b", "center" }, 1081 { "b", "p" }, 1082 { "b", "td" }, 1083 { "b", "th" }, 1084 { "big", "p" }, 1085 { "caption", "col" }, 1086 { "caption", "colgroup" }, 1087 { "caption", "tbody" }, 1088 { "caption", "tfoot" }, 1089 { "caption", "thead" }, 1090 { "caption", "tr" }, 1091 { "col", "col" }, 1092 { "col", "colgroup" }, 1093 { "col", "tbody" }, 1094 { "col", "tfoot" }, 1095 { "col", "thead" }, 1096 { "col", "tr" }, 1097 { "colgroup", "colgroup" }, 1098 { "colgroup", "tbody" }, 1099 { "colgroup", "tfoot" }, 1100 { "colgroup", "thead" }, 1101 { "colgroup", "tr" }, 1102 { "dd", "dt" }, 1103 { "dir", "dd" }, 1104 { "dir", "dl" }, 1105 { "dir", "dt" }, 1106 { "dir", "form" }, 1107 { "dir", "ul" }, 1108 { "dl", "form" }, 1109 { "dl", "li" }, 1110 { "dt", "dd" }, 1111 { "dt", "dl" }, 1112 { "font", "center" }, 1113 { "font", "td" }, 1114 { "font", "th" }, 1115 { "form", "form" }, 1116 { "h1", "fieldset" }, 1117 { "h1", "form" }, 1118 { "h1", "li" }, 1119 { "h1", "p" }, 1120 { "h1", "table" }, 1121 { "h2", "fieldset" }, 1122 { "h2", "form" }, 1123 { "h2", "li" }, 1124 { "h2", "p" }, 1125 { "h2", "table" }, 1126 { "h3", "fieldset" }, 1127 { "h3", "form" }, 1128 { "h3", "li" }, 1129 { "h3", "p" }, 1130 { "h3", "table" }, 1131 { "h4", "fieldset" }, 1132 { "h4", "form" }, 1133 { "h4", "li" }, 1134 { "h4", "p" }, 1135 { "h4", "table" }, 1136 { "h5", "fieldset" }, 1137 { "h5", "form" }, 1138 { "h5", "li" }, 1139 { "h5", "p" }, 1140 { "h5", "table" }, 1141 { "h6", "fieldset" }, 1142 { "h6", "form" }, 1143 { "h6", "li" }, 1144 { "h6", "p" }, 1145 { "h6", "table" }, 1146 { "head", "a" }, 1147 { "head", "abbr" }, 1148 { "head", "acronym" }, 1149 { "head", "address" }, 1150 { "head", "b" }, 1151 { "head", "bdo" }, 1152 { "head", "big" }, 1153 { "head", "blockquote" }, 1154 { "head", "body" }, 1155 { "head", "br" }, 1156 { "head", "center" }, 1157 { "head", "cite" }, 1158 { "head", "code" }, 1159 { "head", "dd" }, 1160 { "head", "dfn" }, 1161 { "head", "dir" }, 1162 { "head", "div" }, 1163 { "head", "dl" }, 1164 { "head", "dt" }, 1165 { "head", "em" }, 1166 { "head", "fieldset" }, 1167 { "head", "font" }, 1168 { "head", "form" }, 1169 { "head", "frameset" }, 1170 { "head", "h1" }, 1171 { "head", "h2" }, 1172 { "head", "h3" }, 1173 { "head", "h4" }, 1174 { "head", "h5" }, 1175 { "head", "h6" }, 1176 { "head", "hr" }, 1177 { "head", "i" }, 1178 { "head", "iframe" }, 1179 { "head", "img" }, 1180 { "head", "kbd" }, 1181 { "head", "li" }, 1182 { "head", "listing" }, 1183 { "head", "map" }, 1184 { "head", "menu" }, 1185 { "head", "ol" }, 1186 { "head", "p" }, 1187 { "head", "pre" }, 1188 { "head", "q" }, 1189 { "head", "s" }, 1190 { "head", "samp" }, 1191 { "head", "small" }, 1192 { "head", "span" }, 1193 { "head", "strike" }, 1194 { "head", "strong" }, 1195 { "head", "sub" }, 1196 { "head", "sup" }, 1197 { "head", "table" }, 1198 { "head", "tt" }, 1199 { "head", "u" }, 1200 { "head", "ul" }, 1201 { "head", "var" }, 1202 { "head", "xmp" }, 1203 { "hr", "form" }, 1204 { "i", "center" }, 1205 { "i", "p" }, 1206 { "i", "td" }, 1207 { "i", "th" }, 1208 { "legend", "fieldset" }, 1209 { "li", "li" }, 1210 { "link", "body" }, 1211 { "link", "frameset" }, 1212 { "listing", "dd" }, 1213 { "listing", "dl" }, 1214 { "listing", "dt" }, 1215 { "listing", "fieldset" }, 1216 { "listing", "form" }, 1217 { "listing", "li" }, 1218 { "listing", "table" }, 1219 { "listing", "ul" }, 1220 { "menu", "dd" }, 1221 { "menu", "dl" }, 1222 { "menu", "dt" }, 1223 { "menu", "form" }, 1224 { "menu", "ul" }, 1225 { "ol", "form" }, 1226 { "ol", "ul" }, 1227 { "option", "optgroup" }, 1228 { "option", "option" }, 1229 { "p", "address" }, 1230 { "p", "blockquote" }, 1231 { "p", "body" }, 1232 { "p", "caption" }, 1233 { "p", "center" }, 1234 { "p", "col" }, 1235 { "p", "colgroup" }, 1236 { "p", "dd" }, 1237 { "p", "dir" }, 1238 { "p", "div" }, 1239 { "p", "dl" }, 1240 { "p", "dt" }, 1241 { "p", "fieldset" }, 1242 { "p", "form" }, 1243 { "p", "frameset" }, 1244 { "p", "h1" }, 1245 { "p", "h2" }, 1246 { "p", "h3" }, 1247 { "p", "h4" }, 1248 { "p", "h5" }, 1249 { "p", "h6" }, 1250 { "p", "head" }, 1251 { "p", "hr" }, 1252 { "p", "li" }, 1253 { "p", "listing" }, 1254 { "p", "menu" }, 1255 { "p", "ol" }, 1256 { "p", "p" }, 1257 { "p", "pre" }, 1258 { "p", "table" }, 1259 { "p", "tbody" }, 1260 { "p", "td" }, 1261 { "p", "tfoot" }, 1262 { "p", "th" }, 1263 { "p", "title" }, 1264 { "p", "tr" }, 1265 { "p", "ul" }, 1266 { "p", "xmp" }, 1267 { "pre", "dd" }, 1268 { "pre", "dl" }, 1269 { "pre", "dt" }, 1270 { "pre", "fieldset" }, 1271 { "pre", "form" }, 1272 { "pre", "li" }, 1273 { "pre", "table" }, 1274 { "pre", "ul" }, 1275 { "s", "p" }, 1276 { "script", "noscript" }, 1277 { "small", "p" }, 1278 { "span", "td" }, 1279 { "span", "th" }, 1280 { "strike", "p" }, 1281 { "style", "body" }, 1282 { "style", "frameset" }, 1283 { "tbody", "tbody" }, 1284 { "tbody", "tfoot" }, 1285 { "td", "tbody" }, 1286 { "td", "td" }, 1287 { "td", "tfoot" }, 1288 { "td", "th" }, 1289 { "td", "tr" }, 1290 { "tfoot", "tbody" }, 1291 { "th", "tbody" }, 1292 { "th", "td" }, 1293 { "th", "tfoot" }, 1294 { "th", "th" }, 1295 { "th", "tr" }, 1296 { "thead", "tbody" }, 1297 { "thead", "tfoot" }, 1298 { "title", "body" }, 1299 { "title", "frameset" }, 1300 { "tr", "tbody" }, 1301 { "tr", "tfoot" }, 1302 { "tr", "tr" }, 1303 { "tt", "p" }, 1304 { "u", "p" }, 1305 { "u", "td" }, 1306 { "u", "th" }, 1307 { "ul", "address" }, 1308 { "ul", "form" }, 1309 { "ul", "menu" }, 1310 { "ul", "ol" }, 1311 { "ul", "pre" }, 1312 { "xmp", "dd" }, 1313 { "xmp", "dl" }, 1314 { "xmp", "dt" }, 1315 { "xmp", "fieldset" }, 1316 { "xmp", "form" }, 1317 { "xmp", "li" }, 1318 { "xmp", "table" }, 1319 { "xmp", "ul" } 1320 }; 1321 1322 /* 1323 * The list of HTML elements which are supposed not to have 1324 * CDATA content and where a p element will be implied 1325 * 1326 * TODO: extend that list by reading the HTML SGML DTD on 1327 * implied paragraph 1328 */ 1329 static const char *const htmlNoContentElements[] = { 1330 "html", 1331 "head", 1332 NULL 1333 }; 1334 1335 /* 1336 * The list of HTML attributes which are of content %Script; 1337 * NOTE: when adding ones, check htmlIsScriptAttribute() since 1338 * it assumes the name starts with 'on' 1339 */ 1340 static const char *const htmlScriptAttributes[] = { 1341 "onclick", 1342 "ondblclick", 1343 "onmousedown", 1344 "onmouseup", 1345 "onmouseover", 1346 "onmousemove", 1347 "onmouseout", 1348 "onkeypress", 1349 "onkeydown", 1350 "onkeyup", 1351 "onload", 1352 "onunload", 1353 "onfocus", 1354 "onblur", 1355 "onsubmit", 1356 "onreset", 1357 "onchange", 1358 "onselect" 1359 }; 1360 1361 /* 1362 * This table is used by the htmlparser to know what to do with 1363 * broken html pages. By assigning different priorities to different 1364 * elements the parser can decide how to handle extra endtags. 1365 * Endtags are only allowed to close elements with lower or equal 1366 * priority. 1367 */ 1368 1369 typedef struct { 1370 const char *name; 1371 int priority; 1372 } elementPriority; 1373 1374 static const elementPriority htmlEndPriority[] = { 1375 {"div", 150}, 1376 {"td", 160}, 1377 {"th", 160}, 1378 {"tr", 170}, 1379 {"thead", 180}, 1380 {"tbody", 180}, 1381 {"tfoot", 180}, 1382 {"table", 190}, 1383 {"head", 200}, 1384 {"body", 200}, 1385 {"html", 220}, 1386 {NULL, 100} /* Default priority */ 1387 }; 1388 1389 /************************************************************************ 1390 * * 1391 * functions to handle HTML specific data * 1392 * * 1393 ************************************************************************/ 1394 1395 /** 1396 * htmlInitAutoClose: 1397 * 1398 * DEPRECATED: This function will be made private. Call xmlInitParser to 1399 * initialize the library. 1400 * 1401 * This is a no-op now. 1402 */ 1403 void 1404 htmlInitAutoClose(void) { 1405 } 1406 1407 static int 1408 htmlCompareTags(const void *key, const void *member) { 1409 const xmlChar *tag = (const xmlChar *) key; 1410 const htmlElemDesc *desc = (const htmlElemDesc *) member; 1411 1412 return(xmlStrcasecmp(tag, BAD_CAST desc->name)); 1413 } 1414 1415 /** 1416 * htmlTagLookup: 1417 * @tag: The tag name in lowercase 1418 * 1419 * Lookup the HTML tag in the ElementTable 1420 * 1421 * Returns the related htmlElemDescPtr or NULL if not found. 1422 */ 1423 const htmlElemDesc * 1424 htmlTagLookup(const xmlChar *tag) { 1425 if (tag == NULL) 1426 return(NULL); 1427 1428 return((const htmlElemDesc *) bsearch(tag, html40ElementTable, 1429 sizeof(html40ElementTable) / sizeof(htmlElemDesc), 1430 sizeof(htmlElemDesc), htmlCompareTags)); 1431 } 1432 1433 /** 1434 * htmlGetEndPriority: 1435 * @name: The name of the element to look up the priority for. 1436 * 1437 * Return value: The "endtag" priority. 1438 **/ 1439 static int 1440 htmlGetEndPriority (const xmlChar *name) { 1441 int i = 0; 1442 1443 while ((htmlEndPriority[i].name != NULL) && 1444 (!xmlStrEqual((const xmlChar *)htmlEndPriority[i].name, name))) 1445 i++; 1446 1447 return(htmlEndPriority[i].priority); 1448 } 1449 1450 1451 static int 1452 htmlCompareStartClose(const void *vkey, const void *member) { 1453 const htmlStartCloseEntry *key = (const htmlStartCloseEntry *) vkey; 1454 const htmlStartCloseEntry *entry = (const htmlStartCloseEntry *) member; 1455 int ret; 1456 1457 ret = strcmp(key->oldTag, entry->oldTag); 1458 if (ret == 0) 1459 ret = strcmp(key->newTag, entry->newTag); 1460 1461 return(ret); 1462 } 1463 1464 /** 1465 * htmlCheckAutoClose: 1466 * @newtag: The new tag name 1467 * @oldtag: The old tag name 1468 * 1469 * Checks whether the new tag is one of the registered valid tags for 1470 * closing old. 1471 * 1472 * Returns 0 if no, 1 if yes. 1473 */ 1474 static int 1475 htmlCheckAutoClose(const xmlChar * newtag, const xmlChar * oldtag) 1476 { 1477 htmlStartCloseEntry key; 1478 void *res; 1479 1480 key.oldTag = (const char *) oldtag; 1481 key.newTag = (const char *) newtag; 1482 res = bsearch(&key, htmlStartClose, 1483 sizeof(htmlStartClose) / sizeof(htmlStartCloseEntry), 1484 sizeof(htmlStartCloseEntry), htmlCompareStartClose); 1485 return(res != NULL); 1486 } 1487 1488 /** 1489 * htmlAutoCloseOnClose: 1490 * @ctxt: an HTML parser context 1491 * @newtag: The new tag name 1492 * @force: force the tag closure 1493 * 1494 * The HTML DTD allows an ending tag to implicitly close other tags. 1495 */ 1496 static void 1497 htmlAutoCloseOnClose(htmlParserCtxtPtr ctxt, const xmlChar * newtag) 1498 { 1499 const htmlElemDesc *info; 1500 int i, priority; 1501 1502 priority = htmlGetEndPriority(newtag); 1503 1504 for (i = (ctxt->nameNr - 1); i >= 0; i--) { 1505 1506 if (xmlStrEqual(newtag, ctxt->nameTab[i])) 1507 break; 1508 /* 1509 * A misplaced endtag can only close elements with lower 1510 * or equal priority, so if we find an element with higher 1511 * priority before we find an element with 1512 * matching name, we just ignore this endtag 1513 */ 1514 if (htmlGetEndPriority(ctxt->nameTab[i]) > priority) 1515 return; 1516 } 1517 if (i < 0) 1518 return; 1519 1520 while (!xmlStrEqual(newtag, ctxt->name)) { 1521 info = htmlTagLookup(ctxt->name); 1522 if ((info != NULL) && (info->endTag == 3)) { 1523 htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH, 1524 "Opening and ending tag mismatch: %s and %s\n", 1525 newtag, ctxt->name); 1526 } 1527 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL)) 1528 ctxt->sax->endElement(ctxt->userData, ctxt->name); 1529 htmlnamePop(ctxt); 1530 } 1531 } 1532 1533 /** 1534 * htmlAutoCloseOnEnd: 1535 * @ctxt: an HTML parser context 1536 * 1537 * Close all remaining tags at the end of the stream 1538 */ 1539 static void 1540 htmlAutoCloseOnEnd(htmlParserCtxtPtr ctxt) 1541 { 1542 int i; 1543 1544 if (ctxt->nameNr == 0) 1545 return; 1546 for (i = (ctxt->nameNr - 1); i >= 0; i--) { 1547 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL)) 1548 ctxt->sax->endElement(ctxt->userData, ctxt->name); 1549 htmlnamePop(ctxt); 1550 } 1551 } 1552 1553 /** 1554 * htmlAutoClose: 1555 * @ctxt: an HTML parser context 1556 * @newtag: The new tag name or NULL 1557 * 1558 * The HTML DTD allows a tag to implicitly close other tags. 1559 * The list is kept in htmlStartClose array. This function is 1560 * called when a new tag has been detected and generates the 1561 * appropriates closes if possible/needed. 1562 * If newtag is NULL this mean we are at the end of the resource 1563 * and we should check 1564 */ 1565 static void 1566 htmlAutoClose(htmlParserCtxtPtr ctxt, const xmlChar * newtag) 1567 { 1568 while ((newtag != NULL) && (ctxt->name != NULL) && 1569 (htmlCheckAutoClose(newtag, ctxt->name))) { 1570 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL)) 1571 ctxt->sax->endElement(ctxt->userData, ctxt->name); 1572 htmlnamePop(ctxt); 1573 } 1574 if (newtag == NULL) { 1575 htmlAutoCloseOnEnd(ctxt); 1576 return; 1577 } 1578 while ((newtag == NULL) && (ctxt->name != NULL) && 1579 ((xmlStrEqual(ctxt->name, BAD_CAST "head")) || 1580 (xmlStrEqual(ctxt->name, BAD_CAST "body")) || 1581 (xmlStrEqual(ctxt->name, BAD_CAST "html")))) { 1582 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL)) 1583 ctxt->sax->endElement(ctxt->userData, ctxt->name); 1584 htmlnamePop(ctxt); 1585 } 1586 } 1587 1588 /** 1589 * htmlAutoCloseTag: 1590 * @doc: the HTML document 1591 * @name: The tag name 1592 * @elem: the HTML element 1593 * 1594 * The HTML DTD allows a tag to implicitly close other tags. 1595 * The list is kept in htmlStartClose array. This function checks 1596 * if the element or one of it's children would autoclose the 1597 * given tag. 1598 * 1599 * Returns 1 if autoclose, 0 otherwise 1600 */ 1601 int 1602 htmlAutoCloseTag(htmlDocPtr doc, const xmlChar *name, htmlNodePtr elem) { 1603 htmlNodePtr child; 1604 1605 if (elem == NULL) return(1); 1606 if (xmlStrEqual(name, elem->name)) return(0); 1607 if (htmlCheckAutoClose(elem->name, name)) return(1); 1608 child = elem->children; 1609 while (child != NULL) { 1610 if (htmlAutoCloseTag(doc, name, child)) return(1); 1611 child = child->next; 1612 } 1613 return(0); 1614 } 1615 1616 /** 1617 * htmlIsAutoClosed: 1618 * @doc: the HTML document 1619 * @elem: the HTML element 1620 * 1621 * The HTML DTD allows a tag to implicitly close other tags. 1622 * The list is kept in htmlStartClose array. This function checks 1623 * if a tag is autoclosed by one of it's child 1624 * 1625 * Returns 1 if autoclosed, 0 otherwise 1626 */ 1627 int 1628 htmlIsAutoClosed(htmlDocPtr doc, htmlNodePtr elem) { 1629 htmlNodePtr child; 1630 1631 if (elem == NULL) return(1); 1632 child = elem->children; 1633 while (child != NULL) { 1634 if (htmlAutoCloseTag(doc, elem->name, child)) return(1); 1635 child = child->next; 1636 } 1637 return(0); 1638 } 1639 1640 /** 1641 * htmlCheckImplied: 1642 * @ctxt: an HTML parser context 1643 * @newtag: The new tag name 1644 * 1645 * The HTML DTD allows a tag to exists only implicitly 1646 * called when a new tag has been detected and generates the 1647 * appropriates implicit tags if missing 1648 */ 1649 static void 1650 htmlCheckImplied(htmlParserCtxtPtr ctxt, const xmlChar *newtag) { 1651 int i; 1652 1653 if (ctxt->options & HTML_PARSE_NOIMPLIED) 1654 return; 1655 if (!htmlOmittedDefaultValue) 1656 return; 1657 if (xmlStrEqual(newtag, BAD_CAST"html")) 1658 return; 1659 if (ctxt->nameNr <= 0) { 1660 htmlnamePush(ctxt, BAD_CAST"html"); 1661 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL)) 1662 ctxt->sax->startElement(ctxt->userData, BAD_CAST"html", NULL); 1663 } 1664 if ((xmlStrEqual(newtag, BAD_CAST"body")) || (xmlStrEqual(newtag, BAD_CAST"head"))) 1665 return; 1666 if ((ctxt->nameNr <= 1) && 1667 ((xmlStrEqual(newtag, BAD_CAST"script")) || 1668 (xmlStrEqual(newtag, BAD_CAST"style")) || 1669 (xmlStrEqual(newtag, BAD_CAST"meta")) || 1670 (xmlStrEqual(newtag, BAD_CAST"link")) || 1671 (xmlStrEqual(newtag, BAD_CAST"title")) || 1672 (xmlStrEqual(newtag, BAD_CAST"base")))) { 1673 if (ctxt->html >= 3) { 1674 /* we already saw or generated an <head> before */ 1675 return; 1676 } 1677 /* 1678 * dropped OBJECT ... i you put it first BODY will be 1679 * assumed ! 1680 */ 1681 htmlnamePush(ctxt, BAD_CAST"head"); 1682 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL)) 1683 ctxt->sax->startElement(ctxt->userData, BAD_CAST"head", NULL); 1684 } else if ((!xmlStrEqual(newtag, BAD_CAST"noframes")) && 1685 (!xmlStrEqual(newtag, BAD_CAST"frame")) && 1686 (!xmlStrEqual(newtag, BAD_CAST"frameset"))) { 1687 if (ctxt->html >= 10) { 1688 /* we already saw or generated a <body> before */ 1689 return; 1690 } 1691 for (i = 0;i < ctxt->nameNr;i++) { 1692 if (xmlStrEqual(ctxt->nameTab[i], BAD_CAST"body")) { 1693 return; 1694 } 1695 if (xmlStrEqual(ctxt->nameTab[i], BAD_CAST"head")) { 1696 return; 1697 } 1698 } 1699 1700 htmlnamePush(ctxt, BAD_CAST"body"); 1701 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL)) 1702 ctxt->sax->startElement(ctxt->userData, BAD_CAST"body", NULL); 1703 } 1704 } 1705 1706 /** 1707 * htmlCheckParagraph 1708 * @ctxt: an HTML parser context 1709 * 1710 * Check whether a p element need to be implied before inserting 1711 * characters in the current element. 1712 * 1713 * Returns 1 if a paragraph has been inserted, 0 if not and -1 1714 * in case of error. 1715 */ 1716 1717 static int 1718 htmlCheckParagraph(htmlParserCtxtPtr ctxt) { 1719 const xmlChar *tag; 1720 int i; 1721 1722 if (ctxt == NULL) 1723 return(-1); 1724 tag = ctxt->name; 1725 if (tag == NULL) { 1726 htmlAutoClose(ctxt, BAD_CAST"p"); 1727 htmlCheckImplied(ctxt, BAD_CAST"p"); 1728 htmlnamePush(ctxt, BAD_CAST"p"); 1729 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL)) 1730 ctxt->sax->startElement(ctxt->userData, BAD_CAST"p", NULL); 1731 return(1); 1732 } 1733 if (!htmlOmittedDefaultValue) 1734 return(0); 1735 for (i = 0; htmlNoContentElements[i] != NULL; i++) { 1736 if (xmlStrEqual(tag, BAD_CAST htmlNoContentElements[i])) { 1737 htmlAutoClose(ctxt, BAD_CAST"p"); 1738 htmlCheckImplied(ctxt, BAD_CAST"p"); 1739 htmlnamePush(ctxt, BAD_CAST"p"); 1740 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL)) 1741 ctxt->sax->startElement(ctxt->userData, BAD_CAST"p", NULL); 1742 return(1); 1743 } 1744 } 1745 return(0); 1746 } 1747 1748 /** 1749 * htmlIsScriptAttribute: 1750 * @name: an attribute name 1751 * 1752 * Check if an attribute is of content type Script 1753 * 1754 * Returns 1 is the attribute is a script 0 otherwise 1755 */ 1756 int 1757 htmlIsScriptAttribute(const xmlChar *name) { 1758 unsigned int i; 1759 1760 if (name == NULL) 1761 return(0); 1762 /* 1763 * all script attributes start with 'on' 1764 */ 1765 if ((name[0] != 'o') || (name[1] != 'n')) 1766 return(0); 1767 for (i = 0; 1768 i < sizeof(htmlScriptAttributes)/sizeof(htmlScriptAttributes[0]); 1769 i++) { 1770 if (xmlStrEqual(name, (const xmlChar *) htmlScriptAttributes[i])) 1771 return(1); 1772 } 1773 return(0); 1774 } 1775 1776 /************************************************************************ 1777 * * 1778 * The list of HTML predefined entities * 1779 * * 1780 ************************************************************************/ 1781 1782 1783 static const htmlEntityDesc html40EntitiesTable[] = { 1784 /* 1785 * the 4 absolute ones, plus apostrophe. 1786 */ 1787 { 34, "quot", "quotation mark = APL quote, U+0022 ISOnum" }, 1788 { 38, "amp", "ampersand, U+0026 ISOnum" }, 1789 { 39, "apos", "single quote" }, 1790 { 60, "lt", "less-than sign, U+003C ISOnum" }, 1791 { 62, "gt", "greater-than sign, U+003E ISOnum" }, 1792 1793 /* 1794 * A bunch still in the 128-255 range 1795 * Replacing them depend really on the charset used. 1796 */ 1797 { 160, "nbsp", "no-break space = non-breaking space, U+00A0 ISOnum" }, 1798 { 161, "iexcl","inverted exclamation mark, U+00A1 ISOnum" }, 1799 { 162, "cent", "cent sign, U+00A2 ISOnum" }, 1800 { 163, "pound","pound sign, U+00A3 ISOnum" }, 1801 { 164, "curren","currency sign, U+00A4 ISOnum" }, 1802 { 165, "yen", "yen sign = yuan sign, U+00A5 ISOnum" }, 1803 { 166, "brvbar","broken bar = broken vertical bar, U+00A6 ISOnum" }, 1804 { 167, "sect", "section sign, U+00A7 ISOnum" }, 1805 { 168, "uml", "diaeresis = spacing diaeresis, U+00A8 ISOdia" }, 1806 { 169, "copy", "copyright sign, U+00A9 ISOnum" }, 1807 { 170, "ordf", "feminine ordinal indicator, U+00AA ISOnum" }, 1808 { 171, "laquo","left-pointing double angle quotation mark = left pointing guillemet, U+00AB ISOnum" }, 1809 { 172, "not", "not sign, U+00AC ISOnum" }, 1810 { 173, "shy", "soft hyphen = discretionary hyphen, U+00AD ISOnum" }, 1811 { 174, "reg", "registered sign = registered trade mark sign, U+00AE ISOnum" }, 1812 { 175, "macr", "macron = spacing macron = overline = APL overbar, U+00AF ISOdia" }, 1813 { 176, "deg", "degree sign, U+00B0 ISOnum" }, 1814 { 177, "plusmn","plus-minus sign = plus-or-minus sign, U+00B1 ISOnum" }, 1815 { 178, "sup2", "superscript two = superscript digit two = squared, U+00B2 ISOnum" }, 1816 { 179, "sup3", "superscript three = superscript digit three = cubed, U+00B3 ISOnum" }, 1817 { 180, "acute","acute accent = spacing acute, U+00B4 ISOdia" }, 1818 { 181, "micro","micro sign, U+00B5 ISOnum" }, 1819 { 182, "para", "pilcrow sign = paragraph sign, U+00B6 ISOnum" }, 1820 { 183, "middot","middle dot = Georgian comma Greek middle dot, U+00B7 ISOnum" }, 1821 { 184, "cedil","cedilla = spacing cedilla, U+00B8 ISOdia" }, 1822 { 185, "sup1", "superscript one = superscript digit one, U+00B9 ISOnum" }, 1823 { 186, "ordm", "masculine ordinal indicator, U+00BA ISOnum" }, 1824 { 187, "raquo","right-pointing double angle quotation mark right pointing guillemet, U+00BB ISOnum" }, 1825 { 188, "frac14","vulgar fraction one quarter = fraction one quarter, U+00BC ISOnum" }, 1826 { 189, "frac12","vulgar fraction one half = fraction one half, U+00BD ISOnum" }, 1827 { 190, "frac34","vulgar fraction three quarters = fraction three quarters, U+00BE ISOnum" }, 1828 { 191, "iquest","inverted question mark = turned question mark, U+00BF ISOnum" }, 1829 { 192, "Agrave","latin capital letter A with grave = latin capital letter A grave, U+00C0 ISOlat1" }, 1830 { 193, "Aacute","latin capital letter A with acute, U+00C1 ISOlat1" }, 1831 { 194, "Acirc","latin capital letter A with circumflex, U+00C2 ISOlat1" }, 1832 { 195, "Atilde","latin capital letter A with tilde, U+00C3 ISOlat1" }, 1833 { 196, "Auml", "latin capital letter A with diaeresis, U+00C4 ISOlat1" }, 1834 { 197, "Aring","latin capital letter A with ring above = latin capital letter A ring, U+00C5 ISOlat1" }, 1835 { 198, "AElig","latin capital letter AE = latin capital ligature AE, U+00C6 ISOlat1" }, 1836 { 199, "Ccedil","latin capital letter C with cedilla, U+00C7 ISOlat1" }, 1837 { 200, "Egrave","latin capital letter E with grave, U+00C8 ISOlat1" }, 1838 { 201, "Eacute","latin capital letter E with acute, U+00C9 ISOlat1" }, 1839 { 202, "Ecirc","latin capital letter E with circumflex, U+00CA ISOlat1" }, 1840 { 203, "Euml", "latin capital letter E with diaeresis, U+00CB ISOlat1" }, 1841 { 204, "Igrave","latin capital letter I with grave, U+00CC ISOlat1" }, 1842 { 205, "Iacute","latin capital letter I with acute, U+00CD ISOlat1" }, 1843 { 206, "Icirc","latin capital letter I with circumflex, U+00CE ISOlat1" }, 1844 { 207, "Iuml", "latin capital letter I with diaeresis, U+00CF ISOlat1" }, 1845 { 208, "ETH", "latin capital letter ETH, U+00D0 ISOlat1" }, 1846 { 209, "Ntilde","latin capital letter N with tilde, U+00D1 ISOlat1" }, 1847 { 210, "Ograve","latin capital letter O with grave, U+00D2 ISOlat1" }, 1848 { 211, "Oacute","latin capital letter O with acute, U+00D3 ISOlat1" }, 1849 { 212, "Ocirc","latin capital letter O with circumflex, U+00D4 ISOlat1" }, 1850 { 213, "Otilde","latin capital letter O with tilde, U+00D5 ISOlat1" }, 1851 { 214, "Ouml", "latin capital letter O with diaeresis, U+00D6 ISOlat1" }, 1852 { 215, "times","multiplication sign, U+00D7 ISOnum" }, 1853 { 216, "Oslash","latin capital letter O with stroke latin capital letter O slash, U+00D8 ISOlat1" }, 1854 { 217, "Ugrave","latin capital letter U with grave, U+00D9 ISOlat1" }, 1855 { 218, "Uacute","latin capital letter U with acute, U+00DA ISOlat1" }, 1856 { 219, "Ucirc","latin capital letter U with circumflex, U+00DB ISOlat1" }, 1857 { 220, "Uuml", "latin capital letter U with diaeresis, U+00DC ISOlat1" }, 1858 { 221, "Yacute","latin capital letter Y with acute, U+00DD ISOlat1" }, 1859 { 222, "THORN","latin capital letter THORN, U+00DE ISOlat1" }, 1860 { 223, "szlig","latin small letter sharp s = ess-zed, U+00DF ISOlat1" }, 1861 { 224, "agrave","latin small letter a with grave = latin small letter a grave, U+00E0 ISOlat1" }, 1862 { 225, "aacute","latin small letter a with acute, U+00E1 ISOlat1" }, 1863 { 226, "acirc","latin small letter a with circumflex, U+00E2 ISOlat1" }, 1864 { 227, "atilde","latin small letter a with tilde, U+00E3 ISOlat1" }, 1865 { 228, "auml", "latin small letter a with diaeresis, U+00E4 ISOlat1" }, 1866 { 229, "aring","latin small letter a with ring above = latin small letter a ring, U+00E5 ISOlat1" }, 1867 { 230, "aelig","latin small letter ae = latin small ligature ae, U+00E6 ISOlat1" }, 1868 { 231, "ccedil","latin small letter c with cedilla, U+00E7 ISOlat1" }, 1869 { 232, "egrave","latin small letter e with grave, U+00E8 ISOlat1" }, 1870 { 233, "eacute","latin small letter e with acute, U+00E9 ISOlat1" }, 1871 { 234, "ecirc","latin small letter e with circumflex, U+00EA ISOlat1" }, 1872 { 235, "euml", "latin small letter e with diaeresis, U+00EB ISOlat1" }, 1873 { 236, "igrave","latin small letter i with grave, U+00EC ISOlat1" }, 1874 { 237, "iacute","latin small letter i with acute, U+00ED ISOlat1" }, 1875 { 238, "icirc","latin small letter i with circumflex, U+00EE ISOlat1" }, 1876 { 239, "iuml", "latin small letter i with diaeresis, U+00EF ISOlat1" }, 1877 { 240, "eth", "latin small letter eth, U+00F0 ISOlat1" }, 1878 { 241, "ntilde","latin small letter n with tilde, U+00F1 ISOlat1" }, 1879 { 242, "ograve","latin small letter o with grave, U+00F2 ISOlat1" }, 1880 { 243, "oacute","latin small letter o with acute, U+00F3 ISOlat1" }, 1881 { 244, "ocirc","latin small letter o with circumflex, U+00F4 ISOlat1" }, 1882 { 245, "otilde","latin small letter o with tilde, U+00F5 ISOlat1" }, 1883 { 246, "ouml", "latin small letter o with diaeresis, U+00F6 ISOlat1" }, 1884 { 247, "divide","division sign, U+00F7 ISOnum" }, 1885 { 248, "oslash","latin small letter o with stroke, = latin small letter o slash, U+00F8 ISOlat1" }, 1886 { 249, "ugrave","latin small letter u with grave, U+00F9 ISOlat1" }, 1887 { 250, "uacute","latin small letter u with acute, U+00FA ISOlat1" }, 1888 { 251, "ucirc","latin small letter u with circumflex, U+00FB ISOlat1" }, 1889 { 252, "uuml", "latin small letter u with diaeresis, U+00FC ISOlat1" }, 1890 { 253, "yacute","latin small letter y with acute, U+00FD ISOlat1" }, 1891 { 254, "thorn","latin small letter thorn with, U+00FE ISOlat1" }, 1892 { 255, "yuml", "latin small letter y with diaeresis, U+00FF ISOlat1" }, 1893 1894 { 338, "OElig","latin capital ligature OE, U+0152 ISOlat2" }, 1895 { 339, "oelig","latin small ligature oe, U+0153 ISOlat2" }, 1896 { 352, "Scaron","latin capital letter S with caron, U+0160 ISOlat2" }, 1897 { 353, "scaron","latin small letter s with caron, U+0161 ISOlat2" }, 1898 { 376, "Yuml", "latin capital letter Y with diaeresis, U+0178 ISOlat2" }, 1899 1900 /* 1901 * Anything below should really be kept as entities references 1902 */ 1903 { 402, "fnof", "latin small f with hook = function = florin, U+0192 ISOtech" }, 1904 1905 { 710, "circ", "modifier letter circumflex accent, U+02C6 ISOpub" }, 1906 { 732, "tilde","small tilde, U+02DC ISOdia" }, 1907 1908 { 913, "Alpha","greek capital letter alpha, U+0391" }, 1909 { 914, "Beta", "greek capital letter beta, U+0392" }, 1910 { 915, "Gamma","greek capital letter gamma, U+0393 ISOgrk3" }, 1911 { 916, "Delta","greek capital letter delta, U+0394 ISOgrk3" }, 1912 { 917, "Epsilon","greek capital letter epsilon, U+0395" }, 1913 { 918, "Zeta", "greek capital letter zeta, U+0396" }, 1914 { 919, "Eta", "greek capital letter eta, U+0397" }, 1915 { 920, "Theta","greek capital letter theta, U+0398 ISOgrk3" }, 1916 { 921, "Iota", "greek capital letter iota, U+0399" }, 1917 { 922, "Kappa","greek capital letter kappa, U+039A" }, 1918 { 923, "Lambda", "greek capital letter lambda, U+039B ISOgrk3" }, 1919 { 924, "Mu", "greek capital letter mu, U+039C" }, 1920 { 925, "Nu", "greek capital letter nu, U+039D" }, 1921 { 926, "Xi", "greek capital letter xi, U+039E ISOgrk3" }, 1922 { 927, "Omicron","greek capital letter omicron, U+039F" }, 1923 { 928, "Pi", "greek capital letter pi, U+03A0 ISOgrk3" }, 1924 { 929, "Rho", "greek capital letter rho, U+03A1" }, 1925 { 931, "Sigma","greek capital letter sigma, U+03A3 ISOgrk3" }, 1926 { 932, "Tau", "greek capital letter tau, U+03A4" }, 1927 { 933, "Upsilon","greek capital letter upsilon, U+03A5 ISOgrk3" }, 1928 { 934, "Phi", "greek capital letter phi, U+03A6 ISOgrk3" }, 1929 { 935, "Chi", "greek capital letter chi, U+03A7" }, 1930 { 936, "Psi", "greek capital letter psi, U+03A8 ISOgrk3" }, 1931 { 937, "Omega","greek capital letter omega, U+03A9 ISOgrk3" }, 1932 1933 { 945, "alpha","greek small letter alpha, U+03B1 ISOgrk3" }, 1934 { 946, "beta", "greek small letter beta, U+03B2 ISOgrk3" }, 1935 { 947, "gamma","greek small letter gamma, U+03B3 ISOgrk3" }, 1936 { 948, "delta","greek small letter delta, U+03B4 ISOgrk3" }, 1937 { 949, "epsilon","greek small letter epsilon, U+03B5 ISOgrk3" }, 1938 { 950, "zeta", "greek small letter zeta, U+03B6 ISOgrk3" }, 1939 { 951, "eta", "greek small letter eta, U+03B7 ISOgrk3" }, 1940 { 952, "theta","greek small letter theta, U+03B8 ISOgrk3" }, 1941 { 953, "iota", "greek small letter iota, U+03B9 ISOgrk3" }, 1942 { 954, "kappa","greek small letter kappa, U+03BA ISOgrk3" }, 1943 { 955, "lambda","greek small letter lambda, U+03BB ISOgrk3" }, 1944 { 956, "mu", "greek small letter mu, U+03BC ISOgrk3" }, 1945 { 957, "nu", "greek small letter nu, U+03BD ISOgrk3" }, 1946 { 958, "xi", "greek small letter xi, U+03BE ISOgrk3" }, 1947 { 959, "omicron","greek small letter omicron, U+03BF NEW" }, 1948 { 960, "pi", "greek small letter pi, U+03C0 ISOgrk3" }, 1949 { 961, "rho", "greek small letter rho, U+03C1 ISOgrk3" }, 1950 { 962, "sigmaf","greek small letter final sigma, U+03C2 ISOgrk3" }, 1951 { 963, "sigma","greek small letter sigma, U+03C3 ISOgrk3" }, 1952 { 964, "tau", "greek small letter tau, U+03C4 ISOgrk3" }, 1953 { 965, "upsilon","greek small letter upsilon, U+03C5 ISOgrk3" }, 1954 { 966, "phi", "greek small letter phi, U+03C6 ISOgrk3" }, 1955 { 967, "chi", "greek small letter chi, U+03C7 ISOgrk3" }, 1956 { 968, "psi", "greek small letter psi, U+03C8 ISOgrk3" }, 1957 { 969, "omega","greek small letter omega, U+03C9 ISOgrk3" }, 1958 { 977, "thetasym","greek small letter theta symbol, U+03D1 NEW" }, 1959 { 978, "upsih","greek upsilon with hook symbol, U+03D2 NEW" }, 1960 { 982, "piv", "greek pi symbol, U+03D6 ISOgrk3" }, 1961 1962 { 8194, "ensp", "en space, U+2002 ISOpub" }, 1963 { 8195, "emsp", "em space, U+2003 ISOpub" }, 1964 { 8201, "thinsp","thin space, U+2009 ISOpub" }, 1965 { 8204, "zwnj", "zero width non-joiner, U+200C NEW RFC 2070" }, 1966 { 8205, "zwj", "zero width joiner, U+200D NEW RFC 2070" }, 1967 { 8206, "lrm", "left-to-right mark, U+200E NEW RFC 2070" }, 1968 { 8207, "rlm", "right-to-left mark, U+200F NEW RFC 2070" }, 1969 { 8211, "ndash","en dash, U+2013 ISOpub" }, 1970 { 8212, "mdash","em dash, U+2014 ISOpub" }, 1971 { 8216, "lsquo","left single quotation mark, U+2018 ISOnum" }, 1972 { 8217, "rsquo","right single quotation mark, U+2019 ISOnum" }, 1973 { 8218, "sbquo","single low-9 quotation mark, U+201A NEW" }, 1974 { 8220, "ldquo","left double quotation mark, U+201C ISOnum" }, 1975 { 8221, "rdquo","right double quotation mark, U+201D ISOnum" }, 1976 { 8222, "bdquo","double low-9 quotation mark, U+201E NEW" }, 1977 { 8224, "dagger","dagger, U+2020 ISOpub" }, 1978 { 8225, "Dagger","double dagger, U+2021 ISOpub" }, 1979 1980 { 8226, "bull", "bullet = black small circle, U+2022 ISOpub" }, 1981 { 8230, "hellip","horizontal ellipsis = three dot leader, U+2026 ISOpub" }, 1982 1983 { 8240, "permil","per mille sign, U+2030 ISOtech" }, 1984 1985 { 8242, "prime","prime = minutes = feet, U+2032 ISOtech" }, 1986 { 8243, "Prime","double prime = seconds = inches, U+2033 ISOtech" }, 1987 1988 { 8249, "lsaquo","single left-pointing angle quotation mark, U+2039 ISO proposed" }, 1989 { 8250, "rsaquo","single right-pointing angle quotation mark, U+203A ISO proposed" }, 1990 1991 { 8254, "oline","overline = spacing overscore, U+203E NEW" }, 1992 { 8260, "frasl","fraction slash, U+2044 NEW" }, 1993 1994 { 8364, "euro", "euro sign, U+20AC NEW" }, 1995 1996 { 8465, "image","blackletter capital I = imaginary part, U+2111 ISOamso" }, 1997 { 8472, "weierp","script capital P = power set = Weierstrass p, U+2118 ISOamso" }, 1998 { 8476, "real", "blackletter capital R = real part symbol, U+211C ISOamso" }, 1999 { 8482, "trade","trade mark sign, U+2122 ISOnum" }, 2000 { 8501, "alefsym","alef symbol = first transfinite cardinal, U+2135 NEW" }, 2001 { 8592, "larr", "leftwards arrow, U+2190 ISOnum" }, 2002 { 8593, "uarr", "upwards arrow, U+2191 ISOnum" }, 2003 { 8594, "rarr", "rightwards arrow, U+2192 ISOnum" }, 2004 { 8595, "darr", "downwards arrow, U+2193 ISOnum" }, 2005 { 8596, "harr", "left right arrow, U+2194 ISOamsa" }, 2006 { 8629, "crarr","downwards arrow with corner leftwards = carriage return, U+21B5 NEW" }, 2007 { 8656, "lArr", "leftwards double arrow, U+21D0 ISOtech" }, 2008 { 8657, "uArr", "upwards double arrow, U+21D1 ISOamsa" }, 2009 { 8658, "rArr", "rightwards double arrow, U+21D2 ISOtech" }, 2010 { 8659, "dArr", "downwards double arrow, U+21D3 ISOamsa" }, 2011 { 8660, "hArr", "left right double arrow, U+21D4 ISOamsa" }, 2012 2013 { 8704, "forall","for all, U+2200 ISOtech" }, 2014 { 8706, "part", "partial differential, U+2202 ISOtech" }, 2015 { 8707, "exist","there exists, U+2203 ISOtech" }, 2016 { 8709, "empty","empty set = null set = diameter, U+2205 ISOamso" }, 2017 { 8711, "nabla","nabla = backward difference, U+2207 ISOtech" }, 2018 { 8712, "isin", "element of, U+2208 ISOtech" }, 2019 { 8713, "notin","not an element of, U+2209 ISOtech" }, 2020 { 8715, "ni", "contains as member, U+220B ISOtech" }, 2021 { 8719, "prod", "n-ary product = product sign, U+220F ISOamsb" }, 2022 { 8721, "sum", "n-ary summation, U+2211 ISOamsb" }, 2023 { 8722, "minus","minus sign, U+2212 ISOtech" }, 2024 { 8727, "lowast","asterisk operator, U+2217 ISOtech" }, 2025 { 8730, "radic","square root = radical sign, U+221A ISOtech" }, 2026 { 8733, "prop", "proportional to, U+221D ISOtech" }, 2027 { 8734, "infin","infinity, U+221E ISOtech" }, 2028 { 8736, "ang", "angle, U+2220 ISOamso" }, 2029 { 8743, "and", "logical and = wedge, U+2227 ISOtech" }, 2030 { 8744, "or", "logical or = vee, U+2228 ISOtech" }, 2031 { 8745, "cap", "intersection = cap, U+2229 ISOtech" }, 2032 { 8746, "cup", "union = cup, U+222A ISOtech" }, 2033 { 8747, "int", "integral, U+222B ISOtech" }, 2034 { 8756, "there4","therefore, U+2234 ISOtech" }, 2035 { 8764, "sim", "tilde operator = varies with = similar to, U+223C ISOtech" }, 2036 { 8773, "cong", "approximately equal to, U+2245 ISOtech" }, 2037 { 8776, "asymp","almost equal to = asymptotic to, U+2248 ISOamsr" }, 2038 { 8800, "ne", "not equal to, U+2260 ISOtech" }, 2039 { 8801, "equiv","identical to, U+2261 ISOtech" }, 2040 { 8804, "le", "less-than or equal to, U+2264 ISOtech" }, 2041 { 8805, "ge", "greater-than or equal to, U+2265 ISOtech" }, 2042 { 8834, "sub", "subset of, U+2282 ISOtech" }, 2043 { 8835, "sup", "superset of, U+2283 ISOtech" }, 2044 { 8836, "nsub", "not a subset of, U+2284 ISOamsn" }, 2045 { 8838, "sube", "subset of or equal to, U+2286 ISOtech" }, 2046 { 8839, "supe", "superset of or equal to, U+2287 ISOtech" }, 2047 { 8853, "oplus","circled plus = direct sum, U+2295 ISOamsb" }, 2048 { 8855, "otimes","circled times = vector product, U+2297 ISOamsb" }, 2049 { 8869, "perp", "up tack = orthogonal to = perpendicular, U+22A5 ISOtech" }, 2050 { 8901, "sdot", "dot operator, U+22C5 ISOamsb" }, 2051 { 8968, "lceil","left ceiling = apl upstile, U+2308 ISOamsc" }, 2052 { 8969, "rceil","right ceiling, U+2309 ISOamsc" }, 2053 { 8970, "lfloor","left floor = apl downstile, U+230A ISOamsc" }, 2054 { 8971, "rfloor","right floor, U+230B ISOamsc" }, 2055 { 9001, "lang", "left-pointing angle bracket = bra, U+2329 ISOtech" }, 2056 { 9002, "rang", "right-pointing angle bracket = ket, U+232A ISOtech" }, 2057 { 9674, "loz", "lozenge, U+25CA ISOpub" }, 2058 2059 { 9824, "spades","black spade suit, U+2660 ISOpub" }, 2060 { 9827, "clubs","black club suit = shamrock, U+2663 ISOpub" }, 2061 { 9829, "hearts","black heart suit = valentine, U+2665 ISOpub" }, 2062 { 9830, "diams","black diamond suit, U+2666 ISOpub" }, 2063 2064 }; 2065 2066 /************************************************************************ 2067 * * 2068 * Commodity functions to handle entities * 2069 * * 2070 ************************************************************************/ 2071 2072 /* 2073 * Macro used to grow the current buffer. 2074 */ 2075 #define growBuffer(buffer) { \ 2076 xmlChar *tmp; \ 2077 buffer##_size *= 2; \ 2078 tmp = (xmlChar *) xmlRealloc(buffer, buffer##_size * sizeof(xmlChar)); \ 2079 if (tmp == NULL) { \ 2080 htmlErrMemory(ctxt, "growing buffer\n"); \ 2081 xmlFree(buffer); \ 2082 return(NULL); \ 2083 } \ 2084 buffer = tmp; \ 2085 } 2086 2087 /** 2088 * htmlEntityLookup: 2089 * @name: the entity name 2090 * 2091 * Lookup the given entity in EntitiesTable 2092 * 2093 * TODO: the linear scan is really ugly, an hash table is really needed. 2094 * 2095 * Returns the associated htmlEntityDescPtr if found, NULL otherwise. 2096 */ 2097 const htmlEntityDesc * 2098 htmlEntityLookup(const xmlChar *name) { 2099 unsigned int i; 2100 2101 for (i = 0;i < (sizeof(html40EntitiesTable)/ 2102 sizeof(html40EntitiesTable[0]));i++) { 2103 if (xmlStrEqual(name, BAD_CAST html40EntitiesTable[i].name)) { 2104 return((htmlEntityDescPtr) &html40EntitiesTable[i]); 2105 } 2106 } 2107 return(NULL); 2108 } 2109 2110 /** 2111 * htmlEntityValueLookup: 2112 * @value: the entity's unicode value 2113 * 2114 * Lookup the given entity in EntitiesTable 2115 * 2116 * TODO: the linear scan is really ugly, an hash table is really needed. 2117 * 2118 * Returns the associated htmlEntityDescPtr if found, NULL otherwise. 2119 */ 2120 const htmlEntityDesc * 2121 htmlEntityValueLookup(unsigned int value) { 2122 unsigned int i; 2123 2124 for (i = 0;i < (sizeof(html40EntitiesTable)/ 2125 sizeof(html40EntitiesTable[0]));i++) { 2126 if (html40EntitiesTable[i].value >= value) { 2127 if (html40EntitiesTable[i].value > value) 2128 break; 2129 return((htmlEntityDescPtr) &html40EntitiesTable[i]); 2130 } 2131 } 2132 return(NULL); 2133 } 2134 2135 /** 2136 * UTF8ToHtml: 2137 * @out: a pointer to an array of bytes to store the result 2138 * @outlen: the length of @out 2139 * @in: a pointer to an array of UTF-8 chars 2140 * @inlen: the length of @in 2141 * 2142 * Take a block of UTF-8 chars in and try to convert it to an ASCII 2143 * plus HTML entities block of chars out. 2144 * 2145 * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise 2146 * The value of @inlen after return is the number of octets consumed 2147 * as the return value is positive, else unpredictable. 2148 * The value of @outlen after return is the number of octets consumed. 2149 */ 2150 int 2151 UTF8ToHtml(unsigned char* out, int *outlen, 2152 const unsigned char* in, int *inlen) { 2153 const unsigned char* processed = in; 2154 const unsigned char* outend; 2155 const unsigned char* outstart = out; 2156 const unsigned char* instart = in; 2157 const unsigned char* inend; 2158 unsigned int c, d; 2159 int trailing; 2160 2161 if ((out == NULL) || (outlen == NULL) || (inlen == NULL)) return(-1); 2162 if (in == NULL) { 2163 /* 2164 * initialization nothing to do 2165 */ 2166 *outlen = 0; 2167 *inlen = 0; 2168 return(0); 2169 } 2170 inend = in + (*inlen); 2171 outend = out + (*outlen); 2172 while (in < inend) { 2173 d = *in++; 2174 if (d < 0x80) { c= d; trailing= 0; } 2175 else if (d < 0xC0) { 2176 /* trailing byte in leading position */ 2177 *outlen = out - outstart; 2178 *inlen = processed - instart; 2179 return(-2); 2180 } else if (d < 0xE0) { c= d & 0x1F; trailing= 1; } 2181 else if (d < 0xF0) { c= d & 0x0F; trailing= 2; } 2182 else if (d < 0xF8) { c= d & 0x07; trailing= 3; } 2183 else { 2184 /* no chance for this in Ascii */ 2185 *outlen = out - outstart; 2186 *inlen = processed - instart; 2187 return(-2); 2188 } 2189 2190 if (inend - in < trailing) { 2191 break; 2192 } 2193 2194 for ( ; trailing; trailing--) { 2195 if ((in >= inend) || (((d= *in++) & 0xC0) != 0x80)) 2196 break; 2197 c <<= 6; 2198 c |= d & 0x3F; 2199 } 2200 2201 /* assertion: c is a single UTF-4 value */ 2202 if (c < 0x80) { 2203 if (out + 1 >= outend) 2204 break; 2205 *out++ = c; 2206 } else { 2207 int len; 2208 const htmlEntityDesc * ent; 2209 const char *cp; 2210 char nbuf[16]; 2211 2212 /* 2213 * Try to lookup a predefined HTML entity for it 2214 */ 2215 2216 ent = htmlEntityValueLookup(c); 2217 if (ent == NULL) { 2218 snprintf(nbuf, sizeof(nbuf), "#%u", c); 2219 cp = nbuf; 2220 } 2221 else 2222 cp = ent->name; 2223 len = strlen(cp); 2224 if (out + 2 + len >= outend) 2225 break; 2226 *out++ = '&'; 2227 memcpy(out, cp, len); 2228 out += len; 2229 *out++ = ';'; 2230 } 2231 processed = in; 2232 } 2233 *outlen = out - outstart; 2234 *inlen = processed - instart; 2235 return(0); 2236 } 2237 2238 /** 2239 * htmlEncodeEntities: 2240 * @out: a pointer to an array of bytes to store the result 2241 * @outlen: the length of @out 2242 * @in: a pointer to an array of UTF-8 chars 2243 * @inlen: the length of @in 2244 * @quoteChar: the quote character to escape (' or ") or zero. 2245 * 2246 * Take a block of UTF-8 chars in and try to convert it to an ASCII 2247 * plus HTML entities block of chars out. 2248 * 2249 * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise 2250 * The value of @inlen after return is the number of octets consumed 2251 * as the return value is positive, else unpredictable. 2252 * The value of @outlen after return is the number of octets consumed. 2253 */ 2254 int 2255 htmlEncodeEntities(unsigned char* out, int *outlen, 2256 const unsigned char* in, int *inlen, int quoteChar) { 2257 const unsigned char* processed = in; 2258 const unsigned char* outend; 2259 const unsigned char* outstart = out; 2260 const unsigned char* instart = in; 2261 const unsigned char* inend; 2262 unsigned int c, d; 2263 int trailing; 2264 2265 if ((out == NULL) || (outlen == NULL) || (inlen == NULL) || (in == NULL)) 2266 return(-1); 2267 outend = out + (*outlen); 2268 inend = in + (*inlen); 2269 while (in < inend) { 2270 d = *in++; 2271 if (d < 0x80) { c= d; trailing= 0; } 2272 else if (d < 0xC0) { 2273 /* trailing byte in leading position */ 2274 *outlen = out - outstart; 2275 *inlen = processed - instart; 2276 return(-2); 2277 } else if (d < 0xE0) { c= d & 0x1F; trailing= 1; } 2278 else if (d < 0xF0) { c= d & 0x0F; trailing= 2; } 2279 else if (d < 0xF8) { c= d & 0x07; trailing= 3; } 2280 else { 2281 /* no chance for this in Ascii */ 2282 *outlen = out - outstart; 2283 *inlen = processed - instart; 2284 return(-2); 2285 } 2286 2287 if (inend - in < trailing) 2288 break; 2289 2290 while (trailing--) { 2291 if (((d= *in++) & 0xC0) != 0x80) { 2292 *outlen = out - outstart; 2293 *inlen = processed - instart; 2294 return(-2); 2295 } 2296 c <<= 6; 2297 c |= d & 0x3F; 2298 } 2299 2300 /* assertion: c is a single UTF-4 value */ 2301 if ((c < 0x80) && (c != (unsigned int) quoteChar) && 2302 (c != '&') && (c != '<') && (c != '>')) { 2303 if (out >= outend) 2304 break; 2305 *out++ = c; 2306 } else { 2307 const htmlEntityDesc * ent; 2308 const char *cp; 2309 char nbuf[16]; 2310 int len; 2311 2312 /* 2313 * Try to lookup a predefined HTML entity for it 2314 */ 2315 ent = htmlEntityValueLookup(c); 2316 if (ent == NULL) { 2317 snprintf(nbuf, sizeof(nbuf), "#%u", c); 2318 cp = nbuf; 2319 } 2320 else 2321 cp = ent->name; 2322 len = strlen(cp); 2323 if (out + 2 + len > outend) 2324 break; 2325 *out++ = '&'; 2326 memcpy(out, cp, len); 2327 out += len; 2328 *out++ = ';'; 2329 } 2330 processed = in; 2331 } 2332 *outlen = out - outstart; 2333 *inlen = processed - instart; 2334 return(0); 2335 } 2336 2337 /************************************************************************ 2338 * * 2339 * Commodity functions to handle streams * 2340 * * 2341 ************************************************************************/ 2342 2343 #ifdef LIBXML_PUSH_ENABLED 2344 /** 2345 * htmlNewInputStream: 2346 * @ctxt: an HTML parser context 2347 * 2348 * Create a new input stream structure 2349 * Returns the new input stream or NULL 2350 */ 2351 static htmlParserInputPtr 2352 htmlNewInputStream(htmlParserCtxtPtr ctxt) { 2353 htmlParserInputPtr input; 2354 2355 input = (xmlParserInputPtr) xmlMalloc(sizeof(htmlParserInput)); 2356 if (input == NULL) { 2357 htmlErrMemory(ctxt, "couldn't allocate a new input stream\n"); 2358 return(NULL); 2359 } 2360 memset(input, 0, sizeof(htmlParserInput)); 2361 input->filename = NULL; 2362 input->directory = NULL; 2363 input->base = NULL; 2364 input->cur = NULL; 2365 input->buf = NULL; 2366 input->line = 1; 2367 input->col = 1; 2368 input->buf = NULL; 2369 input->free = NULL; 2370 input->version = NULL; 2371 input->consumed = 0; 2372 input->length = 0; 2373 return(input); 2374 } 2375 #endif 2376 2377 2378 /************************************************************************ 2379 * * 2380 * Commodity functions, cleanup needed ? * 2381 * * 2382 ************************************************************************/ 2383 /* 2384 * all tags allowing pc data from the html 4.01 loose dtd 2385 * NOTE: it might be more appropriate to integrate this information 2386 * into the html40ElementTable array but I don't want to risk any 2387 * binary incompatibility 2388 */ 2389 static const char *allowPCData[] = { 2390 "a", "abbr", "acronym", "address", "applet", "b", "bdo", "big", 2391 "blockquote", "body", "button", "caption", "center", "cite", "code", 2392 "dd", "del", "dfn", "div", "dt", "em", "font", "form", "h1", "h2", 2393 "h3", "h4", "h5", "h6", "i", "iframe", "ins", "kbd", "label", "legend", 2394 "li", "noframes", "noscript", "object", "p", "pre", "q", "s", "samp", 2395 "small", "span", "strike", "strong", "td", "th", "tt", "u", "var" 2396 }; 2397 2398 /** 2399 * areBlanks: 2400 * @ctxt: an HTML parser context 2401 * @str: a xmlChar * 2402 * @len: the size of @str 2403 * 2404 * Is this a sequence of blank chars that one can ignore ? 2405 * 2406 * Returns 1 if ignorable 0 otherwise. 2407 */ 2408 2409 static int areBlanks(htmlParserCtxtPtr ctxt, const xmlChar *str, int len) { 2410 unsigned int i; 2411 int j; 2412 xmlNodePtr lastChild; 2413 xmlDtdPtr dtd; 2414 2415 for (j = 0;j < len;j++) 2416 if (!(IS_BLANK_CH(str[j]))) return(0); 2417 2418 if (CUR == 0) return(1); 2419 if (CUR != '<') return(0); 2420 if (ctxt->name == NULL) 2421 return(1); 2422 if (xmlStrEqual(ctxt->name, BAD_CAST"html")) 2423 return(1); 2424 if (xmlStrEqual(ctxt->name, BAD_CAST"head")) 2425 return(1); 2426 2427 /* Only strip CDATA children of the body tag for strict HTML DTDs */ 2428 if (xmlStrEqual(ctxt->name, BAD_CAST "body") && ctxt->myDoc != NULL) { 2429 dtd = xmlGetIntSubset(ctxt->myDoc); 2430 if (dtd != NULL && dtd->ExternalID != NULL) { 2431 if (!xmlStrcasecmp(dtd->ExternalID, BAD_CAST "-//W3C//DTD HTML 4.01//EN") || 2432 !xmlStrcasecmp(dtd->ExternalID, BAD_CAST "-//W3C//DTD HTML 4//EN")) 2433 return(1); 2434 } 2435 } 2436 2437 if (ctxt->node == NULL) return(0); 2438 lastChild = xmlGetLastChild(ctxt->node); 2439 while ((lastChild) && (lastChild->type == XML_COMMENT_NODE)) 2440 lastChild = lastChild->prev; 2441 if (lastChild == NULL) { 2442 if ((ctxt->node->type != XML_ELEMENT_NODE) && 2443 (ctxt->node->content != NULL)) return(0); 2444 /* keep ws in constructs like ...<b> </b>... 2445 for all tags "b" allowing PCDATA */ 2446 for ( i = 0; i < sizeof(allowPCData)/sizeof(allowPCData[0]); i++ ) { 2447 if ( xmlStrEqual(ctxt->name, BAD_CAST allowPCData[i]) ) { 2448 return(0); 2449 } 2450 } 2451 } else if (xmlNodeIsText(lastChild)) { 2452 return(0); 2453 } else { 2454 /* keep ws in constructs like <p><b>xy</b> <i>z</i><p> 2455 for all tags "p" allowing PCDATA */ 2456 for ( i = 0; i < sizeof(allowPCData)/sizeof(allowPCData[0]); i++ ) { 2457 if ( xmlStrEqual(lastChild->name, BAD_CAST allowPCData[i]) ) { 2458 return(0); 2459 } 2460 } 2461 } 2462 return(1); 2463 } 2464 2465 /** 2466 * htmlNewDocNoDtD: 2467 * @URI: URI for the dtd, or NULL 2468 * @ExternalID: the external ID of the DTD, or NULL 2469 * 2470 * Creates a new HTML document without a DTD node if @URI and @ExternalID 2471 * are NULL 2472 * 2473 * Returns a new document, do not initialize the DTD if not provided 2474 */ 2475 htmlDocPtr 2476 htmlNewDocNoDtD(const xmlChar *URI, const xmlChar *ExternalID) { 2477 xmlDocPtr cur; 2478 2479 /* 2480 * Allocate a new document and fill the fields. 2481 */ 2482 cur = (xmlDocPtr) xmlMalloc(sizeof(xmlDoc)); 2483 if (cur == NULL) { 2484 htmlErrMemory(NULL, "HTML document creation failed\n"); 2485 return(NULL); 2486 } 2487 memset(cur, 0, sizeof(xmlDoc)); 2488 2489 cur->type = XML_HTML_DOCUMENT_NODE; 2490 cur->version = NULL; 2491 cur->intSubset = NULL; 2492 cur->doc = cur; 2493 cur->name = NULL; 2494 cur->children = NULL; 2495 cur->extSubset = NULL; 2496 cur->oldNs = NULL; 2497 cur->encoding = NULL; 2498 cur->standalone = 1; 2499 cur->compression = 0; 2500 cur->ids = NULL; 2501 cur->refs = NULL; 2502 cur->_private = NULL; 2503 cur->charset = XML_CHAR_ENCODING_UTF8; 2504 cur->properties = XML_DOC_HTML | XML_DOC_USERBUILT; 2505 if ((ExternalID != NULL) || 2506 (URI != NULL)) 2507 xmlCreateIntSubset(cur, BAD_CAST "html", ExternalID, URI); 2508 if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue)) 2509 xmlRegisterNodeDefaultValue((xmlNodePtr)cur); 2510 return(cur); 2511 } 2512 2513 /** 2514 * htmlNewDoc: 2515 * @URI: URI for the dtd, or NULL 2516 * @ExternalID: the external ID of the DTD, or NULL 2517 * 2518 * Creates a new HTML document 2519 * 2520 * Returns a new document 2521 */ 2522 htmlDocPtr 2523 htmlNewDoc(const xmlChar *URI, const xmlChar *ExternalID) { 2524 if ((URI == NULL) && (ExternalID == NULL)) 2525 return(htmlNewDocNoDtD( 2526 BAD_CAST "http://www.w3.org/TR/REC-html40/loose.dtd", 2527 BAD_CAST "-//W3C//DTD HTML 4.0 Transitional//EN")); 2528 2529 return(htmlNewDocNoDtD(URI, ExternalID)); 2530 } 2531 2532 2533 /************************************************************************ 2534 * * 2535 * The parser itself * 2536 * Relates to http://www.w3.org/TR/html40 * 2537 * * 2538 ************************************************************************/ 2539 2540 /************************************************************************ 2541 * * 2542 * The parser itself * 2543 * * 2544 ************************************************************************/ 2545 2546 static const xmlChar * htmlParseNameComplex(xmlParserCtxtPtr ctxt); 2547 2548 static void 2549 htmlSkipBogusComment(htmlParserCtxtPtr ctxt) { 2550 int c; 2551 2552 htmlParseErr(ctxt, XML_HTML_INCORRECTLY_OPENED_COMMENT, 2553 "Incorrectly opened comment\n", NULL, NULL); 2554 2555 do { 2556 c = CUR; 2557 if (c == 0) 2558 break; 2559 NEXT; 2560 } while (c != '>'); 2561 } 2562 2563 /** 2564 * htmlParseHTMLName: 2565 * @ctxt: an HTML parser context 2566 * 2567 * parse an HTML tag or attribute name, note that we convert it to lowercase 2568 * since HTML names are not case-sensitive. 2569 * 2570 * Returns the Tag Name parsed or NULL 2571 */ 2572 2573 static const xmlChar * 2574 htmlParseHTMLName(htmlParserCtxtPtr ctxt) { 2575 int i = 0; 2576 xmlChar loc[HTML_PARSER_BUFFER_SIZE]; 2577 2578 if (!IS_ASCII_LETTER(CUR) && (CUR != '_') && 2579 (CUR != ':') && (CUR != '.')) return(NULL); 2580 2581 while ((i < HTML_PARSER_BUFFER_SIZE) && 2582 ((IS_ASCII_LETTER(CUR)) || (IS_ASCII_DIGIT(CUR)) || 2583 (CUR == ':') || (CUR == '-') || (CUR == '_') || 2584 (CUR == '.'))) { 2585 if ((CUR >= 'A') && (CUR <= 'Z')) loc[i] = CUR + 0x20; 2586 else loc[i] = CUR; 2587 i++; 2588 2589 NEXT; 2590 } 2591 2592 return(xmlDictLookup(ctxt->dict, loc, i)); 2593 } 2594 2595 2596 /** 2597 * htmlParseHTMLName_nonInvasive: 2598 * @ctxt: an HTML parser context 2599 * 2600 * parse an HTML tag or attribute name, note that we convert it to lowercase 2601 * since HTML names are not case-sensitive, this doesn't consume the data 2602 * from the stream, it's a look-ahead 2603 * 2604 * Returns the Tag Name parsed or NULL 2605 */ 2606 2607 static const xmlChar * 2608 htmlParseHTMLName_nonInvasive(htmlParserCtxtPtr ctxt) { 2609 int i = 0; 2610 xmlChar loc[HTML_PARSER_BUFFER_SIZE]; 2611 2612 if (!IS_ASCII_LETTER(NXT(1)) && (NXT(1) != '_') && 2613 (NXT(1) != ':')) return(NULL); 2614 2615 while ((i < HTML_PARSER_BUFFER_SIZE) && 2616 ((IS_ASCII_LETTER(NXT(1+i))) || (IS_ASCII_DIGIT(NXT(1+i))) || 2617 (NXT(1+i) == ':') || (NXT(1+i) == '-') || (NXT(1+i) == '_'))) { 2618 if ((NXT(1+i) >= 'A') && (NXT(1+i) <= 'Z')) loc[i] = NXT(1+i) + 0x20; 2619 else loc[i] = NXT(1+i); 2620 i++; 2621 } 2622 2623 return(xmlDictLookup(ctxt->dict, loc, i)); 2624 } 2625 2626 2627 /** 2628 * htmlParseName: 2629 * @ctxt: an HTML parser context 2630 * 2631 * parse an HTML name, this routine is case sensitive. 2632 * 2633 * Returns the Name parsed or NULL 2634 */ 2635 2636 static const xmlChar * 2637 htmlParseName(htmlParserCtxtPtr ctxt) { 2638 const xmlChar *in; 2639 const xmlChar *ret; 2640 int count = 0; 2641 2642 GROW; 2643 2644 /* 2645 * Accelerator for simple ASCII names 2646 */ 2647 in = ctxt->input->cur; 2648 if (((*in >= 0x61) && (*in <= 0x7A)) || 2649 ((*in >= 0x41) && (*in <= 0x5A)) || 2650 (*in == '_') || (*in == ':')) { 2651 in++; 2652 while (((*in >= 0x61) && (*in <= 0x7A)) || 2653 ((*in >= 0x41) && (*in <= 0x5A)) || 2654 ((*in >= 0x30) && (*in <= 0x39)) || 2655 (*in == '_') || (*in == '-') || 2656 (*in == ':') || (*in == '.')) 2657 in++; 2658 2659 if (in == ctxt->input->end) 2660 return(NULL); 2661 2662 if ((*in > 0) && (*in < 0x80)) { 2663 count = in - ctxt->input->cur; 2664 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count); 2665 ctxt->input->cur = in; 2666 ctxt->input->col += count; 2667 return(ret); 2668 } 2669 } 2670 return(htmlParseNameComplex(ctxt)); 2671 } 2672 2673 static const xmlChar * 2674 htmlParseNameComplex(xmlParserCtxtPtr ctxt) { 2675 int len = 0, l; 2676 int c; 2677 int count = 0; 2678 const xmlChar *base = ctxt->input->base; 2679 2680 /* 2681 * Handler for more complex cases 2682 */ 2683 GROW; 2684 c = CUR_CHAR(l); 2685 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ 2686 (!IS_LETTER(c) && (c != '_') && 2687 (c != ':'))) { 2688 return(NULL); 2689 } 2690 2691 while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */ 2692 ((IS_LETTER(c)) || (IS_DIGIT(c)) || 2693 (c == '.') || (c == '-') || 2694 (c == '_') || (c == ':') || 2695 (IS_COMBINING(c)) || 2696 (IS_EXTENDER(c)))) { 2697 if (count++ > 100) { 2698 count = 0; 2699 GROW; 2700 } 2701 len += l; 2702 NEXTL(l); 2703 c = CUR_CHAR(l); 2704 if (ctxt->input->base != base) { 2705 /* 2706 * We changed encoding from an unknown encoding 2707 * Input buffer changed location, so we better start again 2708 */ 2709 return(htmlParseNameComplex(ctxt)); 2710 } 2711 } 2712 2713 if (ctxt->input->cur - ctxt->input->base < len) { 2714 /* Sanity check */ 2715 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 2716 "unexpected change of input buffer", NULL, NULL); 2717 return (NULL); 2718 } 2719 2720 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len)); 2721 } 2722 2723 2724 /** 2725 * htmlParseHTMLAttribute: 2726 * @ctxt: an HTML parser context 2727 * @stop: a char stop value 2728 * 2729 * parse an HTML attribute value till the stop (quote), if 2730 * stop is 0 then it stops at the first space 2731 * 2732 * Returns the attribute parsed or NULL 2733 */ 2734 2735 static xmlChar * 2736 htmlParseHTMLAttribute(htmlParserCtxtPtr ctxt, const xmlChar stop) { 2737 xmlChar *buffer = NULL; 2738 int buffer_size = 0; 2739 xmlChar *out = NULL; 2740 const xmlChar *name = NULL; 2741 const xmlChar *cur = NULL; 2742 const htmlEntityDesc * ent; 2743 2744 /* 2745 * allocate a translation buffer. 2746 */ 2747 buffer_size = HTML_PARSER_BUFFER_SIZE; 2748 buffer = (xmlChar *) xmlMallocAtomic(buffer_size * sizeof(xmlChar)); 2749 if (buffer == NULL) { 2750 htmlErrMemory(ctxt, "buffer allocation failed\n"); 2751 return(NULL); 2752 } 2753 out = buffer; 2754 2755 /* 2756 * Ok loop until we reach one of the ending chars 2757 */ 2758 while ((CUR != 0) && (CUR != stop)) { 2759 if ((stop == 0) && (CUR == '>')) break; 2760 if ((stop == 0) && (IS_BLANK_CH(CUR))) break; 2761 if (CUR == '&') { 2762 if (NXT(1) == '#') { 2763 unsigned int c; 2764 int bits; 2765 2766 c = htmlParseCharRef(ctxt); 2767 if (c < 0x80) 2768 { *out++ = c; bits= -6; } 2769 else if (c < 0x800) 2770 { *out++ =((c >> 6) & 0x1F) | 0xC0; bits= 0; } 2771 else if (c < 0x10000) 2772 { *out++ =((c >> 12) & 0x0F) | 0xE0; bits= 6; } 2773 else 2774 { *out++ =((c >> 18) & 0x07) | 0xF0; bits= 12; } 2775 2776 for ( ; bits >= 0; bits-= 6) { 2777 *out++ = ((c >> bits) & 0x3F) | 0x80; 2778 } 2779 2780 if (out - buffer > buffer_size - 100) { 2781 int indx = out - buffer; 2782 2783 growBuffer(buffer); 2784 out = &buffer[indx]; 2785 } 2786 } else { 2787 ent = htmlParseEntityRef(ctxt, &name); 2788 if (name == NULL) { 2789 *out++ = '&'; 2790 if (out - buffer > buffer_size - 100) { 2791 int indx = out - buffer; 2792 2793 growBuffer(buffer); 2794 out = &buffer[indx]; 2795 } 2796 } else if (ent == NULL) { 2797 *out++ = '&'; 2798 cur = name; 2799 while (*cur != 0) { 2800 if (out - buffer > buffer_size - 100) { 2801 int indx = out - buffer; 2802 2803 growBuffer(buffer); 2804 out = &buffer[indx]; 2805 } 2806 *out++ = *cur++; 2807 } 2808 } else { 2809 unsigned int c; 2810 int bits; 2811 2812 if (out - buffer > buffer_size - 100) { 2813 int indx = out - buffer; 2814 2815 growBuffer(buffer); 2816 out = &buffer[indx]; 2817 } 2818 c = ent->value; 2819 if (c < 0x80) 2820 { *out++ = c; bits= -6; } 2821 else if (c < 0x800) 2822 { *out++ =((c >> 6) & 0x1F) | 0xC0; bits= 0; } 2823 else if (c < 0x10000) 2824 { *out++ =((c >> 12) & 0x0F) | 0xE0; bits= 6; } 2825 else 2826 { *out++ =((c >> 18) & 0x07) | 0xF0; bits= 12; } 2827 2828 for ( ; bits >= 0; bits-= 6) { 2829 *out++ = ((c >> bits) & 0x3F) | 0x80; 2830 } 2831 } 2832 } 2833 } else { 2834 unsigned int c; 2835 int bits, l; 2836 2837 if (out - buffer > buffer_size - 100) { 2838 int indx = out - buffer; 2839 2840 growBuffer(buffer); 2841 out = &buffer[indx]; 2842 } 2843 c = CUR_CHAR(l); 2844 if (c < 0x80) 2845 { *out++ = c; bits= -6; } 2846 else if (c < 0x800) 2847 { *out++ =((c >> 6) & 0x1F) | 0xC0; bits= 0; } 2848 else if (c < 0x10000) 2849 { *out++ =((c >> 12) & 0x0F) | 0xE0; bits= 6; } 2850 else 2851 { *out++ =((c >> 18) & 0x07) | 0xF0; bits= 12; } 2852 2853 for ( ; bits >= 0; bits-= 6) { 2854 *out++ = ((c >> bits) & 0x3F) | 0x80; 2855 } 2856 NEXT; 2857 } 2858 } 2859 *out = 0; 2860 return(buffer); 2861 } 2862 2863 /** 2864 * htmlParseEntityRef: 2865 * @ctxt: an HTML parser context 2866 * @str: location to store the entity name 2867 * 2868 * parse an HTML ENTITY references 2869 * 2870 * [68] EntityRef ::= '&' Name ';' 2871 * 2872 * Returns the associated htmlEntityDescPtr if found, or NULL otherwise, 2873 * if non-NULL *str will have to be freed by the caller. 2874 */ 2875 const htmlEntityDesc * 2876 htmlParseEntityRef(htmlParserCtxtPtr ctxt, const xmlChar **str) { 2877 const xmlChar *name; 2878 const htmlEntityDesc * ent = NULL; 2879 2880 if (str != NULL) *str = NULL; 2881 if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL); 2882 2883 if (CUR == '&') { 2884 NEXT; 2885 name = htmlParseName(ctxt); 2886 if (name == NULL) { 2887 htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED, 2888 "htmlParseEntityRef: no name\n", NULL, NULL); 2889 } else { 2890 GROW; 2891 if (CUR == ';') { 2892 if (str != NULL) 2893 *str = name; 2894 2895 /* 2896 * Lookup the entity in the table. 2897 */ 2898 ent = htmlEntityLookup(name); 2899 if (ent != NULL) /* OK that's ugly !!! */ 2900 NEXT; 2901 } else { 2902 htmlParseErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, 2903 "htmlParseEntityRef: expecting ';'\n", 2904 NULL, NULL); 2905 if (str != NULL) 2906 *str = name; 2907 } 2908 } 2909 } 2910 return(ent); 2911 } 2912 2913 /** 2914 * htmlParseAttValue: 2915 * @ctxt: an HTML parser context 2916 * 2917 * parse a value for an attribute 2918 * Note: the parser won't do substitution of entities here, this 2919 * will be handled later in xmlStringGetNodeList, unless it was 2920 * asked for ctxt->replaceEntities != 0 2921 * 2922 * Returns the AttValue parsed or NULL. 2923 */ 2924 2925 static xmlChar * 2926 htmlParseAttValue(htmlParserCtxtPtr ctxt) { 2927 xmlChar *ret = NULL; 2928 2929 if (CUR == '"') { 2930 NEXT; 2931 ret = htmlParseHTMLAttribute(ctxt, '"'); 2932 if (CUR != '"') { 2933 htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, 2934 "AttValue: \" expected\n", NULL, NULL); 2935 } else 2936 NEXT; 2937 } else if (CUR == '\'') { 2938 NEXT; 2939 ret = htmlParseHTMLAttribute(ctxt, '\''); 2940 if (CUR != '\'') { 2941 htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, 2942 "AttValue: ' expected\n", NULL, NULL); 2943 } else 2944 NEXT; 2945 } else { 2946 /* 2947 * That's an HTMLism, the attribute value may not be quoted 2948 */ 2949 ret = htmlParseHTMLAttribute(ctxt, 0); 2950 if (ret == NULL) { 2951 htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE, 2952 "AttValue: no value found\n", NULL, NULL); 2953 } 2954 } 2955 return(ret); 2956 } 2957 2958 /** 2959 * htmlParseSystemLiteral: 2960 * @ctxt: an HTML parser context 2961 * 2962 * parse an HTML Literal 2963 * 2964 * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'") 2965 * 2966 * Returns the SystemLiteral parsed or NULL 2967 */ 2968 2969 static xmlChar * 2970 htmlParseSystemLiteral(htmlParserCtxtPtr ctxt) { 2971 size_t len = 0, startPosition = 0; 2972 int err = 0; 2973 int quote; 2974 xmlChar *ret = NULL; 2975 2976 if ((CUR != '"') && (CUR != '\'')) { 2977 htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, 2978 "SystemLiteral \" or ' expected\n", NULL, NULL); 2979 return(NULL); 2980 } 2981 quote = CUR; 2982 NEXT; 2983 2984 if (CUR_PTR < BASE_PTR) 2985 return(ret); 2986 startPosition = CUR_PTR - BASE_PTR; 2987 2988 while ((CUR != 0) && (CUR != quote)) { 2989 /* TODO: Handle UTF-8 */ 2990 if (!IS_CHAR_CH(CUR)) { 2991 htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR, 2992 "Invalid char in SystemLiteral 0x%X\n", CUR); 2993 err = 1; 2994 } 2995 NEXT; 2996 len++; 2997 } 2998 if (CUR != quote) { 2999 htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, 3000 "Unfinished SystemLiteral\n", NULL, NULL); 3001 } else { 3002 NEXT; 3003 if (err == 0) 3004 ret = xmlStrndup((BASE_PTR+startPosition), len); 3005 } 3006 3007 return(ret); 3008 } 3009 3010 /** 3011 * htmlParsePubidLiteral: 3012 * @ctxt: an HTML parser context 3013 * 3014 * parse an HTML public literal 3015 * 3016 * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'" 3017 * 3018 * Returns the PubidLiteral parsed or NULL. 3019 */ 3020 3021 static xmlChar * 3022 htmlParsePubidLiteral(htmlParserCtxtPtr ctxt) { 3023 size_t len = 0, startPosition = 0; 3024 int err = 0; 3025 int quote; 3026 xmlChar *ret = NULL; 3027 3028 if ((CUR != '"') && (CUR != '\'')) { 3029 htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, 3030 "PubidLiteral \" or ' expected\n", NULL, NULL); 3031 return(NULL); 3032 } 3033 quote = CUR; 3034 NEXT; 3035 3036 /* 3037 * Name ::= (Letter | '_') (NameChar)* 3038 */ 3039 if (CUR_PTR < BASE_PTR) 3040 return(ret); 3041 startPosition = CUR_PTR - BASE_PTR; 3042 3043 while ((CUR != 0) && (CUR != quote)) { 3044 if (!IS_PUBIDCHAR_CH(CUR)) { 3045 htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR, 3046 "Invalid char in PubidLiteral 0x%X\n", CUR); 3047 err = 1; 3048 } 3049 len++; 3050 NEXT; 3051 } 3052 3053 if (CUR != quote) { 3054 htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, 3055 "Unfinished PubidLiteral\n", NULL, NULL); 3056 } else { 3057 NEXT; 3058 if (err == 0) 3059 ret = xmlStrndup((BASE_PTR + startPosition), len); 3060 } 3061 3062 return(ret); 3063 } 3064 3065 /** 3066 * htmlParseScript: 3067 * @ctxt: an HTML parser context 3068 * 3069 * parse the content of an HTML SCRIPT or STYLE element 3070 * http://www.w3.org/TR/html4/sgml/dtd.html#Script 3071 * http://www.w3.org/TR/html4/sgml/dtd.html#StyleSheet 3072 * http://www.w3.org/TR/html4/types.html#type-script 3073 * http://www.w3.org/TR/html4/types.html#h-6.15 3074 * http://www.w3.org/TR/html4/appendix/notes.html#h-B.3.2.1 3075 * 3076 * Script data ( %Script; in the DTD) can be the content of the SCRIPT 3077 * element and the value of intrinsic event attributes. User agents must 3078 * not evaluate script data as HTML markup but instead must pass it on as 3079 * data to a script engine. 3080 * NOTES: 3081 * - The content is passed like CDATA 3082 * - the attributes for style and scripting "onXXX" are also described 3083 * as CDATA but SGML allows entities references in attributes so their 3084 * processing is identical as other attributes 3085 */ 3086 static void 3087 htmlParseScript(htmlParserCtxtPtr ctxt) { 3088 xmlChar buf[HTML_PARSER_BIG_BUFFER_SIZE + 5]; 3089 int nbchar = 0; 3090 int cur,l; 3091 3092 SHRINK; 3093 cur = CUR_CHAR(l); 3094 while (cur != 0) { 3095 if ((cur == '<') && (NXT(1) == '/')) { 3096 /* 3097 * One should break here, the specification is clear: 3098 * Authors should therefore escape "</" within the content. 3099 * Escape mechanisms are specific to each scripting or 3100 * style sheet language. 3101 * 3102 * In recovery mode, only break if end tag match the 3103 * current tag, effectively ignoring all tags inside the 3104 * script/style block and treating the entire block as 3105 * CDATA. 3106 */ 3107 if (ctxt->recovery) { 3108 if (xmlStrncasecmp(ctxt->name, ctxt->input->cur+2, 3109 xmlStrlen(ctxt->name)) == 0) 3110 { 3111 break; /* while */ 3112 } else { 3113 htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH, 3114 "Element %s embeds close tag\n", 3115 ctxt->name, NULL); 3116 } 3117 } else { 3118 if (((NXT(2) >= 'A') && (NXT(2) <= 'Z')) || 3119 ((NXT(2) >= 'a') && (NXT(2) <= 'z'))) 3120 { 3121 break; /* while */ 3122 } 3123 } 3124 } 3125 if (IS_CHAR(cur)) { 3126 COPY_BUF(l,buf,nbchar,cur); 3127 } else { 3128 htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR, 3129 "Invalid char in CDATA 0x%X\n", cur); 3130 } 3131 if (nbchar >= HTML_PARSER_BIG_BUFFER_SIZE) { 3132 buf[nbchar] = 0; 3133 if (ctxt->sax->cdataBlock!= NULL) { 3134 /* 3135 * Insert as CDATA, which is the same as HTML_PRESERVE_NODE 3136 */ 3137 ctxt->sax->cdataBlock(ctxt->userData, buf, nbchar); 3138 } else if (ctxt->sax->characters != NULL) { 3139 ctxt->sax->characters(ctxt->userData, buf, nbchar); 3140 } 3141 nbchar = 0; 3142 } 3143 GROW; 3144 NEXTL(l); 3145 cur = CUR_CHAR(l); 3146 } 3147 3148 if ((nbchar != 0) && (ctxt->sax != NULL) && (!ctxt->disableSAX)) { 3149 buf[nbchar] = 0; 3150 if (ctxt->sax->cdataBlock!= NULL) { 3151 /* 3152 * Insert as CDATA, which is the same as HTML_PRESERVE_NODE 3153 */ 3154 ctxt->sax->cdataBlock(ctxt->userData, buf, nbchar); 3155 } else if (ctxt->sax->characters != NULL) { 3156 ctxt->sax->characters(ctxt->userData, buf, nbchar); 3157 } 3158 } 3159 } 3160 3161 3162 /** 3163 * htmlParseCharDataInternal: 3164 * @ctxt: an HTML parser context 3165 * @readahead: optional read ahead character in ascii range 3166 * 3167 * parse a CharData section. 3168 * if we are within a CDATA section ']]>' marks an end of section. 3169 * 3170 * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*) 3171 */ 3172 3173 static void 3174 htmlParseCharDataInternal(htmlParserCtxtPtr ctxt, int readahead) { 3175 xmlChar buf[HTML_PARSER_BIG_BUFFER_SIZE + 6]; 3176 int nbchar = 0; 3177 int cur, l; 3178 int chunk = 0; 3179 3180 if (readahead) 3181 buf[nbchar++] = readahead; 3182 3183 SHRINK; 3184 cur = CUR_CHAR(l); 3185 while (((cur != '<') || (ctxt->token == '<')) && 3186 ((cur != '&') || (ctxt->token == '&')) && 3187 (cur != 0)) { 3188 if (!(IS_CHAR(cur))) { 3189 htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR, 3190 "Invalid char in CDATA 0x%X\n", cur); 3191 } else { 3192 COPY_BUF(l,buf,nbchar,cur); 3193 } 3194 if (nbchar >= HTML_PARSER_BIG_BUFFER_SIZE) { 3195 buf[nbchar] = 0; 3196 3197 /* 3198 * Ok the segment is to be consumed as chars. 3199 */ 3200 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) { 3201 if (areBlanks(ctxt, buf, nbchar)) { 3202 if (ctxt->keepBlanks) { 3203 if (ctxt->sax->characters != NULL) 3204 ctxt->sax->characters(ctxt->userData, buf, nbchar); 3205 } else { 3206 if (ctxt->sax->ignorableWhitespace != NULL) 3207 ctxt->sax->ignorableWhitespace(ctxt->userData, 3208 buf, nbchar); 3209 } 3210 } else { 3211 htmlCheckParagraph(ctxt); 3212 if (ctxt->sax->characters != NULL) 3213 ctxt->sax->characters(ctxt->userData, buf, nbchar); 3214 } 3215 } 3216 nbchar = 0; 3217 } 3218 NEXTL(l); 3219 chunk++; 3220 if (chunk > HTML_PARSER_BUFFER_SIZE) { 3221 chunk = 0; 3222 SHRINK; 3223 GROW; 3224 } 3225 cur = CUR_CHAR(l); 3226 if (cur == 0) { 3227 SHRINK; 3228 GROW; 3229 cur = CUR_CHAR(l); 3230 } 3231 } 3232 if (nbchar != 0) { 3233 buf[nbchar] = 0; 3234 3235 /* 3236 * Ok the segment is to be consumed as chars. 3237 */ 3238 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) { 3239 if (areBlanks(ctxt, buf, nbchar)) { 3240 if (ctxt->keepBlanks) { 3241 if (ctxt->sax->characters != NULL) 3242 ctxt->sax->characters(ctxt->userData, buf, nbchar); 3243 } else { 3244 if (ctxt->sax->ignorableWhitespace != NULL) 3245 ctxt->sax->ignorableWhitespace(ctxt->userData, 3246 buf, nbchar); 3247 } 3248 } else { 3249 htmlCheckParagraph(ctxt); 3250 if (ctxt->sax->characters != NULL) 3251 ctxt->sax->characters(ctxt->userData, buf, nbchar); 3252 } 3253 } 3254 } else { 3255 /* 3256 * Loop detection 3257 */ 3258 if (cur == 0) 3259 ctxt->instate = XML_PARSER_EOF; 3260 } 3261 } 3262 3263 /** 3264 * htmlParseCharData: 3265 * @ctxt: an HTML parser context 3266 * 3267 * parse a CharData section. 3268 * if we are within a CDATA section ']]>' marks an end of section. 3269 * 3270 * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*) 3271 */ 3272 3273 static void 3274 htmlParseCharData(htmlParserCtxtPtr ctxt) { 3275 htmlParseCharDataInternal(ctxt, 0); 3276 } 3277 3278 /** 3279 * htmlParseExternalID: 3280 * @ctxt: an HTML parser context 3281 * @publicID: a xmlChar** receiving PubidLiteral 3282 * 3283 * Parse an External ID or a Public ID 3284 * 3285 * [75] ExternalID ::= 'SYSTEM' S SystemLiteral 3286 * | 'PUBLIC' S PubidLiteral S SystemLiteral 3287 * 3288 * [83] PublicID ::= 'PUBLIC' S PubidLiteral 3289 * 3290 * Returns the function returns SystemLiteral and in the second 3291 * case publicID receives PubidLiteral, is strict is off 3292 * it is possible to return NULL and have publicID set. 3293 */ 3294 3295 static xmlChar * 3296 htmlParseExternalID(htmlParserCtxtPtr ctxt, xmlChar **publicID) { 3297 xmlChar *URI = NULL; 3298 3299 if ((UPPER == 'S') && (UPP(1) == 'Y') && 3300 (UPP(2) == 'S') && (UPP(3) == 'T') && 3301 (UPP(4) == 'E') && (UPP(5) == 'M')) { 3302 SKIP(6); 3303 if (!IS_BLANK_CH(CUR)) { 3304 htmlParseErr(ctxt, XML_ERR_SPACE_REQUIRED, 3305 "Space required after 'SYSTEM'\n", NULL, NULL); 3306 } 3307 SKIP_BLANKS; 3308 URI = htmlParseSystemLiteral(ctxt); 3309 if (URI == NULL) { 3310 htmlParseErr(ctxt, XML_ERR_URI_REQUIRED, 3311 "htmlParseExternalID: SYSTEM, no URI\n", NULL, NULL); 3312 } 3313 } else if ((UPPER == 'P') && (UPP(1) == 'U') && 3314 (UPP(2) == 'B') && (UPP(3) == 'L') && 3315 (UPP(4) == 'I') && (UPP(5) == 'C')) { 3316 SKIP(6); 3317 if (!IS_BLANK_CH(CUR)) { 3318 htmlParseErr(ctxt, XML_ERR_SPACE_REQUIRED, 3319 "Space required after 'PUBLIC'\n", NULL, NULL); 3320 } 3321 SKIP_BLANKS; 3322 *publicID = htmlParsePubidLiteral(ctxt); 3323 if (*publicID == NULL) { 3324 htmlParseErr(ctxt, XML_ERR_PUBID_REQUIRED, 3325 "htmlParseExternalID: PUBLIC, no Public Identifier\n", 3326 NULL, NULL); 3327 } 3328 SKIP_BLANKS; 3329 if ((CUR == '"') || (CUR == '\'')) { 3330 URI = htmlParseSystemLiteral(ctxt); 3331 } 3332 } 3333 return(URI); 3334 } 3335 3336 /** 3337 * xmlParsePI: 3338 * @ctxt: an XML parser context 3339 * 3340 * parse an XML Processing Instruction. 3341 * 3342 * [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>' 3343 */ 3344 static void 3345 htmlParsePI(htmlParserCtxtPtr ctxt) { 3346 xmlChar *buf = NULL; 3347 int len = 0; 3348 int size = HTML_PARSER_BUFFER_SIZE; 3349 int cur, l; 3350 const xmlChar *target; 3351 xmlParserInputState state; 3352 int count = 0; 3353 3354 if ((RAW == '<') && (NXT(1) == '?')) { 3355 state = ctxt->instate; 3356 ctxt->instate = XML_PARSER_PI; 3357 /* 3358 * this is a Processing Instruction. 3359 */ 3360 SKIP(2); 3361 SHRINK; 3362 3363 /* 3364 * Parse the target name and check for special support like 3365 * namespace. 3366 */ 3367 target = htmlParseName(ctxt); 3368 if (target != NULL) { 3369 if (RAW == '>') { 3370 SKIP(1); 3371 3372 /* 3373 * SAX: PI detected. 3374 */ 3375 if ((ctxt->sax) && (!ctxt->disableSAX) && 3376 (ctxt->sax->processingInstruction != NULL)) 3377 ctxt->sax->processingInstruction(ctxt->userData, 3378 target, NULL); 3379 ctxt->instate = state; 3380 return; 3381 } 3382 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 3383 if (buf == NULL) { 3384 htmlErrMemory(ctxt, NULL); 3385 ctxt->instate = state; 3386 return; 3387 } 3388 cur = CUR; 3389 if (!IS_BLANK(cur)) { 3390 htmlParseErr(ctxt, XML_ERR_SPACE_REQUIRED, 3391 "ParsePI: PI %s space expected\n", target, NULL); 3392 } 3393 SKIP_BLANKS; 3394 cur = CUR_CHAR(l); 3395 while ((cur != 0) && (cur != '>')) { 3396 if (len + 5 >= size) { 3397 xmlChar *tmp; 3398 3399 size *= 2; 3400 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 3401 if (tmp == NULL) { 3402 htmlErrMemory(ctxt, NULL); 3403 xmlFree(buf); 3404 ctxt->instate = state; 3405 return; 3406 } 3407 buf = tmp; 3408 } 3409 count++; 3410 if (count > 50) { 3411 GROW; 3412 count = 0; 3413 } 3414 if (IS_CHAR(cur)) { 3415 COPY_BUF(l,buf,len,cur); 3416 } else { 3417 htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR, 3418 "Invalid char in processing instruction " 3419 "0x%X\n", cur); 3420 } 3421 NEXTL(l); 3422 cur = CUR_CHAR(l); 3423 if (cur == 0) { 3424 SHRINK; 3425 GROW; 3426 cur = CUR_CHAR(l); 3427 } 3428 } 3429 buf[len] = 0; 3430 if (cur != '>') { 3431 htmlParseErr(ctxt, XML_ERR_PI_NOT_FINISHED, 3432 "ParsePI: PI %s never end ...\n", target, NULL); 3433 } else { 3434 SKIP(1); 3435 3436 /* 3437 * SAX: PI detected. 3438 */ 3439 if ((ctxt->sax) && (!ctxt->disableSAX) && 3440 (ctxt->sax->processingInstruction != NULL)) 3441 ctxt->sax->processingInstruction(ctxt->userData, 3442 target, buf); 3443 } 3444 xmlFree(buf); 3445 } else { 3446 htmlParseErr(ctxt, XML_ERR_PI_NOT_STARTED, 3447 "PI is not started correctly", NULL, NULL); 3448 } 3449 ctxt->instate = state; 3450 } 3451 } 3452 3453 /** 3454 * htmlParseComment: 3455 * @ctxt: an HTML parser context 3456 * 3457 * Parse an XML (SGML) comment <!-- .... --> 3458 * 3459 * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->' 3460 */ 3461 static void 3462 htmlParseComment(htmlParserCtxtPtr ctxt) { 3463 xmlChar *buf = NULL; 3464 int len; 3465 int size = HTML_PARSER_BUFFER_SIZE; 3466 int q, ql; 3467 int r, rl; 3468 int cur, l; 3469 int next, nl; 3470 xmlParserInputState state; 3471 3472 /* 3473 * Check that there is a comment right here. 3474 */ 3475 if ((RAW != '<') || (NXT(1) != '!') || 3476 (NXT(2) != '-') || (NXT(3) != '-')) return; 3477 3478 state = ctxt->instate; 3479 ctxt->instate = XML_PARSER_COMMENT; 3480 SHRINK; 3481 SKIP(4); 3482 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 3483 if (buf == NULL) { 3484 htmlErrMemory(ctxt, "buffer allocation failed\n"); 3485 ctxt->instate = state; 3486 return; 3487 } 3488 len = 0; 3489 buf[len] = 0; 3490 q = CUR_CHAR(ql); 3491 if (q == 0) 3492 goto unfinished; 3493 if (q == '>') { 3494 htmlParseErr(ctxt, XML_ERR_COMMENT_ABRUPTLY_ENDED, "Comment abruptly ended", NULL, NULL); 3495 cur = '>'; 3496 goto finished; 3497 } 3498 NEXTL(ql); 3499 r = CUR_CHAR(rl); 3500 if (r == 0) 3501 goto unfinished; 3502 if (q == '-' && r == '>') { 3503 htmlParseErr(ctxt, XML_ERR_COMMENT_ABRUPTLY_ENDED, "Comment abruptly ended", NULL, NULL); 3504 cur = '>'; 3505 goto finished; 3506 } 3507 NEXTL(rl); 3508 cur = CUR_CHAR(l); 3509 while ((cur != 0) && 3510 ((cur != '>') || 3511 (r != '-') || (q != '-'))) { 3512 NEXTL(l); 3513 next = CUR_CHAR(nl); 3514 if (next == 0) { 3515 SHRINK; 3516 GROW; 3517 next = CUR_CHAR(nl); 3518 } 3519 3520 if ((q == '-') && (r == '-') && (cur == '!') && (next == '>')) { 3521 htmlParseErr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, 3522 "Comment incorrectly closed by '--!>'", NULL, NULL); 3523 cur = '>'; 3524 break; 3525 } 3526 3527 if (len + 5 >= size) { 3528 xmlChar *tmp; 3529 3530 size *= 2; 3531 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 3532 if (tmp == NULL) { 3533 xmlFree(buf); 3534 htmlErrMemory(ctxt, "growing buffer failed\n"); 3535 ctxt->instate = state; 3536 return; 3537 } 3538 buf = tmp; 3539 } 3540 if (IS_CHAR(q)) { 3541 COPY_BUF(ql,buf,len,q); 3542 } else { 3543 htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR, 3544 "Invalid char in comment 0x%X\n", q); 3545 } 3546 3547 q = r; 3548 ql = rl; 3549 r = cur; 3550 rl = l; 3551 cur = next; 3552 l = nl; 3553 } 3554 finished: 3555 buf[len] = 0; 3556 if (cur == '>') { 3557 NEXT; 3558 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) && 3559 (!ctxt->disableSAX)) 3560 ctxt->sax->comment(ctxt->userData, buf); 3561 xmlFree(buf); 3562 ctxt->instate = state; 3563 return; 3564 } 3565 3566 unfinished: 3567 htmlParseErr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, 3568 "Comment not terminated \n<!--%.50s\n", buf, NULL); 3569 xmlFree(buf); 3570 } 3571 3572 /** 3573 * htmlParseCharRef: 3574 * @ctxt: an HTML parser context 3575 * 3576 * parse Reference declarations 3577 * 3578 * [66] CharRef ::= '&#' [0-9]+ ';' | 3579 * '&#x' [0-9a-fA-F]+ ';' 3580 * 3581 * Returns the value parsed (as an int) 3582 */ 3583 int 3584 htmlParseCharRef(htmlParserCtxtPtr ctxt) { 3585 int val = 0; 3586 3587 if ((ctxt == NULL) || (ctxt->input == NULL)) { 3588 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 3589 "htmlParseCharRef: context error\n", 3590 NULL, NULL); 3591 return(0); 3592 } 3593 if ((CUR == '&') && (NXT(1) == '#') && 3594 ((NXT(2) == 'x') || NXT(2) == 'X')) { 3595 SKIP(3); 3596 while (CUR != ';') { 3597 if ((CUR >= '0') && (CUR <= '9')) { 3598 if (val < 0x110000) 3599 val = val * 16 + (CUR - '0'); 3600 } else if ((CUR >= 'a') && (CUR <= 'f')) { 3601 if (val < 0x110000) 3602 val = val * 16 + (CUR - 'a') + 10; 3603 } else if ((CUR >= 'A') && (CUR <= 'F')) { 3604 if (val < 0x110000) 3605 val = val * 16 + (CUR - 'A') + 10; 3606 } else { 3607 htmlParseErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, 3608 "htmlParseCharRef: missing semicolon\n", 3609 NULL, NULL); 3610 break; 3611 } 3612 NEXT; 3613 } 3614 if (CUR == ';') 3615 NEXT; 3616 } else if ((CUR == '&') && (NXT(1) == '#')) { 3617 SKIP(2); 3618 while (CUR != ';') { 3619 if ((CUR >= '0') && (CUR <= '9')) { 3620 if (val < 0x110000) 3621 val = val * 10 + (CUR - '0'); 3622 } else { 3623 htmlParseErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, 3624 "htmlParseCharRef: missing semicolon\n", 3625 NULL, NULL); 3626 break; 3627 } 3628 NEXT; 3629 } 3630 if (CUR == ';') 3631 NEXT; 3632 } else { 3633 htmlParseErr(ctxt, XML_ERR_INVALID_CHARREF, 3634 "htmlParseCharRef: invalid value\n", NULL, NULL); 3635 } 3636 /* 3637 * Check the value IS_CHAR ... 3638 */ 3639 if (IS_CHAR(val)) { 3640 return(val); 3641 } else if (val >= 0x110000) { 3642 htmlParseErr(ctxt, XML_ERR_INVALID_CHAR, 3643 "htmlParseCharRef: value too large\n", NULL, NULL); 3644 } else { 3645 htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR, 3646 "htmlParseCharRef: invalid xmlChar value %d\n", 3647 val); 3648 } 3649 return(0); 3650 } 3651 3652 3653 /** 3654 * htmlParseDocTypeDecl: 3655 * @ctxt: an HTML parser context 3656 * 3657 * parse a DOCTYPE declaration 3658 * 3659 * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? 3660 * ('[' (markupdecl | PEReference | S)* ']' S?)? '>' 3661 */ 3662 3663 static void 3664 htmlParseDocTypeDecl(htmlParserCtxtPtr ctxt) { 3665 const xmlChar *name; 3666 xmlChar *ExternalID = NULL; 3667 xmlChar *URI = NULL; 3668 3669 /* 3670 * We know that '<!DOCTYPE' has been detected. 3671 */ 3672 SKIP(9); 3673 3674 SKIP_BLANKS; 3675 3676 /* 3677 * Parse the DOCTYPE name. 3678 */ 3679 name = htmlParseName(ctxt); 3680 if (name == NULL) { 3681 htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED, 3682 "htmlParseDocTypeDecl : no DOCTYPE name !\n", 3683 NULL, NULL); 3684 } 3685 /* 3686 * Check that upper(name) == "HTML" !!!!!!!!!!!!! 3687 */ 3688 3689 SKIP_BLANKS; 3690 3691 /* 3692 * Check for SystemID and ExternalID 3693 */ 3694 URI = htmlParseExternalID(ctxt, &ExternalID); 3695 SKIP_BLANKS; 3696 3697 /* 3698 * We should be at the end of the DOCTYPE declaration. 3699 */ 3700 if (CUR != '>') { 3701 htmlParseErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, 3702 "DOCTYPE improperly terminated\n", NULL, NULL); 3703 /* Ignore bogus content */ 3704 while ((CUR != 0) && (CUR != '>')) 3705 NEXT; 3706 } 3707 if (CUR == '>') 3708 NEXT; 3709 3710 /* 3711 * Create or update the document accordingly to the DOCTYPE 3712 */ 3713 if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) && 3714 (!ctxt->disableSAX)) 3715 ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI); 3716 3717 /* 3718 * Cleanup, since we don't use all those identifiers 3719 */ 3720 if (URI != NULL) xmlFree(URI); 3721 if (ExternalID != NULL) xmlFree(ExternalID); 3722 } 3723 3724 /** 3725 * htmlParseAttribute: 3726 * @ctxt: an HTML parser context 3727 * @value: a xmlChar ** used to store the value of the attribute 3728 * 3729 * parse an attribute 3730 * 3731 * [41] Attribute ::= Name Eq AttValue 3732 * 3733 * [25] Eq ::= S? '=' S? 3734 * 3735 * With namespace: 3736 * 3737 * [NS 11] Attribute ::= QName Eq AttValue 3738 * 3739 * Also the case QName == xmlns:??? is handled independently as a namespace 3740 * definition. 3741 * 3742 * Returns the attribute name, and the value in *value. 3743 */ 3744 3745 static const xmlChar * 3746 htmlParseAttribute(htmlParserCtxtPtr ctxt, xmlChar **value) { 3747 const xmlChar *name; 3748 xmlChar *val = NULL; 3749 3750 *value = NULL; 3751 name = htmlParseHTMLName(ctxt); 3752 if (name == NULL) { 3753 htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED, 3754 "error parsing attribute name\n", NULL, NULL); 3755 return(NULL); 3756 } 3757 3758 /* 3759 * read the value 3760 */ 3761 SKIP_BLANKS; 3762 if (CUR == '=') { 3763 NEXT; 3764 SKIP_BLANKS; 3765 val = htmlParseAttValue(ctxt); 3766 } 3767 3768 *value = val; 3769 return(name); 3770 } 3771 3772 /** 3773 * htmlCheckEncodingDirect: 3774 * @ctxt: an HTML parser context 3775 * @attvalue: the attribute value 3776 * 3777 * Checks an attribute value to detect 3778 * the encoding 3779 * If a new encoding is detected the parser is switched to decode 3780 * it and pass UTF8 3781 */ 3782 static void 3783 htmlCheckEncodingDirect(htmlParserCtxtPtr ctxt, const xmlChar *encoding) { 3784 3785 if ((ctxt == NULL) || (encoding == NULL) || 3786 (ctxt->options & HTML_PARSE_IGNORE_ENC)) 3787 return; 3788 3789 /* do not change encoding */ 3790 if (ctxt->input->encoding != NULL) 3791 return; 3792 3793 if (encoding != NULL) { 3794 xmlCharEncoding enc; 3795 xmlCharEncodingHandlerPtr handler; 3796 3797 while ((*encoding == ' ') || (*encoding == '\t')) encoding++; 3798 3799 if (ctxt->input->encoding != NULL) 3800 xmlFree((xmlChar *) ctxt->input->encoding); 3801 ctxt->input->encoding = xmlStrdup(encoding); 3802 3803 enc = xmlParseCharEncoding((const char *) encoding); 3804 /* 3805 * registered set of known encodings 3806 */ 3807 if (enc != XML_CHAR_ENCODING_ERROR) { 3808 if (((enc == XML_CHAR_ENCODING_UTF16LE) || 3809 (enc == XML_CHAR_ENCODING_UTF16BE) || 3810 (enc == XML_CHAR_ENCODING_UCS4LE) || 3811 (enc == XML_CHAR_ENCODING_UCS4BE)) && 3812 (ctxt->input->buf != NULL) && 3813 (ctxt->input->buf->encoder == NULL)) { 3814 htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING, 3815 "htmlCheckEncoding: wrong encoding meta\n", 3816 NULL, NULL); 3817 } else { 3818 xmlSwitchEncoding(ctxt, enc); 3819 } 3820 ctxt->charset = XML_CHAR_ENCODING_UTF8; 3821 } else { 3822 /* 3823 * fallback for unknown encodings 3824 */ 3825 handler = xmlFindCharEncodingHandler((const char *) encoding); 3826 if (handler != NULL) { 3827 xmlSwitchToEncoding(ctxt, handler); 3828 ctxt->charset = XML_CHAR_ENCODING_UTF8; 3829 } else { 3830 htmlParseErr(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 3831 "htmlCheckEncoding: unknown encoding %s\n", 3832 encoding, NULL); 3833 } 3834 } 3835 3836 if ((ctxt->input->buf != NULL) && 3837 (ctxt->input->buf->encoder != NULL) && 3838 (ctxt->input->buf->raw != NULL) && 3839 (ctxt->input->buf->buffer != NULL)) { 3840 int nbchars; 3841 int processed; 3842 3843 /* 3844 * convert as much as possible to the parser reading buffer. 3845 */ 3846 processed = ctxt->input->cur - ctxt->input->base; 3847 xmlBufShrink(ctxt->input->buf->buffer, processed); 3848 nbchars = xmlCharEncInput(ctxt->input->buf, 1); 3849 xmlBufResetInput(ctxt->input->buf->buffer, ctxt->input); 3850 if (nbchars < 0) { 3851 htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING, 3852 "htmlCheckEncoding: encoder error\n", 3853 NULL, NULL); 3854 } 3855 } 3856 } 3857 } 3858 3859 /** 3860 * htmlCheckEncoding: 3861 * @ctxt: an HTML parser context 3862 * @attvalue: the attribute value 3863 * 3864 * Checks an http-equiv attribute from a Meta tag to detect 3865 * the encoding 3866 * If a new encoding is detected the parser is switched to decode 3867 * it and pass UTF8 3868 */ 3869 static void 3870 htmlCheckEncoding(htmlParserCtxtPtr ctxt, const xmlChar *attvalue) { 3871 const xmlChar *encoding; 3872 3873 if (!attvalue) 3874 return; 3875 3876 encoding = xmlStrcasestr(attvalue, BAD_CAST"charset"); 3877 if (encoding != NULL) { 3878 encoding += 7; 3879 } 3880 /* 3881 * skip blank 3882 */ 3883 if (encoding && IS_BLANK_CH(*encoding)) 3884 encoding = xmlStrcasestr(attvalue, BAD_CAST"="); 3885 if (encoding && *encoding == '=') { 3886 encoding ++; 3887 htmlCheckEncodingDirect(ctxt, encoding); 3888 } 3889 } 3890 3891 /** 3892 * htmlCheckMeta: 3893 * @ctxt: an HTML parser context 3894 * @atts: the attributes values 3895 * 3896 * Checks an attributes from a Meta tag 3897 */ 3898 static void 3899 htmlCheckMeta(htmlParserCtxtPtr ctxt, const xmlChar **atts) { 3900 int i; 3901 const xmlChar *att, *value; 3902 int http = 0; 3903 const xmlChar *content = NULL; 3904 3905 if ((ctxt == NULL) || (atts == NULL)) 3906 return; 3907 3908 i = 0; 3909 att = atts[i++]; 3910 while (att != NULL) { 3911 value = atts[i++]; 3912 if ((value != NULL) && (!xmlStrcasecmp(att, BAD_CAST"http-equiv")) 3913 && (!xmlStrcasecmp(value, BAD_CAST"Content-Type"))) 3914 http = 1; 3915 else if ((value != NULL) && (!xmlStrcasecmp(att, BAD_CAST"charset"))) 3916 htmlCheckEncodingDirect(ctxt, value); 3917 else if ((value != NULL) && (!xmlStrcasecmp(att, BAD_CAST"content"))) 3918 content = value; 3919 att = atts[i++]; 3920 } 3921 if ((http) && (content != NULL)) 3922 htmlCheckEncoding(ctxt, content); 3923 3924 } 3925 3926 /** 3927 * htmlParseStartTag: 3928 * @ctxt: an HTML parser context 3929 * 3930 * parse a start of tag either for rule element or 3931 * EmptyElement. In both case we don't parse the tag closing chars. 3932 * 3933 * [40] STag ::= '<' Name (S Attribute)* S? '>' 3934 * 3935 * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>' 3936 * 3937 * With namespace: 3938 * 3939 * [NS 8] STag ::= '<' QName (S Attribute)* S? '>' 3940 * 3941 * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>' 3942 * 3943 * Returns 0 in case of success, -1 in case of error and 1 if discarded 3944 */ 3945 3946 static int 3947 htmlParseStartTag(htmlParserCtxtPtr ctxt) { 3948 const xmlChar *name; 3949 const xmlChar *attname; 3950 xmlChar *attvalue; 3951 const xmlChar **atts; 3952 int nbatts = 0; 3953 int maxatts; 3954 int meta = 0; 3955 int i; 3956 int discardtag = 0; 3957 3958 if ((ctxt == NULL) || (ctxt->input == NULL)) { 3959 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 3960 "htmlParseStartTag: context error\n", NULL, NULL); 3961 return -1; 3962 } 3963 if (ctxt->instate == XML_PARSER_EOF) 3964 return(-1); 3965 if (CUR != '<') return -1; 3966 NEXT; 3967 3968 atts = ctxt->atts; 3969 maxatts = ctxt->maxatts; 3970 3971 GROW; 3972 name = htmlParseHTMLName(ctxt); 3973 if (name == NULL) { 3974 htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED, 3975 "htmlParseStartTag: invalid element name\n", 3976 NULL, NULL); 3977 /* Dump the bogus tag like browsers do */ 3978 while ((CUR != 0) && (CUR != '>') && 3979 (ctxt->instate != XML_PARSER_EOF)) 3980 NEXT; 3981 return -1; 3982 } 3983 if (xmlStrEqual(name, BAD_CAST"meta")) 3984 meta = 1; 3985 3986 /* 3987 * Check for auto-closure of HTML elements. 3988 */ 3989 htmlAutoClose(ctxt, name); 3990 3991 /* 3992 * Check for implied HTML elements. 3993 */ 3994 htmlCheckImplied(ctxt, name); 3995 3996 /* 3997 * Avoid html at any level > 0, head at any level != 1 3998 * or any attempt to recurse body 3999 */ 4000 if ((ctxt->nameNr > 0) && (xmlStrEqual(name, BAD_CAST"html"))) { 4001 htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR, 4002 "htmlParseStartTag: misplaced <html> tag\n", 4003 name, NULL); 4004 discardtag = 1; 4005 ctxt->depth++; 4006 } 4007 if ((ctxt->nameNr != 1) && 4008 (xmlStrEqual(name, BAD_CAST"head"))) { 4009 htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR, 4010 "htmlParseStartTag: misplaced <head> tag\n", 4011 name, NULL); 4012 discardtag = 1; 4013 ctxt->depth++; 4014 } 4015 if (xmlStrEqual(name, BAD_CAST"body")) { 4016 int indx; 4017 for (indx = 0;indx < ctxt->nameNr;indx++) { 4018 if (xmlStrEqual(ctxt->nameTab[indx], BAD_CAST"body")) { 4019 htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR, 4020 "htmlParseStartTag: misplaced <body> tag\n", 4021 name, NULL); 4022 discardtag = 1; 4023 ctxt->depth++; 4024 } 4025 } 4026 } 4027 4028 /* 4029 * Now parse the attributes, it ends up with the ending 4030 * 4031 * (S Attribute)* S? 4032 */ 4033 SKIP_BLANKS; 4034 while ((CUR != 0) && 4035 (CUR != '>') && 4036 ((CUR != '/') || (NXT(1) != '>'))) { 4037 GROW; 4038 attname = htmlParseAttribute(ctxt, &attvalue); 4039 if (attname != NULL) { 4040 4041 /* 4042 * Well formedness requires at most one declaration of an attribute 4043 */ 4044 for (i = 0; i < nbatts;i += 2) { 4045 if (xmlStrEqual(atts[i], attname)) { 4046 htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_REDEFINED, 4047 "Attribute %s redefined\n", attname, NULL); 4048 if (attvalue != NULL) 4049 xmlFree(attvalue); 4050 goto failed; 4051 } 4052 } 4053 4054 /* 4055 * Add the pair to atts 4056 */ 4057 if (atts == NULL) { 4058 maxatts = 22; /* allow for 10 attrs by default */ 4059 atts = (const xmlChar **) 4060 xmlMalloc(maxatts * sizeof(xmlChar *)); 4061 if (atts == NULL) { 4062 htmlErrMemory(ctxt, NULL); 4063 if (attvalue != NULL) 4064 xmlFree(attvalue); 4065 goto failed; 4066 } 4067 ctxt->atts = atts; 4068 ctxt->maxatts = maxatts; 4069 } else if (nbatts + 4 > maxatts) { 4070 const xmlChar **n; 4071 4072 maxatts *= 2; 4073 n = (const xmlChar **) xmlRealloc((void *) atts, 4074 maxatts * sizeof(const xmlChar *)); 4075 if (n == NULL) { 4076 htmlErrMemory(ctxt, NULL); 4077 if (attvalue != NULL) 4078 xmlFree(attvalue); 4079 goto failed; 4080 } 4081 atts = n; 4082 ctxt->atts = atts; 4083 ctxt->maxatts = maxatts; 4084 } 4085 atts[nbatts++] = attname; 4086 atts[nbatts++] = attvalue; 4087 atts[nbatts] = NULL; 4088 atts[nbatts + 1] = NULL; 4089 } 4090 else { 4091 if (attvalue != NULL) 4092 xmlFree(attvalue); 4093 /* Dump the bogus attribute string up to the next blank or 4094 * the end of the tag. */ 4095 while ((CUR != 0) && 4096 !(IS_BLANK_CH(CUR)) && (CUR != '>') && 4097 ((CUR != '/') || (NXT(1) != '>'))) 4098 NEXT; 4099 } 4100 4101 failed: 4102 SKIP_BLANKS; 4103 } 4104 4105 /* 4106 * Handle specific association to the META tag 4107 */ 4108 if (meta && (nbatts != 0)) 4109 htmlCheckMeta(ctxt, atts); 4110 4111 /* 4112 * SAX: Start of Element ! 4113 */ 4114 if (!discardtag) { 4115 htmlnamePush(ctxt, name); 4116 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL)) { 4117 if (nbatts != 0) 4118 ctxt->sax->startElement(ctxt->userData, name, atts); 4119 else 4120 ctxt->sax->startElement(ctxt->userData, name, NULL); 4121 } 4122 } 4123 4124 if (atts != NULL) { 4125 for (i = 1;i < nbatts;i += 2) { 4126 if (atts[i] != NULL) 4127 xmlFree((xmlChar *) atts[i]); 4128 } 4129 } 4130 4131 return(discardtag); 4132 } 4133 4134 /** 4135 * htmlParseEndTag: 4136 * @ctxt: an HTML parser context 4137 * 4138 * parse an end of tag 4139 * 4140 * [42] ETag ::= '</' Name S? '>' 4141 * 4142 * With namespace 4143 * 4144 * [NS 9] ETag ::= '</' QName S? '>' 4145 * 4146 * Returns 1 if the current level should be closed. 4147 */ 4148 4149 static int 4150 htmlParseEndTag(htmlParserCtxtPtr ctxt) 4151 { 4152 const xmlChar *name; 4153 const xmlChar *oldname; 4154 int i, ret; 4155 4156 if ((CUR != '<') || (NXT(1) != '/')) { 4157 htmlParseErr(ctxt, XML_ERR_LTSLASH_REQUIRED, 4158 "htmlParseEndTag: '</' not found\n", NULL, NULL); 4159 return (0); 4160 } 4161 SKIP(2); 4162 4163 name = htmlParseHTMLName(ctxt); 4164 if (name == NULL) 4165 return (0); 4166 /* 4167 * We should definitely be at the ending "S? '>'" part 4168 */ 4169 SKIP_BLANKS; 4170 if (CUR != '>') { 4171 htmlParseErr(ctxt, XML_ERR_GT_REQUIRED, 4172 "End tag : expected '>'\n", NULL, NULL); 4173 /* Skip to next '>' */ 4174 while ((CUR != 0) && (CUR != '>')) 4175 NEXT; 4176 } 4177 if (CUR == '>') 4178 NEXT; 4179 4180 /* 4181 * if we ignored misplaced tags in htmlParseStartTag don't pop them 4182 * out now. 4183 */ 4184 if ((ctxt->depth > 0) && 4185 (xmlStrEqual(name, BAD_CAST "html") || 4186 xmlStrEqual(name, BAD_CAST "body") || 4187 xmlStrEqual(name, BAD_CAST "head"))) { 4188 ctxt->depth--; 4189 return (0); 4190 } 4191 4192 /* 4193 * If the name read is not one of the element in the parsing stack 4194 * then return, it's just an error. 4195 */ 4196 for (i = (ctxt->nameNr - 1); i >= 0; i--) { 4197 if (xmlStrEqual(name, ctxt->nameTab[i])) 4198 break; 4199 } 4200 if (i < 0) { 4201 htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH, 4202 "Unexpected end tag : %s\n", name, NULL); 4203 return (0); 4204 } 4205 4206 4207 /* 4208 * Check for auto-closure of HTML elements. 4209 */ 4210 4211 htmlAutoCloseOnClose(ctxt, name); 4212 4213 /* 4214 * Well formedness constraints, opening and closing must match. 4215 * With the exception that the autoclose may have popped stuff out 4216 * of the stack. 4217 */ 4218 if ((ctxt->name != NULL) && (!xmlStrEqual(ctxt->name, name))) { 4219 htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH, 4220 "Opening and ending tag mismatch: %s and %s\n", 4221 name, ctxt->name); 4222 } 4223 4224 /* 4225 * SAX: End of Tag 4226 */ 4227 oldname = ctxt->name; 4228 if ((oldname != NULL) && (xmlStrEqual(oldname, name))) { 4229 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL)) 4230 ctxt->sax->endElement(ctxt->userData, name); 4231 htmlNodeInfoPop(ctxt); 4232 htmlnamePop(ctxt); 4233 ret = 1; 4234 } else { 4235 ret = 0; 4236 } 4237 4238 return (ret); 4239 } 4240 4241 4242 /** 4243 * htmlParseReference: 4244 * @ctxt: an HTML parser context 4245 * 4246 * parse and handle entity references in content, 4247 * this will end-up in a call to character() since this is either a 4248 * CharRef, or a predefined entity. 4249 */ 4250 static void 4251 htmlParseReference(htmlParserCtxtPtr ctxt) { 4252 const htmlEntityDesc * ent; 4253 xmlChar out[6]; 4254 const xmlChar *name; 4255 if (CUR != '&') return; 4256 4257 if (NXT(1) == '#') { 4258 unsigned int c; 4259 int bits, i = 0; 4260 4261 c = htmlParseCharRef(ctxt); 4262 if (c == 0) 4263 return; 4264 4265 if (c < 0x80) { out[i++]= c; bits= -6; } 4266 else if (c < 0x800) { out[i++]=((c >> 6) & 0x1F) | 0xC0; bits= 0; } 4267 else if (c < 0x10000) { out[i++]=((c >> 12) & 0x0F) | 0xE0; bits= 6; } 4268 else { out[i++]=((c >> 18) & 0x07) | 0xF0; bits= 12; } 4269 4270 for ( ; bits >= 0; bits-= 6) { 4271 out[i++]= ((c >> bits) & 0x3F) | 0x80; 4272 } 4273 out[i] = 0; 4274 4275 htmlCheckParagraph(ctxt); 4276 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL)) 4277 ctxt->sax->characters(ctxt->userData, out, i); 4278 } else { 4279 ent = htmlParseEntityRef(ctxt, &name); 4280 if (name == NULL) { 4281 htmlCheckParagraph(ctxt); 4282 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL)) 4283 ctxt->sax->characters(ctxt->userData, BAD_CAST "&", 1); 4284 return; 4285 } 4286 if ((ent == NULL) || !(ent->value > 0)) { 4287 htmlCheckParagraph(ctxt); 4288 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL)) { 4289 ctxt->sax->characters(ctxt->userData, BAD_CAST "&", 1); 4290 ctxt->sax->characters(ctxt->userData, name, xmlStrlen(name)); 4291 /* ctxt->sax->characters(ctxt->userData, BAD_CAST ";", 1); */ 4292 } 4293 } else { 4294 unsigned int c; 4295 int bits, i = 0; 4296 4297 c = ent->value; 4298 if (c < 0x80) 4299 { out[i++]= c; bits= -6; } 4300 else if (c < 0x800) 4301 { out[i++]=((c >> 6) & 0x1F) | 0xC0; bits= 0; } 4302 else if (c < 0x10000) 4303 { out[i++]=((c >> 12) & 0x0F) | 0xE0; bits= 6; } 4304 else 4305 { out[i++]=((c >> 18) & 0x07) | 0xF0; bits= 12; } 4306 4307 for ( ; bits >= 0; bits-= 6) { 4308 out[i++]= ((c >> bits) & 0x3F) | 0x80; 4309 } 4310 out[i] = 0; 4311 4312 htmlCheckParagraph(ctxt); 4313 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL)) 4314 ctxt->sax->characters(ctxt->userData, out, i); 4315 } 4316 } 4317 } 4318 4319 /** 4320 * htmlParseContent: 4321 * @ctxt: an HTML parser context 4322 * 4323 * Parse a content: comment, sub-element, reference or text. 4324 * Kept for compatibility with old code 4325 */ 4326 4327 static void 4328 htmlParseContent(htmlParserCtxtPtr ctxt) { 4329 xmlChar *currentNode; 4330 int depth; 4331 const xmlChar *name; 4332 4333 currentNode = xmlStrdup(ctxt->name); 4334 depth = ctxt->nameNr; 4335 while (1) { 4336 GROW; 4337 4338 if (ctxt->instate == XML_PARSER_EOF) 4339 break; 4340 4341 /* 4342 * Our tag or one of it's parent or children is ending. 4343 */ 4344 if ((CUR == '<') && (NXT(1) == '/')) { 4345 if (htmlParseEndTag(ctxt) && 4346 ((currentNode != NULL) || (ctxt->nameNr == 0))) { 4347 if (currentNode != NULL) 4348 xmlFree(currentNode); 4349 return; 4350 } 4351 continue; /* while */ 4352 } 4353 4354 else if ((CUR == '<') && 4355 ((IS_ASCII_LETTER(NXT(1))) || 4356 (NXT(1) == '_') || (NXT(1) == ':'))) { 4357 name = htmlParseHTMLName_nonInvasive(ctxt); 4358 if (name == NULL) { 4359 htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED, 4360 "htmlParseStartTag: invalid element name\n", 4361 NULL, NULL); 4362 /* Dump the bogus tag like browsers do */ 4363 while ((CUR != 0) && (CUR != '>')) 4364 NEXT; 4365 4366 if (currentNode != NULL) 4367 xmlFree(currentNode); 4368 return; 4369 } 4370 4371 if (ctxt->name != NULL) { 4372 if (htmlCheckAutoClose(name, ctxt->name) == 1) { 4373 htmlAutoClose(ctxt, name); 4374 continue; 4375 } 4376 } 4377 } 4378 4379 /* 4380 * Has this node been popped out during parsing of 4381 * the next element 4382 */ 4383 if ((ctxt->nameNr > 0) && (depth >= ctxt->nameNr) && 4384 (!xmlStrEqual(currentNode, ctxt->name))) 4385 { 4386 if (currentNode != NULL) xmlFree(currentNode); 4387 return; 4388 } 4389 4390 if ((CUR != 0) && ((xmlStrEqual(currentNode, BAD_CAST"script")) || 4391 (xmlStrEqual(currentNode, BAD_CAST"style")))) { 4392 /* 4393 * Handle SCRIPT/STYLE separately 4394 */ 4395 htmlParseScript(ctxt); 4396 } 4397 4398 else if ((CUR == '<') && (NXT(1) == '!')) { 4399 /* 4400 * Sometimes DOCTYPE arrives in the middle of the document 4401 */ 4402 if ((UPP(2) == 'D') && (UPP(3) == 'O') && 4403 (UPP(4) == 'C') && (UPP(5) == 'T') && 4404 (UPP(6) == 'Y') && (UPP(7) == 'P') && 4405 (UPP(8) == 'E')) { 4406 htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR, 4407 "Misplaced DOCTYPE declaration\n", 4408 BAD_CAST "DOCTYPE" , NULL); 4409 htmlParseDocTypeDecl(ctxt); 4410 } 4411 /* 4412 * First case : a comment 4413 */ 4414 else if ((NXT(2) == '-') && (NXT(3) == '-')) { 4415 htmlParseComment(ctxt); 4416 } 4417 else { 4418 htmlSkipBogusComment(ctxt); 4419 } 4420 } 4421 4422 /* 4423 * Second case : a Processing Instruction. 4424 */ 4425 else if ((CUR == '<') && (NXT(1) == '?')) { 4426 htmlParsePI(ctxt); 4427 } 4428 4429 /* 4430 * Third case : a sub-element. 4431 */ 4432 else if ((CUR == '<') && IS_ASCII_LETTER(NXT(1))) { 4433 htmlParseElement(ctxt); 4434 } 4435 else if (CUR == '<') { 4436 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 4437 (ctxt->sax->characters != NULL)) 4438 ctxt->sax->characters(ctxt->userData, BAD_CAST "<", 1); 4439 NEXT; 4440 } 4441 4442 /* 4443 * Fourth case : a reference. If if has not been resolved, 4444 * parsing returns it's Name, create the node 4445 */ 4446 else if (CUR == '&') { 4447 htmlParseReference(ctxt); 4448 } 4449 4450 /* 4451 * Fifth case : end of the resource 4452 */ 4453 else if (CUR == 0) { 4454 htmlAutoCloseOnEnd(ctxt); 4455 break; 4456 } 4457 4458 /* 4459 * Last case, text. Note that References are handled directly. 4460 */ 4461 else { 4462 htmlParseCharData(ctxt); 4463 } 4464 GROW; 4465 } 4466 if (currentNode != NULL) xmlFree(currentNode); 4467 } 4468 4469 /** 4470 * htmlParseElement: 4471 * @ctxt: an HTML parser context 4472 * 4473 * parse an HTML element, this is highly recursive 4474 * this is kept for compatibility with previous code versions 4475 * 4476 * [39] element ::= EmptyElemTag | STag content ETag 4477 * 4478 * [41] Attribute ::= Name Eq AttValue 4479 */ 4480 4481 void 4482 htmlParseElement(htmlParserCtxtPtr ctxt) { 4483 const xmlChar *name; 4484 xmlChar *currentNode = NULL; 4485 const htmlElemDesc * info; 4486 htmlParserNodeInfo node_info; 4487 int failed; 4488 int depth; 4489 const xmlChar *oldptr; 4490 4491 if ((ctxt == NULL) || (ctxt->input == NULL)) { 4492 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 4493 "htmlParseElement: context error\n", NULL, NULL); 4494 return; 4495 } 4496 4497 if (ctxt->instate == XML_PARSER_EOF) 4498 return; 4499 4500 /* Capture start position */ 4501 if (ctxt->record_info) { 4502 node_info.begin_pos = ctxt->input->consumed + 4503 (CUR_PTR - ctxt->input->base); 4504 node_info.begin_line = ctxt->input->line; 4505 } 4506 4507 failed = htmlParseStartTag(ctxt); 4508 name = ctxt->name; 4509 if ((failed == -1) || (name == NULL)) { 4510 if (CUR == '>') 4511 NEXT; 4512 return; 4513 } 4514 4515 /* 4516 * Lookup the info for that element. 4517 */ 4518 info = htmlTagLookup(name); 4519 if (info == NULL) { 4520 htmlParseErr(ctxt, XML_HTML_UNKNOWN_TAG, 4521 "Tag %s invalid\n", name, NULL); 4522 } 4523 4524 /* 4525 * Check for an Empty Element labeled the XML/SGML way 4526 */ 4527 if ((CUR == '/') && (NXT(1) == '>')) { 4528 SKIP(2); 4529 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL)) 4530 ctxt->sax->endElement(ctxt->userData, name); 4531 htmlnamePop(ctxt); 4532 return; 4533 } 4534 4535 if (CUR == '>') { 4536 NEXT; 4537 } else { 4538 htmlParseErr(ctxt, XML_ERR_GT_REQUIRED, 4539 "Couldn't find end of Start Tag %s\n", name, NULL); 4540 4541 /* 4542 * end of parsing of this node. 4543 */ 4544 if (xmlStrEqual(name, ctxt->name)) { 4545 nodePop(ctxt); 4546 htmlnamePop(ctxt); 4547 } 4548 4549 /* 4550 * Capture end position and add node 4551 */ 4552 if (ctxt->record_info) { 4553 node_info.end_pos = ctxt->input->consumed + 4554 (CUR_PTR - ctxt->input->base); 4555 node_info.end_line = ctxt->input->line; 4556 node_info.node = ctxt->node; 4557 xmlParserAddNodeInfo(ctxt, &node_info); 4558 } 4559 return; 4560 } 4561 4562 /* 4563 * Check for an Empty Element from DTD definition 4564 */ 4565 if ((info != NULL) && (info->empty)) { 4566 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL)) 4567 ctxt->sax->endElement(ctxt->userData, name); 4568 htmlnamePop(ctxt); 4569 return; 4570 } 4571 4572 /* 4573 * Parse the content of the element: 4574 */ 4575 currentNode = xmlStrdup(ctxt->name); 4576 depth = ctxt->nameNr; 4577 while (CUR != 0) { 4578 oldptr = ctxt->input->cur; 4579 htmlParseContent(ctxt); 4580 if (oldptr==ctxt->input->cur) break; 4581 if (ctxt->nameNr < depth) break; 4582 } 4583 4584 /* 4585 * Capture end position and add node 4586 */ 4587 if ( currentNode != NULL && ctxt->record_info ) { 4588 node_info.end_pos = ctxt->input->consumed + 4589 (CUR_PTR - ctxt->input->base); 4590 node_info.end_line = ctxt->input->line; 4591 node_info.node = ctxt->node; 4592 xmlParserAddNodeInfo(ctxt, &node_info); 4593 } 4594 if (CUR == 0) { 4595 htmlAutoCloseOnEnd(ctxt); 4596 } 4597 4598 if (currentNode != NULL) 4599 xmlFree(currentNode); 4600 } 4601 4602 static void 4603 htmlParserFinishElementParsing(htmlParserCtxtPtr ctxt) { 4604 /* 4605 * Capture end position and add node 4606 */ 4607 if ( ctxt->node != NULL && ctxt->record_info ) { 4608 ctxt->nodeInfo->end_pos = ctxt->input->consumed + 4609 (CUR_PTR - ctxt->input->base); 4610 ctxt->nodeInfo->end_line = ctxt->input->line; 4611 ctxt->nodeInfo->node = ctxt->node; 4612 xmlParserAddNodeInfo(ctxt, ctxt->nodeInfo); 4613 htmlNodeInfoPop(ctxt); 4614 } 4615 if (CUR == 0) { 4616 htmlAutoCloseOnEnd(ctxt); 4617 } 4618 } 4619 4620 /** 4621 * htmlParseElementInternal: 4622 * @ctxt: an HTML parser context 4623 * 4624 * parse an HTML element, new version, non recursive 4625 * 4626 * [39] element ::= EmptyElemTag | STag content ETag 4627 * 4628 * [41] Attribute ::= Name Eq AttValue 4629 */ 4630 4631 static void 4632 htmlParseElementInternal(htmlParserCtxtPtr ctxt) { 4633 const xmlChar *name; 4634 const htmlElemDesc * info; 4635 htmlParserNodeInfo node_info = { NULL, 0, 0, 0, 0 }; 4636 int failed; 4637 4638 if ((ctxt == NULL) || (ctxt->input == NULL)) { 4639 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 4640 "htmlParseElementInternal: context error\n", NULL, NULL); 4641 return; 4642 } 4643 4644 if (ctxt->instate == XML_PARSER_EOF) 4645 return; 4646 4647 /* Capture start position */ 4648 if (ctxt->record_info) { 4649 node_info.begin_pos = ctxt->input->consumed + 4650 (CUR_PTR - ctxt->input->base); 4651 node_info.begin_line = ctxt->input->line; 4652 } 4653 4654 failed = htmlParseStartTag(ctxt); 4655 name = ctxt->name; 4656 if ((failed == -1) || (name == NULL)) { 4657 if (CUR == '>') 4658 NEXT; 4659 return; 4660 } 4661 4662 /* 4663 * Lookup the info for that element. 4664 */ 4665 info = htmlTagLookup(name); 4666 if (info == NULL) { 4667 htmlParseErr(ctxt, XML_HTML_UNKNOWN_TAG, 4668 "Tag %s invalid\n", name, NULL); 4669 } 4670 4671 /* 4672 * Check for an Empty Element labeled the XML/SGML way 4673 */ 4674 if ((CUR == '/') && (NXT(1) == '>')) { 4675 SKIP(2); 4676 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL)) 4677 ctxt->sax->endElement(ctxt->userData, name); 4678 htmlnamePop(ctxt); 4679 return; 4680 } 4681 4682 if (CUR == '>') { 4683 NEXT; 4684 } else { 4685 htmlParseErr(ctxt, XML_ERR_GT_REQUIRED, 4686 "Couldn't find end of Start Tag %s\n", name, NULL); 4687 4688 /* 4689 * end of parsing of this node. 4690 */ 4691 if (xmlStrEqual(name, ctxt->name)) { 4692 nodePop(ctxt); 4693 htmlnamePop(ctxt); 4694 } 4695 4696 if (ctxt->record_info) 4697 htmlNodeInfoPush(ctxt, &node_info); 4698 htmlParserFinishElementParsing(ctxt); 4699 return; 4700 } 4701 4702 /* 4703 * Check for an Empty Element from DTD definition 4704 */ 4705 if ((info != NULL) && (info->empty)) { 4706 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL)) 4707 ctxt->sax->endElement(ctxt->userData, name); 4708 htmlnamePop(ctxt); 4709 return; 4710 } 4711 4712 if (ctxt->record_info) 4713 htmlNodeInfoPush(ctxt, &node_info); 4714 } 4715 4716 /** 4717 * htmlParseContentInternal: 4718 * @ctxt: an HTML parser context 4719 * 4720 * Parse a content: comment, sub-element, reference or text. 4721 * New version for non recursive htmlParseElementInternal 4722 */ 4723 4724 static void 4725 htmlParseContentInternal(htmlParserCtxtPtr ctxt) { 4726 xmlChar *currentNode; 4727 int depth; 4728 const xmlChar *name; 4729 4730 currentNode = xmlStrdup(ctxt->name); 4731 depth = ctxt->nameNr; 4732 while (1) { 4733 GROW; 4734 4735 if (ctxt->instate == XML_PARSER_EOF) 4736 break; 4737 4738 /* 4739 * Our tag or one of it's parent or children is ending. 4740 */ 4741 if ((CUR == '<') && (NXT(1) == '/')) { 4742 if (htmlParseEndTag(ctxt) && 4743 ((currentNode != NULL) || (ctxt->nameNr == 0))) { 4744 if (currentNode != NULL) 4745 xmlFree(currentNode); 4746 4747 currentNode = xmlStrdup(ctxt->name); 4748 depth = ctxt->nameNr; 4749 } 4750 continue; /* while */ 4751 } 4752 4753 else if ((CUR == '<') && 4754 ((IS_ASCII_LETTER(NXT(1))) || 4755 (NXT(1) == '_') || (NXT(1) == ':'))) { 4756 name = htmlParseHTMLName_nonInvasive(ctxt); 4757 if (name == NULL) { 4758 htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED, 4759 "htmlParseStartTag: invalid element name\n", 4760 NULL, NULL); 4761 /* Dump the bogus tag like browsers do */ 4762 while ((CUR == 0) && (CUR != '>')) 4763 NEXT; 4764 4765 htmlParserFinishElementParsing(ctxt); 4766 if (currentNode != NULL) 4767 xmlFree(currentNode); 4768 4769 currentNode = xmlStrdup(ctxt->name); 4770 depth = ctxt->nameNr; 4771 continue; 4772 } 4773 4774 if (ctxt->name != NULL) { 4775 if (htmlCheckAutoClose(name, ctxt->name) == 1) { 4776 htmlAutoClose(ctxt, name); 4777 continue; 4778 } 4779 } 4780 } 4781 4782 /* 4783 * Has this node been popped out during parsing of 4784 * the next element 4785 */ 4786 if ((ctxt->nameNr > 0) && (depth >= ctxt->nameNr) && 4787 (!xmlStrEqual(currentNode, ctxt->name))) 4788 { 4789 htmlParserFinishElementParsing(ctxt); 4790 if (currentNode != NULL) xmlFree(currentNode); 4791 4792 currentNode = xmlStrdup(ctxt->name); 4793 depth = ctxt->nameNr; 4794 continue; 4795 } 4796 4797 if ((CUR != 0) && ((xmlStrEqual(currentNode, BAD_CAST"script")) || 4798 (xmlStrEqual(currentNode, BAD_CAST"style")))) { 4799 /* 4800 * Handle SCRIPT/STYLE separately 4801 */ 4802 htmlParseScript(ctxt); 4803 } 4804 4805 else if ((CUR == '<') && (NXT(1) == '!')) { 4806 /* 4807 * Sometimes DOCTYPE arrives in the middle of the document 4808 */ 4809 if ((UPP(2) == 'D') && (UPP(3) == 'O') && 4810 (UPP(4) == 'C') && (UPP(5) == 'T') && 4811 (UPP(6) == 'Y') && (UPP(7) == 'P') && 4812 (UPP(8) == 'E')) { 4813 htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR, 4814 "Misplaced DOCTYPE declaration\n", 4815 BAD_CAST "DOCTYPE" , NULL); 4816 htmlParseDocTypeDecl(ctxt); 4817 } 4818 /* 4819 * First case : a comment 4820 */ 4821 else if ((NXT(2) == '-') && (NXT(3) == '-')) { 4822 htmlParseComment(ctxt); 4823 } 4824 else { 4825 htmlSkipBogusComment(ctxt); 4826 } 4827 } 4828 4829 /* 4830 * Second case : a Processing Instruction. 4831 */ 4832 else if ((CUR == '<') && (NXT(1) == '?')) { 4833 htmlParsePI(ctxt); 4834 } 4835 4836 /* 4837 * Third case : a sub-element. 4838 */ 4839 else if ((CUR == '<') && IS_ASCII_LETTER(NXT(1))) { 4840 htmlParseElementInternal(ctxt); 4841 if (currentNode != NULL) xmlFree(currentNode); 4842 4843 currentNode = xmlStrdup(ctxt->name); 4844 depth = ctxt->nameNr; 4845 } 4846 else if (CUR == '<') { 4847 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 4848 (ctxt->sax->characters != NULL)) 4849 ctxt->sax->characters(ctxt->userData, BAD_CAST "<", 1); 4850 NEXT; 4851 } 4852 4853 /* 4854 * Fourth case : a reference. If if has not been resolved, 4855 * parsing returns it's Name, create the node 4856 */ 4857 else if (CUR == '&') { 4858 htmlParseReference(ctxt); 4859 } 4860 4861 /* 4862 * Fifth case : end of the resource 4863 */ 4864 else if (CUR == 0) { 4865 htmlAutoCloseOnEnd(ctxt); 4866 break; 4867 } 4868 4869 /* 4870 * Last case, text. Note that References are handled directly. 4871 */ 4872 else { 4873 htmlParseCharData(ctxt); 4874 } 4875 GROW; 4876 } 4877 if (currentNode != NULL) xmlFree(currentNode); 4878 } 4879 4880 /** 4881 * htmlParseContent: 4882 * @ctxt: an HTML parser context 4883 * 4884 * Parse a content: comment, sub-element, reference or text. 4885 * This is the entry point when called from parser.c 4886 */ 4887 4888 void 4889 __htmlParseContent(void *ctxt) { 4890 if (ctxt != NULL) 4891 htmlParseContentInternal((htmlParserCtxtPtr) ctxt); 4892 } 4893 4894 /** 4895 * htmlParseDocument: 4896 * @ctxt: an HTML parser context 4897 * 4898 * parse an HTML document (and build a tree if using the standard SAX 4899 * interface). 4900 * 4901 * Returns 0, -1 in case of error. the parser context is augmented 4902 * as a result of the parsing. 4903 */ 4904 4905 int 4906 htmlParseDocument(htmlParserCtxtPtr ctxt) { 4907 xmlChar start[4]; 4908 xmlCharEncoding enc; 4909 xmlDtdPtr dtd; 4910 4911 xmlInitParser(); 4912 4913 htmlDefaultSAXHandlerInit(); 4914 4915 if ((ctxt == NULL) || (ctxt->input == NULL)) { 4916 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 4917 "htmlParseDocument: context error\n", NULL, NULL); 4918 return(XML_ERR_INTERNAL_ERROR); 4919 } 4920 ctxt->html = 1; 4921 ctxt->linenumbers = 1; 4922 GROW; 4923 /* 4924 * SAX: beginning of the document processing. 4925 */ 4926 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) 4927 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator); 4928 4929 if ((ctxt->encoding == (const xmlChar *)XML_CHAR_ENCODING_NONE) && 4930 ((ctxt->input->end - ctxt->input->cur) >= 4)) { 4931 /* 4932 * Get the 4 first bytes and decode the charset 4933 * if enc != XML_CHAR_ENCODING_NONE 4934 * plug some encoding conversion routines. 4935 */ 4936 start[0] = RAW; 4937 start[1] = NXT(1); 4938 start[2] = NXT(2); 4939 start[3] = NXT(3); 4940 enc = xmlDetectCharEncoding(&start[0], 4); 4941 if (enc != XML_CHAR_ENCODING_NONE) { 4942 xmlSwitchEncoding(ctxt, enc); 4943 } 4944 } 4945 4946 /* 4947 * Wipe out everything which is before the first '<' 4948 */ 4949 SKIP_BLANKS; 4950 if (CUR == 0) { 4951 htmlParseErr(ctxt, XML_ERR_DOCUMENT_EMPTY, 4952 "Document is empty\n", NULL, NULL); 4953 } 4954 4955 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX)) 4956 ctxt->sax->startDocument(ctxt->userData); 4957 4958 4959 /* 4960 * Parse possible comments and PIs before any content 4961 */ 4962 while (((CUR == '<') && (NXT(1) == '!') && 4963 (NXT(2) == '-') && (NXT(3) == '-')) || 4964 ((CUR == '<') && (NXT(1) == '?'))) { 4965 htmlParseComment(ctxt); 4966 htmlParsePI(ctxt); 4967 SKIP_BLANKS; 4968 } 4969 4970 4971 /* 4972 * Then possibly doc type declaration(s) and more Misc 4973 * (doctypedecl Misc*)? 4974 */ 4975 if ((CUR == '<') && (NXT(1) == '!') && 4976 (UPP(2) == 'D') && (UPP(3) == 'O') && 4977 (UPP(4) == 'C') && (UPP(5) == 'T') && 4978 (UPP(6) == 'Y') && (UPP(7) == 'P') && 4979 (UPP(8) == 'E')) { 4980 htmlParseDocTypeDecl(ctxt); 4981 } 4982 SKIP_BLANKS; 4983 4984 /* 4985 * Parse possible comments and PIs before any content 4986 */ 4987 while (((CUR == '<') && (NXT(1) == '!') && 4988 (NXT(2) == '-') && (NXT(3) == '-')) || 4989 ((CUR == '<') && (NXT(1) == '?'))) { 4990 htmlParseComment(ctxt); 4991 htmlParsePI(ctxt); 4992 SKIP_BLANKS; 4993 } 4994 4995 /* 4996 * Time to start parsing the tree itself 4997 */ 4998 htmlParseContentInternal(ctxt); 4999 5000 /* 5001 * autoclose 5002 */ 5003 if (CUR == 0) 5004 htmlAutoCloseOnEnd(ctxt); 5005 5006 5007 /* 5008 * SAX: end of the document processing. 5009 */ 5010 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 5011 ctxt->sax->endDocument(ctxt->userData); 5012 5013 if ((!(ctxt->options & HTML_PARSE_NODEFDTD)) && (ctxt->myDoc != NULL)) { 5014 dtd = xmlGetIntSubset(ctxt->myDoc); 5015 if (dtd == NULL) 5016 ctxt->myDoc->intSubset = 5017 xmlCreateIntSubset(ctxt->myDoc, BAD_CAST "html", 5018 BAD_CAST "-//W3C//DTD HTML 4.0 Transitional//EN", 5019 BAD_CAST "http://www.w3.org/TR/REC-html40/loose.dtd"); 5020 } 5021 if (! ctxt->wellFormed) return(-1); 5022 return(0); 5023 } 5024 5025 5026 /************************************************************************ 5027 * * 5028 * Parser contexts handling * 5029 * * 5030 ************************************************************************/ 5031 5032 /** 5033 * htmlInitParserCtxt: 5034 * @ctxt: an HTML parser context 5035 * 5036 * Initialize a parser context 5037 * 5038 * Returns 0 in case of success and -1 in case of error 5039 */ 5040 5041 static int 5042 htmlInitParserCtxt(htmlParserCtxtPtr ctxt) 5043 { 5044 htmlSAXHandler *sax; 5045 5046 if (ctxt == NULL) return(-1); 5047 memset(ctxt, 0, sizeof(htmlParserCtxt)); 5048 5049 ctxt->dict = xmlDictCreate(); 5050 if (ctxt->dict == NULL) { 5051 htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n"); 5052 return(-1); 5053 } 5054 sax = (htmlSAXHandler *) xmlMalloc(sizeof(htmlSAXHandler)); 5055 if (sax == NULL) { 5056 htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n"); 5057 return(-1); 5058 } 5059 memset(sax, 0, sizeof(htmlSAXHandler)); 5060 5061 /* Allocate the Input stack */ 5062 ctxt->inputTab = (htmlParserInputPtr *) 5063 xmlMalloc(5 * sizeof(htmlParserInputPtr)); 5064 if (ctxt->inputTab == NULL) { 5065 htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n"); 5066 ctxt->inputNr = 0; 5067 ctxt->inputMax = 0; 5068 ctxt->input = NULL; 5069 return(-1); 5070 } 5071 ctxt->inputNr = 0; 5072 ctxt->inputMax = 5; 5073 ctxt->input = NULL; 5074 ctxt->version = NULL; 5075 ctxt->encoding = NULL; 5076 ctxt->standalone = -1; 5077 ctxt->instate = XML_PARSER_START; 5078 5079 /* Allocate the Node stack */ 5080 ctxt->nodeTab = (htmlNodePtr *) xmlMalloc(10 * sizeof(htmlNodePtr)); 5081 if (ctxt->nodeTab == NULL) { 5082 htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n"); 5083 ctxt->nodeNr = 0; 5084 ctxt->nodeMax = 0; 5085 ctxt->node = NULL; 5086 ctxt->inputNr = 0; 5087 ctxt->inputMax = 0; 5088 ctxt->input = NULL; 5089 return(-1); 5090 } 5091 ctxt->nodeNr = 0; 5092 ctxt->nodeMax = 10; 5093 ctxt->node = NULL; 5094 5095 /* Allocate the Name stack */ 5096 ctxt->nameTab = (const xmlChar **) xmlMalloc(10 * sizeof(xmlChar *)); 5097 if (ctxt->nameTab == NULL) { 5098 htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n"); 5099 ctxt->nameNr = 0; 5100 ctxt->nameMax = 0; 5101 ctxt->name = NULL; 5102 ctxt->nodeNr = 0; 5103 ctxt->nodeMax = 0; 5104 ctxt->node = NULL; 5105 ctxt->inputNr = 0; 5106 ctxt->inputMax = 0; 5107 ctxt->input = NULL; 5108 return(-1); 5109 } 5110 ctxt->nameNr = 0; 5111 ctxt->nameMax = 10; 5112 ctxt->name = NULL; 5113 5114 ctxt->nodeInfoTab = NULL; 5115 ctxt->nodeInfoNr = 0; 5116 ctxt->nodeInfoMax = 0; 5117 5118 ctxt->sax = sax; 5119 xmlSAX2InitHtmlDefaultSAXHandler(sax); 5120 5121 ctxt->userData = ctxt; 5122 ctxt->myDoc = NULL; 5123 ctxt->wellFormed = 1; 5124 ctxt->replaceEntities = 0; 5125 ctxt->linenumbers = xmlLineNumbersDefaultValue; 5126 ctxt->keepBlanks = xmlKeepBlanksDefaultValue; 5127 ctxt->html = 1; 5128 ctxt->vctxt.flags = XML_VCTXT_USE_PCTXT; 5129 ctxt->vctxt.userData = ctxt; 5130 ctxt->vctxt.error = xmlParserValidityError; 5131 ctxt->vctxt.warning = xmlParserValidityWarning; 5132 ctxt->record_info = 0; 5133 ctxt->validate = 0; 5134 ctxt->checkIndex = 0; 5135 ctxt->catalogs = NULL; 5136 xmlInitNodeInfoSeq(&ctxt->node_seq); 5137 return(0); 5138 } 5139 5140 /** 5141 * htmlFreeParserCtxt: 5142 * @ctxt: an HTML parser context 5143 * 5144 * Free all the memory used by a parser context. However the parsed 5145 * document in ctxt->myDoc is not freed. 5146 */ 5147 5148 void 5149 htmlFreeParserCtxt(htmlParserCtxtPtr ctxt) 5150 { 5151 xmlFreeParserCtxt(ctxt); 5152 } 5153 5154 /** 5155 * htmlNewParserCtxt: 5156 * 5157 * Allocate and initialize a new parser context. 5158 * 5159 * Returns the htmlParserCtxtPtr or NULL in case of allocation error 5160 */ 5161 5162 htmlParserCtxtPtr 5163 htmlNewParserCtxt(void) 5164 { 5165 xmlParserCtxtPtr ctxt; 5166 5167 ctxt = (xmlParserCtxtPtr) xmlMalloc(sizeof(xmlParserCtxt)); 5168 if (ctxt == NULL) { 5169 htmlErrMemory(NULL, "NewParserCtxt: out of memory\n"); 5170 return(NULL); 5171 } 5172 memset(ctxt, 0, sizeof(xmlParserCtxt)); 5173 if (htmlInitParserCtxt(ctxt) < 0) { 5174 htmlFreeParserCtxt(ctxt); 5175 return(NULL); 5176 } 5177 return(ctxt); 5178 } 5179 5180 /** 5181 * htmlCreateMemoryParserCtxt: 5182 * @buffer: a pointer to a char array 5183 * @size: the size of the array 5184 * 5185 * Create a parser context for an HTML in-memory document. 5186 * 5187 * Returns the new parser context or NULL 5188 */ 5189 htmlParserCtxtPtr 5190 htmlCreateMemoryParserCtxt(const char *buffer, int size) { 5191 xmlParserCtxtPtr ctxt; 5192 xmlParserInputPtr input; 5193 xmlParserInputBufferPtr buf; 5194 5195 if (buffer == NULL) 5196 return(NULL); 5197 if (size <= 0) 5198 return(NULL); 5199 5200 ctxt = htmlNewParserCtxt(); 5201 if (ctxt == NULL) 5202 return(NULL); 5203 5204 buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE); 5205 if (buf == NULL) return(NULL); 5206 5207 input = xmlNewInputStream(ctxt); 5208 if (input == NULL) { 5209 xmlFreeParserInputBuffer(buf); 5210 xmlFreeParserCtxt(ctxt); 5211 return(NULL); 5212 } 5213 5214 input->filename = NULL; 5215 input->buf = buf; 5216 xmlBufResetInput(buf->buffer, input); 5217 5218 inputPush(ctxt, input); 5219 return(ctxt); 5220 } 5221 5222 /** 5223 * htmlCreateDocParserCtxt: 5224 * @cur: a pointer to an array of xmlChar 5225 * @encoding: a free form C string describing the HTML document encoding, or NULL 5226 * 5227 * Create a parser context for an HTML document. 5228 * 5229 * TODO: check the need to add encoding handling there 5230 * 5231 * Returns the new parser context or NULL 5232 */ 5233 static htmlParserCtxtPtr 5234 htmlCreateDocParserCtxt(const xmlChar *cur, const char *encoding) { 5235 int len; 5236 htmlParserCtxtPtr ctxt; 5237 5238 if (cur == NULL) 5239 return(NULL); 5240 len = xmlStrlen(cur); 5241 ctxt = htmlCreateMemoryParserCtxt((char *)cur, len); 5242 if (ctxt == NULL) 5243 return(NULL); 5244 5245 if (encoding != NULL) { 5246 xmlCharEncoding enc; 5247 xmlCharEncodingHandlerPtr handler; 5248 5249 if (ctxt->input->encoding != NULL) 5250 xmlFree((xmlChar *) ctxt->input->encoding); 5251 ctxt->input->encoding = xmlStrdup((const xmlChar *) encoding); 5252 5253 enc = xmlParseCharEncoding(encoding); 5254 /* 5255 * registered set of known encodings 5256 */ 5257 if (enc != XML_CHAR_ENCODING_ERROR) { 5258 xmlSwitchEncoding(ctxt, enc); 5259 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 5260 htmlParseErr(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 5261 "Unsupported encoding %s\n", 5262 (const xmlChar *) encoding, NULL); 5263 } 5264 } else { 5265 /* 5266 * fallback for unknown encodings 5267 */ 5268 handler = xmlFindCharEncodingHandler((const char *) encoding); 5269 if (handler != NULL) { 5270 xmlSwitchToEncoding(ctxt, handler); 5271 } else { 5272 htmlParseErr(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 5273 "Unsupported encoding %s\n", 5274 (const xmlChar *) encoding, NULL); 5275 } 5276 } 5277 } 5278 return(ctxt); 5279 } 5280 5281 #ifdef LIBXML_PUSH_ENABLED 5282 /************************************************************************ 5283 * * 5284 * Progressive parsing interfaces * 5285 * * 5286 ************************************************************************/ 5287 5288 /** 5289 * htmlParseLookupSequence: 5290 * @ctxt: an HTML parser context 5291 * @first: the first char to lookup 5292 * @next: the next char to lookup or zero 5293 * @third: the next char to lookup or zero 5294 * @ignoreattrval: skip over attribute values 5295 * 5296 * Try to find if a sequence (first, next, third) or just (first next) or 5297 * (first) is available in the input stream. 5298 * This function has a side effect of (possibly) incrementing ctxt->checkIndex 5299 * to avoid rescanning sequences of bytes, it DOES change the state of the 5300 * parser, do not use liberally. 5301 * This is basically similar to xmlParseLookupSequence() 5302 * 5303 * Returns the index to the current parsing point if the full sequence 5304 * is available, -1 otherwise. 5305 */ 5306 static int 5307 htmlParseLookupSequence(htmlParserCtxtPtr ctxt, xmlChar first, 5308 xmlChar next, xmlChar third, int ignoreattrval) 5309 { 5310 int base, len; 5311 htmlParserInputPtr in; 5312 const xmlChar *buf; 5313 int invalue = 0; 5314 char valdellim = 0x0; 5315 5316 in = ctxt->input; 5317 if (in == NULL) 5318 return (-1); 5319 5320 base = in->cur - in->base; 5321 if (base < 0) 5322 return (-1); 5323 5324 if (ctxt->checkIndex > base) { 5325 base = ctxt->checkIndex; 5326 /* Abuse hasPErefs member to restore current state. */ 5327 invalue = ctxt->hasPErefs & 1 ? 1 : 0; 5328 } 5329 5330 if (in->buf == NULL) { 5331 buf = in->base; 5332 len = in->length; 5333 } else { 5334 buf = xmlBufContent(in->buf->buffer); 5335 len = xmlBufUse(in->buf->buffer); 5336 } 5337 5338 /* take into account the sequence length */ 5339 if (third) 5340 len -= 2; 5341 else if (next) 5342 len--; 5343 for (; base < len; base++) { 5344 if (ignoreattrval) { 5345 if (buf[base] == '"' || buf[base] == '\'') { 5346 if (invalue) { 5347 if (buf[base] == valdellim) { 5348 invalue = 0; 5349 continue; 5350 } 5351 } else { 5352 valdellim = buf[base]; 5353 invalue = 1; 5354 continue; 5355 } 5356 } else if (invalue) { 5357 continue; 5358 } 5359 } 5360 if (buf[base] == first) { 5361 if (third != 0) { 5362 if ((buf[base + 1] != next) || (buf[base + 2] != third)) 5363 continue; 5364 } else if (next != 0) { 5365 if (buf[base + 1] != next) 5366 continue; 5367 } 5368 ctxt->checkIndex = 0; 5369 #ifdef DEBUG_PUSH 5370 if (next == 0) 5371 xmlGenericError(xmlGenericErrorContext, 5372 "HPP: lookup '%c' found at %d\n", 5373 first, base); 5374 else if (third == 0) 5375 xmlGenericError(xmlGenericErrorContext, 5376 "HPP: lookup '%c%c' found at %d\n", 5377 first, next, base); 5378 else 5379 xmlGenericError(xmlGenericErrorContext, 5380 "HPP: lookup '%c%c%c' found at %d\n", 5381 first, next, third, base); 5382 #endif 5383 return (base - (in->cur - in->base)); 5384 } 5385 } 5386 ctxt->checkIndex = base; 5387 /* Abuse hasPErefs member to track current state. */ 5388 if (invalue) 5389 ctxt->hasPErefs |= 1; 5390 else 5391 ctxt->hasPErefs &= ~1; 5392 #ifdef DEBUG_PUSH 5393 if (next == 0) 5394 xmlGenericError(xmlGenericErrorContext, 5395 "HPP: lookup '%c' failed\n", first); 5396 else if (third == 0) 5397 xmlGenericError(xmlGenericErrorContext, 5398 "HPP: lookup '%c%c' failed\n", first, next); 5399 else 5400 xmlGenericError(xmlGenericErrorContext, 5401 "HPP: lookup '%c%c%c' failed\n", first, next, 5402 third); 5403 #endif 5404 return (-1); 5405 } 5406 5407 /** 5408 * htmlParseLookupCommentEnd: 5409 * @ctxt: an HTML parser context 5410 * 5411 * Try to find a comment end tag in the input stream 5412 * The search includes "-->" as well as WHATWG-recommended incorrectly-closed tags. 5413 * (See https://html.spec.whatwg.org/multipage/parsing.html#parse-error-incorrectly-closed-comment) 5414 * This function has a side effect of (possibly) incrementing ctxt->checkIndex 5415 * to avoid rescanning sequences of bytes, it DOES change the state of the 5416 * parser, do not use liberally. 5417 * This wraps to htmlParseLookupSequence() 5418 * 5419 * Returns the index to the current parsing point if the full sequence is available, -1 otherwise. 5420 */ 5421 static int 5422 htmlParseLookupCommentEnd(htmlParserCtxtPtr ctxt) 5423 { 5424 int mark = 0; 5425 int cur = CUR_PTR - BASE_PTR; 5426 5427 while (mark >= 0) { 5428 mark = htmlParseLookupSequence(ctxt, '-', '-', 0, 0); 5429 if ((mark < 0) || 5430 (NXT(mark+2) == '>') || 5431 ((NXT(mark+2) == '!') && (NXT(mark+3) == '>'))) { 5432 return mark; 5433 } 5434 ctxt->checkIndex = cur + mark + 1; 5435 } 5436 return mark; 5437 } 5438 5439 5440 /** 5441 * htmlParseTryOrFinish: 5442 * @ctxt: an HTML parser context 5443 * @terminate: last chunk indicator 5444 * 5445 * Try to progress on parsing 5446 * 5447 * Returns zero if no parsing was possible 5448 */ 5449 static int 5450 htmlParseTryOrFinish(htmlParserCtxtPtr ctxt, int terminate) { 5451 int ret = 0; 5452 htmlParserInputPtr in; 5453 ptrdiff_t avail = 0; 5454 xmlChar cur, next; 5455 5456 htmlParserNodeInfo node_info; 5457 5458 #ifdef DEBUG_PUSH 5459 switch (ctxt->instate) { 5460 case XML_PARSER_EOF: 5461 xmlGenericError(xmlGenericErrorContext, 5462 "HPP: try EOF\n"); break; 5463 case XML_PARSER_START: 5464 xmlGenericError(xmlGenericErrorContext, 5465 "HPP: try START\n"); break; 5466 case XML_PARSER_MISC: 5467 xmlGenericError(xmlGenericErrorContext, 5468 "HPP: try MISC\n");break; 5469 case XML_PARSER_COMMENT: 5470 xmlGenericError(xmlGenericErrorContext, 5471 "HPP: try COMMENT\n");break; 5472 case XML_PARSER_PROLOG: 5473 xmlGenericError(xmlGenericErrorContext, 5474 "HPP: try PROLOG\n");break; 5475 case XML_PARSER_START_TAG: 5476 xmlGenericError(xmlGenericErrorContext, 5477 "HPP: try START_TAG\n");break; 5478 case XML_PARSER_CONTENT: 5479 xmlGenericError(xmlGenericErrorContext, 5480 "HPP: try CONTENT\n");break; 5481 case XML_PARSER_CDATA_SECTION: 5482 xmlGenericError(xmlGenericErrorContext, 5483 "HPP: try CDATA_SECTION\n");break; 5484 case XML_PARSER_END_TAG: 5485 xmlGenericError(xmlGenericErrorContext, 5486 "HPP: try END_TAG\n");break; 5487 case XML_PARSER_ENTITY_DECL: 5488 xmlGenericError(xmlGenericErrorContext, 5489 "HPP: try ENTITY_DECL\n");break; 5490 case XML_PARSER_ENTITY_VALUE: 5491 xmlGenericError(xmlGenericErrorContext, 5492 "HPP: try ENTITY_VALUE\n");break; 5493 case XML_PARSER_ATTRIBUTE_VALUE: 5494 xmlGenericError(xmlGenericErrorContext, 5495 "HPP: try ATTRIBUTE_VALUE\n");break; 5496 case XML_PARSER_DTD: 5497 xmlGenericError(xmlGenericErrorContext, 5498 "HPP: try DTD\n");break; 5499 case XML_PARSER_EPILOG: 5500 xmlGenericError(xmlGenericErrorContext, 5501 "HPP: try EPILOG\n");break; 5502 case XML_PARSER_PI: 5503 xmlGenericError(xmlGenericErrorContext, 5504 "HPP: try PI\n");break; 5505 case XML_PARSER_SYSTEM_LITERAL: 5506 xmlGenericError(xmlGenericErrorContext, 5507 "HPP: try SYSTEM_LITERAL\n");break; 5508 } 5509 #endif 5510 5511 while (1) { 5512 5513 in = ctxt->input; 5514 if (in == NULL) break; 5515 if (in->buf == NULL) 5516 avail = in->length - (in->cur - in->base); 5517 else 5518 avail = (ptrdiff_t)xmlBufUse(in->buf->buffer) - 5519 (in->cur - in->base); 5520 if ((avail == 0) && (terminate)) { 5521 htmlAutoCloseOnEnd(ctxt); 5522 if ((ctxt->nameNr == 0) && (ctxt->instate != XML_PARSER_EOF)) { 5523 /* 5524 * SAX: end of the document processing. 5525 */ 5526 ctxt->instate = XML_PARSER_EOF; 5527 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 5528 ctxt->sax->endDocument(ctxt->userData); 5529 } 5530 } 5531 if (avail < 1) 5532 goto done; 5533 /* 5534 * This is done to make progress and avoid an infinite loop 5535 * if a parsing attempt was aborted by hitting a NUL byte. After 5536 * changing htmlCurrentChar, this probably isn't necessary anymore. 5537 * We should consider removing this check. 5538 */ 5539 cur = in->cur[0]; 5540 if (cur == 0) { 5541 SKIP(1); 5542 continue; 5543 } 5544 5545 switch (ctxt->instate) { 5546 case XML_PARSER_EOF: 5547 /* 5548 * Document parsing is done ! 5549 */ 5550 goto done; 5551 case XML_PARSER_START: 5552 /* 5553 * Very first chars read from the document flow. 5554 */ 5555 cur = in->cur[0]; 5556 if (IS_BLANK_CH(cur)) { 5557 SKIP_BLANKS; 5558 if (in->buf == NULL) 5559 avail = in->length - (in->cur - in->base); 5560 else 5561 avail = (ptrdiff_t)xmlBufUse(in->buf->buffer) - 5562 (in->cur - in->base); 5563 } 5564 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) 5565 ctxt->sax->setDocumentLocator(ctxt->userData, 5566 &xmlDefaultSAXLocator); 5567 if ((ctxt->sax) && (ctxt->sax->startDocument) && 5568 (!ctxt->disableSAX)) 5569 ctxt->sax->startDocument(ctxt->userData); 5570 5571 cur = in->cur[0]; 5572 next = in->cur[1]; 5573 if ((cur == '<') && (next == '!') && 5574 (UPP(2) == 'D') && (UPP(3) == 'O') && 5575 (UPP(4) == 'C') && (UPP(5) == 'T') && 5576 (UPP(6) == 'Y') && (UPP(7) == 'P') && 5577 (UPP(8) == 'E')) { 5578 if ((!terminate) && 5579 (htmlParseLookupSequence(ctxt, '>', 0, 0, 1) < 0)) 5580 goto done; 5581 #ifdef DEBUG_PUSH 5582 xmlGenericError(xmlGenericErrorContext, 5583 "HPP: Parsing internal subset\n"); 5584 #endif 5585 htmlParseDocTypeDecl(ctxt); 5586 ctxt->instate = XML_PARSER_PROLOG; 5587 #ifdef DEBUG_PUSH 5588 xmlGenericError(xmlGenericErrorContext, 5589 "HPP: entering PROLOG\n"); 5590 #endif 5591 } else { 5592 ctxt->instate = XML_PARSER_MISC; 5593 #ifdef DEBUG_PUSH 5594 xmlGenericError(xmlGenericErrorContext, 5595 "HPP: entering MISC\n"); 5596 #endif 5597 } 5598 break; 5599 case XML_PARSER_MISC: 5600 SKIP_BLANKS; 5601 if (in->buf == NULL) 5602 avail = in->length - (in->cur - in->base); 5603 else 5604 avail = (ptrdiff_t)xmlBufUse(in->buf->buffer) - 5605 (in->cur - in->base); 5606 /* 5607 * no chars in buffer 5608 */ 5609 if (avail < 1) 5610 goto done; 5611 /* 5612 * not enough chars in buffer 5613 */ 5614 if (avail < 2) { 5615 if (!terminate) 5616 goto done; 5617 else 5618 next = ' '; 5619 } else { 5620 next = in->cur[1]; 5621 } 5622 cur = in->cur[0]; 5623 if ((cur == '<') && (next == '!') && 5624 (in->cur[2] == '-') && (in->cur[3] == '-')) { 5625 if ((!terminate) && (htmlParseLookupCommentEnd(ctxt) < 0)) 5626 goto done; 5627 #ifdef DEBUG_PUSH 5628 xmlGenericError(xmlGenericErrorContext, 5629 "HPP: Parsing Comment\n"); 5630 #endif 5631 htmlParseComment(ctxt); 5632 ctxt->instate = XML_PARSER_MISC; 5633 } else if ((cur == '<') && (next == '?')) { 5634 if ((!terminate) && 5635 (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0)) 5636 goto done; 5637 #ifdef DEBUG_PUSH 5638 xmlGenericError(xmlGenericErrorContext, 5639 "HPP: Parsing PI\n"); 5640 #endif 5641 htmlParsePI(ctxt); 5642 ctxt->instate = XML_PARSER_MISC; 5643 } else if ((cur == '<') && (next == '!') && 5644 (UPP(2) == 'D') && (UPP(3) == 'O') && 5645 (UPP(4) == 'C') && (UPP(5) == 'T') && 5646 (UPP(6) == 'Y') && (UPP(7) == 'P') && 5647 (UPP(8) == 'E')) { 5648 if ((!terminate) && 5649 (htmlParseLookupSequence(ctxt, '>', 0, 0, 1) < 0)) 5650 goto done; 5651 #ifdef DEBUG_PUSH 5652 xmlGenericError(xmlGenericErrorContext, 5653 "HPP: Parsing internal subset\n"); 5654 #endif 5655 htmlParseDocTypeDecl(ctxt); 5656 ctxt->instate = XML_PARSER_PROLOG; 5657 #ifdef DEBUG_PUSH 5658 xmlGenericError(xmlGenericErrorContext, 5659 "HPP: entering PROLOG\n"); 5660 #endif 5661 } else if ((cur == '<') && (next == '!') && 5662 (avail < 9)) { 5663 goto done; 5664 } else { 5665 ctxt->instate = XML_PARSER_CONTENT; 5666 #ifdef DEBUG_PUSH 5667 xmlGenericError(xmlGenericErrorContext, 5668 "HPP: entering START_TAG\n"); 5669 #endif 5670 } 5671 break; 5672 case XML_PARSER_PROLOG: 5673 SKIP_BLANKS; 5674 if (in->buf == NULL) 5675 avail = in->length - (in->cur - in->base); 5676 else 5677 avail = (ptrdiff_t)xmlBufUse(in->buf->buffer) - 5678 (in->cur - in->base); 5679 if (avail < 2) 5680 goto done; 5681 cur = in->cur[0]; 5682 next = in->cur[1]; 5683 if ((cur == '<') && (next == '!') && 5684 (in->cur[2] == '-') && (in->cur[3] == '-')) { 5685 if ((!terminate) && (htmlParseLookupCommentEnd(ctxt) < 0)) 5686 goto done; 5687 #ifdef DEBUG_PUSH 5688 xmlGenericError(xmlGenericErrorContext, 5689 "HPP: Parsing Comment\n"); 5690 #endif 5691 htmlParseComment(ctxt); 5692 ctxt->instate = XML_PARSER_PROLOG; 5693 } else if ((cur == '<') && (next == '?')) { 5694 if ((!terminate) && 5695 (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0)) 5696 goto done; 5697 #ifdef DEBUG_PUSH 5698 xmlGenericError(xmlGenericErrorContext, 5699 "HPP: Parsing PI\n"); 5700 #endif 5701 htmlParsePI(ctxt); 5702 ctxt->instate = XML_PARSER_PROLOG; 5703 } else if ((cur == '<') && (next == '!') && 5704 (avail < 4)) { 5705 goto done; 5706 } else { 5707 ctxt->instate = XML_PARSER_CONTENT; 5708 #ifdef DEBUG_PUSH 5709 xmlGenericError(xmlGenericErrorContext, 5710 "HPP: entering START_TAG\n"); 5711 #endif 5712 } 5713 break; 5714 case XML_PARSER_EPILOG: 5715 if (in->buf == NULL) 5716 avail = in->length - (in->cur - in->base); 5717 else 5718 avail = (ptrdiff_t)xmlBufUse(in->buf->buffer) - 5719 (in->cur - in->base); 5720 if (avail < 1) 5721 goto done; 5722 cur = in->cur[0]; 5723 if (IS_BLANK_CH(cur)) { 5724 htmlParseCharData(ctxt); 5725 goto done; 5726 } 5727 if (avail < 2) 5728 goto done; 5729 next = in->cur[1]; 5730 if ((cur == '<') && (next == '!') && 5731 (in->cur[2] == '-') && (in->cur[3] == '-')) { 5732 if ((!terminate) && (htmlParseLookupCommentEnd(ctxt) < 0)) 5733 goto done; 5734 #ifdef DEBUG_PUSH 5735 xmlGenericError(xmlGenericErrorContext, 5736 "HPP: Parsing Comment\n"); 5737 #endif 5738 htmlParseComment(ctxt); 5739 ctxt->instate = XML_PARSER_EPILOG; 5740 } else if ((cur == '<') && (next == '?')) { 5741 if ((!terminate) && 5742 (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0)) 5743 goto done; 5744 #ifdef DEBUG_PUSH 5745 xmlGenericError(xmlGenericErrorContext, 5746 "HPP: Parsing PI\n"); 5747 #endif 5748 htmlParsePI(ctxt); 5749 ctxt->instate = XML_PARSER_EPILOG; 5750 } else if ((cur == '<') && (next == '!') && 5751 (avail < 4)) { 5752 goto done; 5753 } else { 5754 ctxt->errNo = XML_ERR_DOCUMENT_END; 5755 ctxt->wellFormed = 0; 5756 ctxt->instate = XML_PARSER_EOF; 5757 #ifdef DEBUG_PUSH 5758 xmlGenericError(xmlGenericErrorContext, 5759 "HPP: entering EOF\n"); 5760 #endif 5761 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 5762 ctxt->sax->endDocument(ctxt->userData); 5763 goto done; 5764 } 5765 break; 5766 case XML_PARSER_START_TAG: { 5767 const xmlChar *name; 5768 int failed; 5769 const htmlElemDesc * info; 5770 5771 /* 5772 * no chars in buffer 5773 */ 5774 if (avail < 1) 5775 goto done; 5776 /* 5777 * not enough chars in buffer 5778 */ 5779 if (avail < 2) { 5780 if (!terminate) 5781 goto done; 5782 else 5783 next = ' '; 5784 } else { 5785 next = in->cur[1]; 5786 } 5787 cur = in->cur[0]; 5788 if (cur != '<') { 5789 ctxt->instate = XML_PARSER_CONTENT; 5790 #ifdef DEBUG_PUSH 5791 xmlGenericError(xmlGenericErrorContext, 5792 "HPP: entering CONTENT\n"); 5793 #endif 5794 break; 5795 } 5796 if (next == '/') { 5797 ctxt->instate = XML_PARSER_END_TAG; 5798 ctxt->checkIndex = 0; 5799 #ifdef DEBUG_PUSH 5800 xmlGenericError(xmlGenericErrorContext, 5801 "HPP: entering END_TAG\n"); 5802 #endif 5803 break; 5804 } 5805 if ((!terminate) && 5806 (htmlParseLookupSequence(ctxt, '>', 0, 0, 1) < 0)) 5807 goto done; 5808 5809 /* Capture start position */ 5810 if (ctxt->record_info) { 5811 node_info.begin_pos = ctxt->input->consumed + 5812 (CUR_PTR - ctxt->input->base); 5813 node_info.begin_line = ctxt->input->line; 5814 } 5815 5816 5817 failed = htmlParseStartTag(ctxt); 5818 name = ctxt->name; 5819 if ((failed == -1) || 5820 (name == NULL)) { 5821 if (CUR == '>') 5822 NEXT; 5823 break; 5824 } 5825 5826 /* 5827 * Lookup the info for that element. 5828 */ 5829 info = htmlTagLookup(name); 5830 if (info == NULL) { 5831 htmlParseErr(ctxt, XML_HTML_UNKNOWN_TAG, 5832 "Tag %s invalid\n", name, NULL); 5833 } 5834 5835 /* 5836 * Check for an Empty Element labeled the XML/SGML way 5837 */ 5838 if ((CUR == '/') && (NXT(1) == '>')) { 5839 SKIP(2); 5840 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL)) 5841 ctxt->sax->endElement(ctxt->userData, name); 5842 htmlnamePop(ctxt); 5843 ctxt->instate = XML_PARSER_CONTENT; 5844 #ifdef DEBUG_PUSH 5845 xmlGenericError(xmlGenericErrorContext, 5846 "HPP: entering CONTENT\n"); 5847 #endif 5848 break; 5849 } 5850 5851 if (CUR == '>') { 5852 NEXT; 5853 } else { 5854 htmlParseErr(ctxt, XML_ERR_GT_REQUIRED, 5855 "Couldn't find end of Start Tag %s\n", 5856 name, NULL); 5857 5858 /* 5859 * end of parsing of this node. 5860 */ 5861 if (xmlStrEqual(name, ctxt->name)) { 5862 nodePop(ctxt); 5863 htmlnamePop(ctxt); 5864 } 5865 5866 if (ctxt->record_info) 5867 htmlNodeInfoPush(ctxt, &node_info); 5868 5869 ctxt->instate = XML_PARSER_CONTENT; 5870 #ifdef DEBUG_PUSH 5871 xmlGenericError(xmlGenericErrorContext, 5872 "HPP: entering CONTENT\n"); 5873 #endif 5874 break; 5875 } 5876 5877 /* 5878 * Check for an Empty Element from DTD definition 5879 */ 5880 if ((info != NULL) && (info->empty)) { 5881 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL)) 5882 ctxt->sax->endElement(ctxt->userData, name); 5883 htmlnamePop(ctxt); 5884 } 5885 5886 if (ctxt->record_info) 5887 htmlNodeInfoPush(ctxt, &node_info); 5888 5889 ctxt->instate = XML_PARSER_CONTENT; 5890 #ifdef DEBUG_PUSH 5891 xmlGenericError(xmlGenericErrorContext, 5892 "HPP: entering CONTENT\n"); 5893 #endif 5894 break; 5895 } 5896 case XML_PARSER_CONTENT: { 5897 xmlChar chr[2] = { 0, 0 }; 5898 5899 /* 5900 * Handle preparsed entities and charRef 5901 */ 5902 if (ctxt->token != 0) { 5903 chr[0] = (xmlChar) ctxt->token; 5904 htmlCheckParagraph(ctxt); 5905 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL)) 5906 ctxt->sax->characters(ctxt->userData, chr, 1); 5907 ctxt->token = 0; 5908 ctxt->checkIndex = 0; 5909 } 5910 if ((avail == 1) && (terminate)) { 5911 cur = in->cur[0]; 5912 if ((cur != '<') && (cur != '&')) { 5913 if (ctxt->sax != NULL) { 5914 chr[0] = cur; 5915 if (IS_BLANK_CH(cur)) { 5916 if (ctxt->keepBlanks) { 5917 if (ctxt->sax->characters != NULL) 5918 ctxt->sax->characters( 5919 ctxt->userData, chr, 1); 5920 } else { 5921 if (ctxt->sax->ignorableWhitespace != NULL) 5922 ctxt->sax->ignorableWhitespace( 5923 ctxt->userData, chr, 1); 5924 } 5925 } else { 5926 htmlCheckParagraph(ctxt); 5927 if (ctxt->sax->characters != NULL) 5928 ctxt->sax->characters( 5929 ctxt->userData, chr, 1); 5930 } 5931 } 5932 ctxt->token = 0; 5933 ctxt->checkIndex = 0; 5934 in->cur++; 5935 break; 5936 } 5937 } 5938 if (avail < 2) 5939 goto done; 5940 cur = in->cur[0]; 5941 next = in->cur[1]; 5942 if ((xmlStrEqual(ctxt->name, BAD_CAST"script")) || 5943 (xmlStrEqual(ctxt->name, BAD_CAST"style"))) { 5944 /* 5945 * Handle SCRIPT/STYLE separately 5946 */ 5947 if (!terminate) { 5948 int idx; 5949 xmlChar val; 5950 5951 idx = htmlParseLookupSequence(ctxt, '<', '/', 0, 0); 5952 if (idx < 0) 5953 goto done; 5954 val = in->cur[idx + 2]; 5955 if (val == 0) /* bad cut of input */ 5956 goto done; 5957 } 5958 htmlParseScript(ctxt); 5959 if ((cur == '<') && (next == '/')) { 5960 ctxt->instate = XML_PARSER_END_TAG; 5961 ctxt->checkIndex = 0; 5962 #ifdef DEBUG_PUSH 5963 xmlGenericError(xmlGenericErrorContext, 5964 "HPP: entering END_TAG\n"); 5965 #endif 5966 break; 5967 } 5968 } else if ((cur == '<') && (next == '!')) { 5969 /* 5970 * Sometimes DOCTYPE arrives in the middle of the document 5971 */ 5972 if ((UPP(2) == 'D') && (UPP(3) == 'O') && 5973 (UPP(4) == 'C') && (UPP(5) == 'T') && 5974 (UPP(6) == 'Y') && (UPP(7) == 'P') && 5975 (UPP(8) == 'E')) { 5976 if ((!terminate) && 5977 (htmlParseLookupSequence(ctxt, '>', 0, 0, 1) < 0)) 5978 goto done; 5979 htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR, 5980 "Misplaced DOCTYPE declaration\n", 5981 BAD_CAST "DOCTYPE" , NULL); 5982 htmlParseDocTypeDecl(ctxt); 5983 } else if ((in->cur[2] == '-') && (in->cur[3] == '-')) { 5984 if ((!terminate) && 5985 (htmlParseLookupCommentEnd(ctxt) < 0)) 5986 goto done; 5987 #ifdef DEBUG_PUSH 5988 xmlGenericError(xmlGenericErrorContext, 5989 "HPP: Parsing Comment\n"); 5990 #endif 5991 htmlParseComment(ctxt); 5992 ctxt->instate = XML_PARSER_CONTENT; 5993 } else { 5994 if ((!terminate) && 5995 (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0)) 5996 goto done; 5997 htmlSkipBogusComment(ctxt); 5998 } 5999 } else if ((cur == '<') && (next == '?')) { 6000 if ((!terminate) && 6001 (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0)) 6002 goto done; 6003 #ifdef DEBUG_PUSH 6004 xmlGenericError(xmlGenericErrorContext, 6005 "HPP: Parsing PI\n"); 6006 #endif 6007 htmlParsePI(ctxt); 6008 ctxt->instate = XML_PARSER_CONTENT; 6009 } else if ((cur == '<') && (next == '!') && (avail < 4)) { 6010 goto done; 6011 } else if ((cur == '<') && (next == '/')) { 6012 ctxt->instate = XML_PARSER_END_TAG; 6013 ctxt->checkIndex = 0; 6014 #ifdef DEBUG_PUSH 6015 xmlGenericError(xmlGenericErrorContext, 6016 "HPP: entering END_TAG\n"); 6017 #endif 6018 break; 6019 } else if ((cur == '<') && IS_ASCII_LETTER(next)) { 6020 if ((!terminate) && (next == 0)) 6021 goto done; 6022 ctxt->instate = XML_PARSER_START_TAG; 6023 ctxt->checkIndex = 0; 6024 #ifdef DEBUG_PUSH 6025 xmlGenericError(xmlGenericErrorContext, 6026 "HPP: entering START_TAG\n"); 6027 #endif 6028 break; 6029 } else if (cur == '<') { 6030 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 6031 (ctxt->sax->characters != NULL)) 6032 ctxt->sax->characters(ctxt->userData, 6033 BAD_CAST "<", 1); 6034 NEXT; 6035 } else { 6036 /* 6037 * check that the text sequence is complete 6038 * before handing out the data to the parser 6039 * to avoid problems with erroneous end of 6040 * data detection. 6041 */ 6042 if ((!terminate) && 6043 (htmlParseLookupSequence(ctxt, '<', 0, 0, 0) < 0)) 6044 goto done; 6045 ctxt->checkIndex = 0; 6046 #ifdef DEBUG_PUSH 6047 xmlGenericError(xmlGenericErrorContext, 6048 "HPP: Parsing char data\n"); 6049 #endif 6050 while ((ctxt->instate != XML_PARSER_EOF) && 6051 (cur != '<') && (in->cur < in->end)) { 6052 if (cur == '&') { 6053 htmlParseReference(ctxt); 6054 } else { 6055 htmlParseCharData(ctxt); 6056 } 6057 cur = in->cur[0]; 6058 } 6059 } 6060 6061 break; 6062 } 6063 case XML_PARSER_END_TAG: 6064 if (avail < 2) 6065 goto done; 6066 if ((!terminate) && 6067 (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0)) 6068 goto done; 6069 htmlParseEndTag(ctxt); 6070 if (ctxt->nameNr == 0) { 6071 ctxt->instate = XML_PARSER_EPILOG; 6072 } else { 6073 ctxt->instate = XML_PARSER_CONTENT; 6074 } 6075 ctxt->checkIndex = 0; 6076 #ifdef DEBUG_PUSH 6077 xmlGenericError(xmlGenericErrorContext, 6078 "HPP: entering CONTENT\n"); 6079 #endif 6080 break; 6081 case XML_PARSER_CDATA_SECTION: 6082 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 6083 "HPP: internal error, state == CDATA\n", 6084 NULL, NULL); 6085 ctxt->instate = XML_PARSER_CONTENT; 6086 ctxt->checkIndex = 0; 6087 #ifdef DEBUG_PUSH 6088 xmlGenericError(xmlGenericErrorContext, 6089 "HPP: entering CONTENT\n"); 6090 #endif 6091 break; 6092 case XML_PARSER_DTD: 6093 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 6094 "HPP: internal error, state == DTD\n", 6095 NULL, NULL); 6096 ctxt->instate = XML_PARSER_CONTENT; 6097 ctxt->checkIndex = 0; 6098 #ifdef DEBUG_PUSH 6099 xmlGenericError(xmlGenericErrorContext, 6100 "HPP: entering CONTENT\n"); 6101 #endif 6102 break; 6103 case XML_PARSER_COMMENT: 6104 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 6105 "HPP: internal error, state == COMMENT\n", 6106 NULL, NULL); 6107 ctxt->instate = XML_PARSER_CONTENT; 6108 ctxt->checkIndex = 0; 6109 #ifdef DEBUG_PUSH 6110 xmlGenericError(xmlGenericErrorContext, 6111 "HPP: entering CONTENT\n"); 6112 #endif 6113 break; 6114 case XML_PARSER_PI: 6115 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 6116 "HPP: internal error, state == PI\n", 6117 NULL, NULL); 6118 ctxt->instate = XML_PARSER_CONTENT; 6119 ctxt->checkIndex = 0; 6120 #ifdef DEBUG_PUSH 6121 xmlGenericError(xmlGenericErrorContext, 6122 "HPP: entering CONTENT\n"); 6123 #endif 6124 break; 6125 case XML_PARSER_ENTITY_DECL: 6126 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 6127 "HPP: internal error, state == ENTITY_DECL\n", 6128 NULL, NULL); 6129 ctxt->instate = XML_PARSER_CONTENT; 6130 ctxt->checkIndex = 0; 6131 #ifdef DEBUG_PUSH 6132 xmlGenericError(xmlGenericErrorContext, 6133 "HPP: entering CONTENT\n"); 6134 #endif 6135 break; 6136 case XML_PARSER_ENTITY_VALUE: 6137 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 6138 "HPP: internal error, state == ENTITY_VALUE\n", 6139 NULL, NULL); 6140 ctxt->instate = XML_PARSER_CONTENT; 6141 ctxt->checkIndex = 0; 6142 #ifdef DEBUG_PUSH 6143 xmlGenericError(xmlGenericErrorContext, 6144 "HPP: entering DTD\n"); 6145 #endif 6146 break; 6147 case XML_PARSER_ATTRIBUTE_VALUE: 6148 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 6149 "HPP: internal error, state == ATTRIBUTE_VALUE\n", 6150 NULL, NULL); 6151 ctxt->instate = XML_PARSER_START_TAG; 6152 ctxt->checkIndex = 0; 6153 #ifdef DEBUG_PUSH 6154 xmlGenericError(xmlGenericErrorContext, 6155 "HPP: entering START_TAG\n"); 6156 #endif 6157 break; 6158 case XML_PARSER_SYSTEM_LITERAL: 6159 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 6160 "HPP: internal error, state == XML_PARSER_SYSTEM_LITERAL\n", 6161 NULL, NULL); 6162 ctxt->instate = XML_PARSER_CONTENT; 6163 ctxt->checkIndex = 0; 6164 #ifdef DEBUG_PUSH 6165 xmlGenericError(xmlGenericErrorContext, 6166 "HPP: entering CONTENT\n"); 6167 #endif 6168 break; 6169 case XML_PARSER_IGNORE: 6170 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 6171 "HPP: internal error, state == XML_PARSER_IGNORE\n", 6172 NULL, NULL); 6173 ctxt->instate = XML_PARSER_CONTENT; 6174 ctxt->checkIndex = 0; 6175 #ifdef DEBUG_PUSH 6176 xmlGenericError(xmlGenericErrorContext, 6177 "HPP: entering CONTENT\n"); 6178 #endif 6179 break; 6180 case XML_PARSER_PUBLIC_LITERAL: 6181 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 6182 "HPP: internal error, state == XML_PARSER_LITERAL\n", 6183 NULL, NULL); 6184 ctxt->instate = XML_PARSER_CONTENT; 6185 ctxt->checkIndex = 0; 6186 #ifdef DEBUG_PUSH 6187 xmlGenericError(xmlGenericErrorContext, 6188 "HPP: entering CONTENT\n"); 6189 #endif 6190 break; 6191 6192 } 6193 } 6194 done: 6195 if ((avail == 0) && (terminate)) { 6196 htmlAutoCloseOnEnd(ctxt); 6197 if ((ctxt->nameNr == 0) && (ctxt->instate != XML_PARSER_EOF)) { 6198 /* 6199 * SAX: end of the document processing. 6200 */ 6201 ctxt->instate = XML_PARSER_EOF; 6202 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 6203 ctxt->sax->endDocument(ctxt->userData); 6204 } 6205 } 6206 if ((!(ctxt->options & HTML_PARSE_NODEFDTD)) && (ctxt->myDoc != NULL) && 6207 ((terminate) || (ctxt->instate == XML_PARSER_EOF) || 6208 (ctxt->instate == XML_PARSER_EPILOG))) { 6209 xmlDtdPtr dtd; 6210 dtd = xmlGetIntSubset(ctxt->myDoc); 6211 if (dtd == NULL) 6212 ctxt->myDoc->intSubset = 6213 xmlCreateIntSubset(ctxt->myDoc, BAD_CAST "html", 6214 BAD_CAST "-//W3C//DTD HTML 4.0 Transitional//EN", 6215 BAD_CAST "http://www.w3.org/TR/REC-html40/loose.dtd"); 6216 } 6217 #ifdef DEBUG_PUSH 6218 xmlGenericError(xmlGenericErrorContext, "HPP: done %d\n", ret); 6219 #endif 6220 return(ret); 6221 } 6222 6223 /** 6224 * htmlParseChunk: 6225 * @ctxt: an HTML parser context 6226 * @chunk: an char array 6227 * @size: the size in byte of the chunk 6228 * @terminate: last chunk indicator 6229 * 6230 * Parse a Chunk of memory 6231 * 6232 * Returns zero if no error, the xmlParserErrors otherwise. 6233 */ 6234 int 6235 htmlParseChunk(htmlParserCtxtPtr ctxt, const char *chunk, int size, 6236 int terminate) { 6237 if ((ctxt == NULL) || (ctxt->input == NULL)) { 6238 htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR, 6239 "htmlParseChunk: context error\n", NULL, NULL); 6240 return(XML_ERR_INTERNAL_ERROR); 6241 } 6242 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) && 6243 (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) { 6244 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input); 6245 size_t cur = ctxt->input->cur - ctxt->input->base; 6246 int res; 6247 6248 res = xmlParserInputBufferPush(ctxt->input->buf, size, chunk); 6249 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur); 6250 if (res < 0) { 6251 ctxt->errNo = XML_PARSER_EOF; 6252 ctxt->disableSAX = 1; 6253 return (XML_PARSER_EOF); 6254 } 6255 #ifdef DEBUG_PUSH 6256 xmlGenericError(xmlGenericErrorContext, "HPP: pushed %d\n", size); 6257 #endif 6258 6259 #if 0 6260 if ((terminate) || (ctxt->input->buf->buffer->use > 80)) 6261 htmlParseTryOrFinish(ctxt, terminate); 6262 #endif 6263 } else if (ctxt->instate != XML_PARSER_EOF) { 6264 if ((ctxt->input != NULL) && ctxt->input->buf != NULL) { 6265 xmlParserInputBufferPtr in = ctxt->input->buf; 6266 if ((in->encoder != NULL) && (in->buffer != NULL) && 6267 (in->raw != NULL)) { 6268 int nbchars; 6269 size_t base = xmlBufGetInputBase(in->buffer, ctxt->input); 6270 size_t current = ctxt->input->cur - ctxt->input->base; 6271 6272 nbchars = xmlCharEncInput(in, terminate); 6273 xmlBufSetInputBaseCur(in->buffer, ctxt->input, base, current); 6274 if (nbchars < 0) { 6275 htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING, 6276 "encoder error\n", NULL, NULL); 6277 return(XML_ERR_INVALID_ENCODING); 6278 } 6279 } 6280 } 6281 } 6282 htmlParseTryOrFinish(ctxt, terminate); 6283 if (terminate) { 6284 if ((ctxt->instate != XML_PARSER_EOF) && 6285 (ctxt->instate != XML_PARSER_EPILOG) && 6286 (ctxt->instate != XML_PARSER_MISC)) { 6287 ctxt->errNo = XML_ERR_DOCUMENT_END; 6288 ctxt->wellFormed = 0; 6289 } 6290 if (ctxt->instate != XML_PARSER_EOF) { 6291 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 6292 ctxt->sax->endDocument(ctxt->userData); 6293 } 6294 ctxt->instate = XML_PARSER_EOF; 6295 } 6296 return((xmlParserErrors) ctxt->errNo); 6297 } 6298 6299 /************************************************************************ 6300 * * 6301 * User entry points * 6302 * * 6303 ************************************************************************/ 6304 6305 /** 6306 * htmlCreatePushParserCtxt: 6307 * @sax: a SAX handler 6308 * @user_data: The user data returned on SAX callbacks 6309 * @chunk: a pointer to an array of chars 6310 * @size: number of chars in the array 6311 * @filename: an optional file name or URI 6312 * @enc: an optional encoding 6313 * 6314 * Create a parser context for using the HTML parser in push mode 6315 * The value of @filename is used for fetching external entities 6316 * and error/warning reports. 6317 * 6318 * Returns the new parser context or NULL 6319 */ 6320 htmlParserCtxtPtr 6321 htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax, void *user_data, 6322 const char *chunk, int size, const char *filename, 6323 xmlCharEncoding enc) { 6324 htmlParserCtxtPtr ctxt; 6325 htmlParserInputPtr inputStream; 6326 xmlParserInputBufferPtr buf; 6327 6328 xmlInitParser(); 6329 6330 buf = xmlAllocParserInputBuffer(enc); 6331 if (buf == NULL) return(NULL); 6332 6333 ctxt = htmlNewParserCtxt(); 6334 if (ctxt == NULL) { 6335 xmlFreeParserInputBuffer(buf); 6336 return(NULL); 6337 } 6338 if(enc==XML_CHAR_ENCODING_UTF8 || buf->encoder) 6339 ctxt->charset=XML_CHAR_ENCODING_UTF8; 6340 if (sax != NULL) { 6341 if (ctxt->sax != (xmlSAXHandlerPtr) &htmlDefaultSAXHandler) 6342 xmlFree(ctxt->sax); 6343 ctxt->sax = (htmlSAXHandlerPtr) xmlMalloc(sizeof(htmlSAXHandler)); 6344 if (ctxt->sax == NULL) { 6345 xmlFree(buf); 6346 xmlFree(ctxt); 6347 return(NULL); 6348 } 6349 memcpy(ctxt->sax, sax, sizeof(htmlSAXHandler)); 6350 if (user_data != NULL) 6351 ctxt->userData = user_data; 6352 } 6353 if (filename == NULL) { 6354 ctxt->directory = NULL; 6355 } else { 6356 ctxt->directory = xmlParserGetDirectory(filename); 6357 } 6358 6359 inputStream = htmlNewInputStream(ctxt); 6360 if (inputStream == NULL) { 6361 xmlFreeParserCtxt(ctxt); 6362 xmlFree(buf); 6363 return(NULL); 6364 } 6365 6366 if (filename == NULL) 6367 inputStream->filename = NULL; 6368 else 6369 inputStream->filename = (char *) 6370 xmlCanonicPath((const xmlChar *) filename); 6371 inputStream->buf = buf; 6372 xmlBufResetInput(buf->buffer, inputStream); 6373 6374 inputPush(ctxt, inputStream); 6375 6376 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) && 6377 (ctxt->input->buf != NULL)) { 6378 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input); 6379 size_t cur = ctxt->input->cur - ctxt->input->base; 6380 6381 xmlParserInputBufferPush(ctxt->input->buf, size, chunk); 6382 6383 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur); 6384 #ifdef DEBUG_PUSH 6385 xmlGenericError(xmlGenericErrorContext, "HPP: pushed %d\n", size); 6386 #endif 6387 } 6388 ctxt->progressive = 1; 6389 6390 return(ctxt); 6391 } 6392 #endif /* LIBXML_PUSH_ENABLED */ 6393 6394 /** 6395 * htmlSAXParseDoc: 6396 * @cur: a pointer to an array of xmlChar 6397 * @encoding: a free form C string describing the HTML document encoding, or NULL 6398 * @sax: the SAX handler block 6399 * @userData: if using SAX, this pointer will be provided on callbacks. 6400 * 6401 * Parse an HTML in-memory document. If sax is not NULL, use the SAX callbacks 6402 * to handle parse events. If sax is NULL, fallback to the default DOM 6403 * behavior and return a tree. 6404 * 6405 * Returns the resulting document tree unless SAX is NULL or the document is 6406 * not well formed. 6407 */ 6408 6409 htmlDocPtr 6410 htmlSAXParseDoc(const xmlChar *cur, const char *encoding, 6411 htmlSAXHandlerPtr sax, void *userData) { 6412 htmlDocPtr ret; 6413 htmlParserCtxtPtr ctxt; 6414 6415 xmlInitParser(); 6416 6417 if (cur == NULL) return(NULL); 6418 6419 6420 ctxt = htmlCreateDocParserCtxt(cur, encoding); 6421 if (ctxt == NULL) return(NULL); 6422 if (sax != NULL) { 6423 if (ctxt->sax != NULL) xmlFree (ctxt->sax); 6424 ctxt->sax = sax; 6425 ctxt->userData = userData; 6426 } 6427 6428 htmlParseDocument(ctxt); 6429 ret = ctxt->myDoc; 6430 if (sax != NULL) { 6431 ctxt->sax = NULL; 6432 ctxt->userData = NULL; 6433 } 6434 htmlFreeParserCtxt(ctxt); 6435 6436 return(ret); 6437 } 6438 6439 /** 6440 * htmlParseDoc: 6441 * @cur: a pointer to an array of xmlChar 6442 * @encoding: a free form C string describing the HTML document encoding, or NULL 6443 * 6444 * parse an HTML in-memory document and build a tree. 6445 * 6446 * Returns the resulting document tree 6447 */ 6448 6449 htmlDocPtr 6450 htmlParseDoc(const xmlChar *cur, const char *encoding) { 6451 return(htmlSAXParseDoc(cur, encoding, NULL, NULL)); 6452 } 6453 6454 6455 /** 6456 * htmlCreateFileParserCtxt: 6457 * @filename: the filename 6458 * @encoding: a free form C string describing the HTML document encoding, or NULL 6459 * 6460 * Create a parser context for a file content. 6461 * Automatic support for ZLIB/Compress compressed document is provided 6462 * by default if found at compile-time. 6463 * 6464 * Returns the new parser context or NULL 6465 */ 6466 htmlParserCtxtPtr 6467 htmlCreateFileParserCtxt(const char *filename, const char *encoding) 6468 { 6469 htmlParserCtxtPtr ctxt; 6470 htmlParserInputPtr inputStream; 6471 char *canonicFilename; 6472 /* htmlCharEncoding enc; */ 6473 xmlChar *content, *content_line = (xmlChar *) "charset="; 6474 6475 if (filename == NULL) 6476 return(NULL); 6477 6478 ctxt = htmlNewParserCtxt(); 6479 if (ctxt == NULL) { 6480 return(NULL); 6481 } 6482 canonicFilename = (char *) xmlCanonicPath((const xmlChar *) filename); 6483 if (canonicFilename == NULL) { 6484 #ifdef LIBXML_SAX1_ENABLED 6485 if (xmlDefaultSAXHandler.error != NULL) { 6486 xmlDefaultSAXHandler.error(NULL, "out of memory\n"); 6487 } 6488 #endif 6489 xmlFreeParserCtxt(ctxt); 6490 return(NULL); 6491 } 6492 6493 inputStream = xmlLoadExternalEntity(canonicFilename, NULL, ctxt); 6494 xmlFree(canonicFilename); 6495 if (inputStream == NULL) { 6496 xmlFreeParserCtxt(ctxt); 6497 return(NULL); 6498 } 6499 6500 inputPush(ctxt, inputStream); 6501 6502 /* set encoding */ 6503 if (encoding) { 6504 size_t l = strlen(encoding); 6505 6506 if (l < 1000) { 6507 content = xmlMallocAtomic (xmlStrlen(content_line) + l + 1); 6508 if (content) { 6509 strcpy ((char *)content, (char *)content_line); 6510 strcat ((char *)content, (char *)encoding); 6511 htmlCheckEncoding (ctxt, content); 6512 xmlFree (content); 6513 } 6514 } 6515 } 6516 6517 return(ctxt); 6518 } 6519 6520 /** 6521 * htmlSAXParseFile: 6522 * @filename: the filename 6523 * @encoding: a free form C string describing the HTML document encoding, or NULL 6524 * @sax: the SAX handler block 6525 * @userData: if using SAX, this pointer will be provided on callbacks. 6526 * 6527 * parse an HTML file and build a tree. Automatic support for ZLIB/Compress 6528 * compressed document is provided by default if found at compile-time. 6529 * It use the given SAX function block to handle the parsing callback. 6530 * If sax is NULL, fallback to the default DOM tree building routines. 6531 * 6532 * Returns the resulting document tree unless SAX is NULL or the document is 6533 * not well formed. 6534 */ 6535 6536 htmlDocPtr 6537 htmlSAXParseFile(const char *filename, const char *encoding, htmlSAXHandlerPtr sax, 6538 void *userData) { 6539 htmlDocPtr ret; 6540 htmlParserCtxtPtr ctxt; 6541 htmlSAXHandlerPtr oldsax = NULL; 6542 6543 xmlInitParser(); 6544 6545 ctxt = htmlCreateFileParserCtxt(filename, encoding); 6546 if (ctxt == NULL) return(NULL); 6547 if (sax != NULL) { 6548 oldsax = ctxt->sax; 6549 ctxt->sax = sax; 6550 ctxt->userData = userData; 6551 } 6552 6553 htmlParseDocument(ctxt); 6554 6555 ret = ctxt->myDoc; 6556 if (sax != NULL) { 6557 ctxt->sax = oldsax; 6558 ctxt->userData = NULL; 6559 } 6560 htmlFreeParserCtxt(ctxt); 6561 6562 return(ret); 6563 } 6564 6565 /** 6566 * htmlParseFile: 6567 * @filename: the filename 6568 * @encoding: a free form C string describing the HTML document encoding, or NULL 6569 * 6570 * parse an HTML file and build a tree. Automatic support for ZLIB/Compress 6571 * compressed document is provided by default if found at compile-time. 6572 * 6573 * Returns the resulting document tree 6574 */ 6575 6576 htmlDocPtr 6577 htmlParseFile(const char *filename, const char *encoding) { 6578 return(htmlSAXParseFile(filename, encoding, NULL, NULL)); 6579 } 6580 6581 /** 6582 * htmlHandleOmittedElem: 6583 * @val: int 0 or 1 6584 * 6585 * Set and return the previous value for handling HTML omitted tags. 6586 * 6587 * Returns the last value for 0 for no handling, 1 for auto insertion. 6588 */ 6589 6590 int 6591 htmlHandleOmittedElem(int val) { 6592 int old = htmlOmittedDefaultValue; 6593 6594 htmlOmittedDefaultValue = val; 6595 return(old); 6596 } 6597 6598 /** 6599 * htmlElementAllowedHere: 6600 * @parent: HTML parent element 6601 * @elt: HTML element 6602 * 6603 * Checks whether an HTML element may be a direct child of a parent element. 6604 * Note - doesn't check for deprecated elements 6605 * 6606 * Returns 1 if allowed; 0 otherwise. 6607 */ 6608 int 6609 htmlElementAllowedHere(const htmlElemDesc* parent, const xmlChar* elt) { 6610 const char** p ; 6611 6612 if ( ! elt || ! parent || ! parent->subelts ) 6613 return 0 ; 6614 6615 for ( p = parent->subelts; *p; ++p ) 6616 if ( !xmlStrcmp((const xmlChar *)*p, elt) ) 6617 return 1 ; 6618 6619 return 0 ; 6620 } 6621 /** 6622 * htmlElementStatusHere: 6623 * @parent: HTML parent element 6624 * @elt: HTML element 6625 * 6626 * Checks whether an HTML element may be a direct child of a parent element. 6627 * and if so whether it is valid or deprecated. 6628 * 6629 * Returns one of HTML_VALID, HTML_DEPRECATED, HTML_INVALID 6630 */ 6631 htmlStatus 6632 htmlElementStatusHere(const htmlElemDesc* parent, const htmlElemDesc* elt) { 6633 if ( ! parent || ! elt ) 6634 return HTML_INVALID ; 6635 if ( ! htmlElementAllowedHere(parent, (const xmlChar*) elt->name ) ) 6636 return HTML_INVALID ; 6637 6638 return ( elt->dtd == 0 ) ? HTML_VALID : HTML_DEPRECATED ; 6639 } 6640 /** 6641 * htmlAttrAllowed: 6642 * @elt: HTML element 6643 * @attr: HTML attribute 6644 * @legacy: whether to allow deprecated attributes 6645 * 6646 * Checks whether an attribute is valid for an element 6647 * Has full knowledge of Required and Deprecated attributes 6648 * 6649 * Returns one of HTML_REQUIRED, HTML_VALID, HTML_DEPRECATED, HTML_INVALID 6650 */ 6651 htmlStatus 6652 htmlAttrAllowed(const htmlElemDesc* elt, const xmlChar* attr, int legacy) { 6653 const char** p ; 6654 6655 if ( !elt || ! attr ) 6656 return HTML_INVALID ; 6657 6658 if ( elt->attrs_req ) 6659 for ( p = elt->attrs_req; *p; ++p) 6660 if ( !xmlStrcmp((const xmlChar*)*p, attr) ) 6661 return HTML_REQUIRED ; 6662 6663 if ( elt->attrs_opt ) 6664 for ( p = elt->attrs_opt; *p; ++p) 6665 if ( !xmlStrcmp((const xmlChar*)*p, attr) ) 6666 return HTML_VALID ; 6667 6668 if ( legacy && elt->attrs_depr ) 6669 for ( p = elt->attrs_depr; *p; ++p) 6670 if ( !xmlStrcmp((const xmlChar*)*p, attr) ) 6671 return HTML_DEPRECATED ; 6672 6673 return HTML_INVALID ; 6674 } 6675 /** 6676 * htmlNodeStatus: 6677 * @node: an htmlNodePtr in a tree 6678 * @legacy: whether to allow deprecated elements (YES is faster here 6679 * for Element nodes) 6680 * 6681 * Checks whether the tree node is valid. Experimental (the author 6682 * only uses the HTML enhancements in a SAX parser) 6683 * 6684 * Return: for Element nodes, a return from htmlElementAllowedHere (if 6685 * legacy allowed) or htmlElementStatusHere (otherwise). 6686 * for Attribute nodes, a return from htmlAttrAllowed 6687 * for other nodes, HTML_NA (no checks performed) 6688 */ 6689 htmlStatus 6690 htmlNodeStatus(const htmlNodePtr node, int legacy) { 6691 if ( ! node ) 6692 return HTML_INVALID ; 6693 6694 switch ( node->type ) { 6695 case XML_ELEMENT_NODE: 6696 return legacy 6697 ? ( htmlElementAllowedHere ( 6698 htmlTagLookup(node->parent->name) , node->name 6699 ) ? HTML_VALID : HTML_INVALID ) 6700 : htmlElementStatusHere( 6701 htmlTagLookup(node->parent->name) , 6702 htmlTagLookup(node->name) ) 6703 ; 6704 case XML_ATTRIBUTE_NODE: 6705 return htmlAttrAllowed( 6706 htmlTagLookup(node->parent->name) , node->name, legacy) ; 6707 default: return HTML_NA ; 6708 } 6709 } 6710 /************************************************************************ 6711 * * 6712 * New set (2.6.0) of simpler and more flexible APIs * 6713 * * 6714 ************************************************************************/ 6715 /** 6716 * DICT_FREE: 6717 * @str: a string 6718 * 6719 * Free a string if it is not owned by the "dict" dictionary in the 6720 * current scope 6721 */ 6722 #define DICT_FREE(str) \ 6723 if ((str) && ((!dict) || \ 6724 (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \ 6725 xmlFree((char *)(str)); 6726 6727 /** 6728 * htmlCtxtReset: 6729 * @ctxt: an HTML parser context 6730 * 6731 * Reset a parser context 6732 */ 6733 void 6734 htmlCtxtReset(htmlParserCtxtPtr ctxt) 6735 { 6736 xmlParserInputPtr input; 6737 xmlDictPtr dict; 6738 6739 if (ctxt == NULL) 6740 return; 6741 6742 xmlInitParser(); 6743 dict = ctxt->dict; 6744 6745 while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */ 6746 xmlFreeInputStream(input); 6747 } 6748 ctxt->inputNr = 0; 6749 ctxt->input = NULL; 6750 6751 ctxt->spaceNr = 0; 6752 if (ctxt->spaceTab != NULL) { 6753 ctxt->spaceTab[0] = -1; 6754 ctxt->space = &ctxt->spaceTab[0]; 6755 } else { 6756 ctxt->space = NULL; 6757 } 6758 6759 6760 ctxt->nodeNr = 0; 6761 ctxt->node = NULL; 6762 6763 ctxt->nameNr = 0; 6764 ctxt->name = NULL; 6765 6766 ctxt->nsNr = 0; 6767 6768 DICT_FREE(ctxt->version); 6769 ctxt->version = NULL; 6770 DICT_FREE(ctxt->encoding); 6771 ctxt->encoding = NULL; 6772 DICT_FREE(ctxt->directory); 6773 ctxt->directory = NULL; 6774 DICT_FREE(ctxt->extSubURI); 6775 ctxt->extSubURI = NULL; 6776 DICT_FREE(ctxt->extSubSystem); 6777 ctxt->extSubSystem = NULL; 6778 if (ctxt->myDoc != NULL) 6779 xmlFreeDoc(ctxt->myDoc); 6780 ctxt->myDoc = NULL; 6781 6782 ctxt->standalone = -1; 6783 ctxt->hasExternalSubset = 0; 6784 ctxt->hasPErefs = 0; 6785 ctxt->html = 1; 6786 ctxt->external = 0; 6787 ctxt->instate = XML_PARSER_START; 6788 ctxt->token = 0; 6789 6790 ctxt->wellFormed = 1; 6791 ctxt->nsWellFormed = 1; 6792 ctxt->disableSAX = 0; 6793 ctxt->valid = 1; 6794 ctxt->vctxt.userData = ctxt; 6795 ctxt->vctxt.error = xmlParserValidityError; 6796 ctxt->vctxt.warning = xmlParserValidityWarning; 6797 ctxt->record_info = 0; 6798 ctxt->checkIndex = 0; 6799 ctxt->inSubset = 0; 6800 ctxt->errNo = XML_ERR_OK; 6801 ctxt->depth = 0; 6802 ctxt->charset = XML_CHAR_ENCODING_NONE; 6803 ctxt->catalogs = NULL; 6804 xmlInitNodeInfoSeq(&ctxt->node_seq); 6805 6806 if (ctxt->attsDefault != NULL) { 6807 xmlHashFree(ctxt->attsDefault, xmlHashDefaultDeallocator); 6808 ctxt->attsDefault = NULL; 6809 } 6810 if (ctxt->attsSpecial != NULL) { 6811 xmlHashFree(ctxt->attsSpecial, NULL); 6812 ctxt->attsSpecial = NULL; 6813 } 6814 } 6815 6816 /** 6817 * htmlCtxtUseOptions: 6818 * @ctxt: an HTML parser context 6819 * @options: a combination of htmlParserOption(s) 6820 * 6821 * Applies the options to the parser context 6822 * 6823 * Returns 0 in case of success, the set of unknown or unimplemented options 6824 * in case of error. 6825 */ 6826 int 6827 htmlCtxtUseOptions(htmlParserCtxtPtr ctxt, int options) 6828 { 6829 if (ctxt == NULL) 6830 return(-1); 6831 6832 if (options & HTML_PARSE_NOWARNING) { 6833 ctxt->sax->warning = NULL; 6834 ctxt->vctxt.warning = NULL; 6835 options -= XML_PARSE_NOWARNING; 6836 ctxt->options |= XML_PARSE_NOWARNING; 6837 } 6838 if (options & HTML_PARSE_NOERROR) { 6839 ctxt->sax->error = NULL; 6840 ctxt->vctxt.error = NULL; 6841 ctxt->sax->fatalError = NULL; 6842 options -= XML_PARSE_NOERROR; 6843 ctxt->options |= XML_PARSE_NOERROR; 6844 } 6845 if (options & HTML_PARSE_PEDANTIC) { 6846 ctxt->pedantic = 1; 6847 options -= XML_PARSE_PEDANTIC; 6848 ctxt->options |= XML_PARSE_PEDANTIC; 6849 } else 6850 ctxt->pedantic = 0; 6851 if (options & XML_PARSE_NOBLANKS) { 6852 ctxt->keepBlanks = 0; 6853 ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace; 6854 options -= XML_PARSE_NOBLANKS; 6855 ctxt->options |= XML_PARSE_NOBLANKS; 6856 } else 6857 ctxt->keepBlanks = 1; 6858 if (options & HTML_PARSE_RECOVER) { 6859 ctxt->recovery = 1; 6860 options -= HTML_PARSE_RECOVER; 6861 } else 6862 ctxt->recovery = 0; 6863 if (options & HTML_PARSE_COMPACT) { 6864 ctxt->options |= HTML_PARSE_COMPACT; 6865 options -= HTML_PARSE_COMPACT; 6866 } 6867 if (options & XML_PARSE_HUGE) { 6868 ctxt->options |= XML_PARSE_HUGE; 6869 options -= XML_PARSE_HUGE; 6870 } 6871 if (options & HTML_PARSE_NODEFDTD) { 6872 ctxt->options |= HTML_PARSE_NODEFDTD; 6873 options -= HTML_PARSE_NODEFDTD; 6874 } 6875 if (options & HTML_PARSE_IGNORE_ENC) { 6876 ctxt->options |= HTML_PARSE_IGNORE_ENC; 6877 options -= HTML_PARSE_IGNORE_ENC; 6878 } 6879 if (options & HTML_PARSE_NOIMPLIED) { 6880 ctxt->options |= HTML_PARSE_NOIMPLIED; 6881 options -= HTML_PARSE_NOIMPLIED; 6882 } 6883 ctxt->dictNames = 0; 6884 return (options); 6885 } 6886 6887 /** 6888 * htmlDoRead: 6889 * @ctxt: an HTML parser context 6890 * @URL: the base URL to use for the document 6891 * @encoding: the document encoding, or NULL 6892 * @options: a combination of htmlParserOption(s) 6893 * @reuse: keep the context for reuse 6894 * 6895 * Common front-end for the htmlRead functions 6896 * 6897 * Returns the resulting document tree or NULL 6898 */ 6899 static htmlDocPtr 6900 htmlDoRead(htmlParserCtxtPtr ctxt, const char *URL, const char *encoding, 6901 int options, int reuse) 6902 { 6903 htmlDocPtr ret; 6904 6905 htmlCtxtUseOptions(ctxt, options); 6906 ctxt->html = 1; 6907 if (encoding != NULL) { 6908 xmlCharEncodingHandlerPtr hdlr; 6909 6910 hdlr = xmlFindCharEncodingHandler(encoding); 6911 if (hdlr != NULL) { 6912 xmlSwitchToEncoding(ctxt, hdlr); 6913 if (ctxt->input->encoding != NULL) 6914 xmlFree((xmlChar *) ctxt->input->encoding); 6915 ctxt->input->encoding = xmlStrdup((xmlChar *)encoding); 6916 } 6917 } 6918 if ((URL != NULL) && (ctxt->input != NULL) && 6919 (ctxt->input->filename == NULL)) 6920 ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL); 6921 htmlParseDocument(ctxt); 6922 ret = ctxt->myDoc; 6923 ctxt->myDoc = NULL; 6924 if (!reuse) { 6925 if ((ctxt->dictNames) && 6926 (ret != NULL) && 6927 (ret->dict == ctxt->dict)) 6928 ctxt->dict = NULL; 6929 xmlFreeParserCtxt(ctxt); 6930 } 6931 return (ret); 6932 } 6933 6934 /** 6935 * htmlReadDoc: 6936 * @cur: a pointer to a zero terminated string 6937 * @URL: the base URL to use for the document 6938 * @encoding: the document encoding, or NULL 6939 * @options: a combination of htmlParserOption(s) 6940 * 6941 * parse an XML in-memory document and build a tree. 6942 * 6943 * Returns the resulting document tree 6944 */ 6945 htmlDocPtr 6946 htmlReadDoc(const xmlChar * cur, const char *URL, const char *encoding, int options) 6947 { 6948 htmlParserCtxtPtr ctxt; 6949 6950 if (cur == NULL) 6951 return (NULL); 6952 6953 xmlInitParser(); 6954 ctxt = htmlCreateDocParserCtxt(cur, NULL); 6955 if (ctxt == NULL) 6956 return (NULL); 6957 return (htmlDoRead(ctxt, URL, encoding, options, 0)); 6958 } 6959 6960 /** 6961 * htmlReadFile: 6962 * @filename: a file or URL 6963 * @encoding: the document encoding, or NULL 6964 * @options: a combination of htmlParserOption(s) 6965 * 6966 * parse an XML file from the filesystem or the network. 6967 * 6968 * Returns the resulting document tree 6969 */ 6970 htmlDocPtr 6971 htmlReadFile(const char *filename, const char *encoding, int options) 6972 { 6973 htmlParserCtxtPtr ctxt; 6974 6975 xmlInitParser(); 6976 ctxt = htmlCreateFileParserCtxt(filename, encoding); 6977 if (ctxt == NULL) 6978 return (NULL); 6979 return (htmlDoRead(ctxt, NULL, NULL, options, 0)); 6980 } 6981 6982 /** 6983 * htmlReadMemory: 6984 * @buffer: a pointer to a char array 6985 * @size: the size of the array 6986 * @URL: the base URL to use for the document 6987 * @encoding: the document encoding, or NULL 6988 * @options: a combination of htmlParserOption(s) 6989 * 6990 * parse an XML in-memory document and build a tree. 6991 * 6992 * Returns the resulting document tree 6993 */ 6994 htmlDocPtr 6995 htmlReadMemory(const char *buffer, int size, const char *URL, const char *encoding, int options) 6996 { 6997 htmlParserCtxtPtr ctxt; 6998 6999 xmlInitParser(); 7000 ctxt = xmlCreateMemoryParserCtxt(buffer, size); 7001 if (ctxt == NULL) 7002 return (NULL); 7003 htmlDefaultSAXHandlerInit(); 7004 if (ctxt->sax != NULL) 7005 memcpy(ctxt->sax, &htmlDefaultSAXHandler, sizeof(xmlSAXHandlerV1)); 7006 return (htmlDoRead(ctxt, URL, encoding, options, 0)); 7007 } 7008 7009 /** 7010 * htmlReadFd: 7011 * @fd: an open file descriptor 7012 * @URL: the base URL to use for the document 7013 * @encoding: the document encoding, or NULL 7014 * @options: a combination of htmlParserOption(s) 7015 * 7016 * parse an HTML from a file descriptor and build a tree. 7017 * NOTE that the file descriptor will not be closed when the 7018 * reader is closed or reset. 7019 * 7020 * Returns the resulting document tree 7021 */ 7022 htmlDocPtr 7023 htmlReadFd(int fd, const char *URL, const char *encoding, int options) 7024 { 7025 htmlParserCtxtPtr ctxt; 7026 xmlParserInputBufferPtr input; 7027 htmlParserInputPtr stream; 7028 7029 if (fd < 0) 7030 return (NULL); 7031 7032 xmlInitParser(); 7033 input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE); 7034 if (input == NULL) 7035 return (NULL); 7036 input->closecallback = NULL; 7037 ctxt = htmlNewParserCtxt(); 7038 if (ctxt == NULL) { 7039 xmlFreeParserInputBuffer(input); 7040 return (NULL); 7041 } 7042 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 7043 if (stream == NULL) { 7044 xmlFreeParserInputBuffer(input); 7045 htmlFreeParserCtxt(ctxt); 7046 return (NULL); 7047 } 7048 inputPush(ctxt, stream); 7049 return (htmlDoRead(ctxt, URL, encoding, options, 0)); 7050 } 7051 7052 /** 7053 * htmlReadIO: 7054 * @ioread: an I/O read function 7055 * @ioclose: an I/O close function 7056 * @ioctx: an I/O handler 7057 * @URL: the base URL to use for the document 7058 * @encoding: the document encoding, or NULL 7059 * @options: a combination of htmlParserOption(s) 7060 * 7061 * parse an HTML document from I/O functions and source and build a tree. 7062 * 7063 * Returns the resulting document tree 7064 */ 7065 htmlDocPtr 7066 htmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose, 7067 void *ioctx, const char *URL, const char *encoding, int options) 7068 { 7069 htmlParserCtxtPtr ctxt; 7070 xmlParserInputBufferPtr input; 7071 xmlParserInputPtr stream; 7072 7073 if (ioread == NULL) 7074 return (NULL); 7075 xmlInitParser(); 7076 7077 input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, 7078 XML_CHAR_ENCODING_NONE); 7079 if (input == NULL) { 7080 if (ioclose != NULL) 7081 ioclose(ioctx); 7082 return (NULL); 7083 } 7084 ctxt = htmlNewParserCtxt(); 7085 if (ctxt == NULL) { 7086 xmlFreeParserInputBuffer(input); 7087 return (NULL); 7088 } 7089 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 7090 if (stream == NULL) { 7091 xmlFreeParserInputBuffer(input); 7092 xmlFreeParserCtxt(ctxt); 7093 return (NULL); 7094 } 7095 inputPush(ctxt, stream); 7096 return (htmlDoRead(ctxt, URL, encoding, options, 0)); 7097 } 7098 7099 /** 7100 * htmlCtxtReadDoc: 7101 * @ctxt: an HTML parser context 7102 * @cur: a pointer to a zero terminated string 7103 * @URL: the base URL to use for the document 7104 * @encoding: the document encoding, or NULL 7105 * @options: a combination of htmlParserOption(s) 7106 * 7107 * parse an XML in-memory document and build a tree. 7108 * This reuses the existing @ctxt parser context 7109 * 7110 * Returns the resulting document tree 7111 */ 7112 htmlDocPtr 7113 htmlCtxtReadDoc(htmlParserCtxtPtr ctxt, const xmlChar * cur, 7114 const char *URL, const char *encoding, int options) 7115 { 7116 if (cur == NULL) 7117 return (NULL); 7118 return (htmlCtxtReadMemory(ctxt, (const char *) cur, xmlStrlen(cur), URL, 7119 encoding, options)); 7120 } 7121 7122 /** 7123 * htmlCtxtReadFile: 7124 * @ctxt: an HTML parser context 7125 * @filename: a file or URL 7126 * @encoding: the document encoding, or NULL 7127 * @options: a combination of htmlParserOption(s) 7128 * 7129 * parse an XML file from the filesystem or the network. 7130 * This reuses the existing @ctxt parser context 7131 * 7132 * Returns the resulting document tree 7133 */ 7134 htmlDocPtr 7135 htmlCtxtReadFile(htmlParserCtxtPtr ctxt, const char *filename, 7136 const char *encoding, int options) 7137 { 7138 xmlParserInputPtr stream; 7139 7140 if (filename == NULL) 7141 return (NULL); 7142 if (ctxt == NULL) 7143 return (NULL); 7144 xmlInitParser(); 7145 7146 htmlCtxtReset(ctxt); 7147 7148 stream = xmlLoadExternalEntity(filename, NULL, ctxt); 7149 if (stream == NULL) { 7150 return (NULL); 7151 } 7152 inputPush(ctxt, stream); 7153 return (htmlDoRead(ctxt, NULL, encoding, options, 1)); 7154 } 7155 7156 /** 7157 * htmlCtxtReadMemory: 7158 * @ctxt: an HTML parser context 7159 * @buffer: a pointer to a char array 7160 * @size: the size of the array 7161 * @URL: the base URL to use for the document 7162 * @encoding: the document encoding, or NULL 7163 * @options: a combination of htmlParserOption(s) 7164 * 7165 * parse an XML in-memory document and build a tree. 7166 * This reuses the existing @ctxt parser context 7167 * 7168 * Returns the resulting document tree 7169 */ 7170 htmlDocPtr 7171 htmlCtxtReadMemory(htmlParserCtxtPtr ctxt, const char *buffer, int size, 7172 const char *URL, const char *encoding, int options) 7173 { 7174 xmlParserInputBufferPtr input; 7175 xmlParserInputPtr stream; 7176 7177 if (ctxt == NULL) 7178 return (NULL); 7179 if (buffer == NULL) 7180 return (NULL); 7181 xmlInitParser(); 7182 7183 htmlCtxtReset(ctxt); 7184 7185 input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE); 7186 if (input == NULL) { 7187 return(NULL); 7188 } 7189 7190 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 7191 if (stream == NULL) { 7192 xmlFreeParserInputBuffer(input); 7193 return(NULL); 7194 } 7195 7196 inputPush(ctxt, stream); 7197 return (htmlDoRead(ctxt, URL, encoding, options, 1)); 7198 } 7199 7200 /** 7201 * htmlCtxtReadFd: 7202 * @ctxt: an HTML parser context 7203 * @fd: an open file descriptor 7204 * @URL: the base URL to use for the document 7205 * @encoding: the document encoding, or NULL 7206 * @options: a combination of htmlParserOption(s) 7207 * 7208 * parse an XML from a file descriptor and build a tree. 7209 * This reuses the existing @ctxt parser context 7210 * 7211 * Returns the resulting document tree 7212 */ 7213 htmlDocPtr 7214 htmlCtxtReadFd(htmlParserCtxtPtr ctxt, int fd, 7215 const char *URL, const char *encoding, int options) 7216 { 7217 xmlParserInputBufferPtr input; 7218 xmlParserInputPtr stream; 7219 7220 if (fd < 0) 7221 return (NULL); 7222 if (ctxt == NULL) 7223 return (NULL); 7224 xmlInitParser(); 7225 7226 htmlCtxtReset(ctxt); 7227 7228 7229 input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE); 7230 if (input == NULL) 7231 return (NULL); 7232 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 7233 if (stream == NULL) { 7234 xmlFreeParserInputBuffer(input); 7235 return (NULL); 7236 } 7237 inputPush(ctxt, stream); 7238 return (htmlDoRead(ctxt, URL, encoding, options, 1)); 7239 } 7240 7241 /** 7242 * htmlCtxtReadIO: 7243 * @ctxt: an HTML parser context 7244 * @ioread: an I/O read function 7245 * @ioclose: an I/O close function 7246 * @ioctx: an I/O handler 7247 * @URL: the base URL to use for the document 7248 * @encoding: the document encoding, or NULL 7249 * @options: a combination of htmlParserOption(s) 7250 * 7251 * parse an HTML document from I/O functions and source and build a tree. 7252 * This reuses the existing @ctxt parser context 7253 * 7254 * Returns the resulting document tree 7255 */ 7256 htmlDocPtr 7257 htmlCtxtReadIO(htmlParserCtxtPtr ctxt, xmlInputReadCallback ioread, 7258 xmlInputCloseCallback ioclose, void *ioctx, 7259 const char *URL, 7260 const char *encoding, int options) 7261 { 7262 xmlParserInputBufferPtr input; 7263 xmlParserInputPtr stream; 7264 7265 if (ioread == NULL) 7266 return (NULL); 7267 if (ctxt == NULL) 7268 return (NULL); 7269 xmlInitParser(); 7270 7271 htmlCtxtReset(ctxt); 7272 7273 input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, 7274 XML_CHAR_ENCODING_NONE); 7275 if (input == NULL) { 7276 if (ioclose != NULL) 7277 ioclose(ioctx); 7278 return (NULL); 7279 } 7280 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 7281 if (stream == NULL) { 7282 xmlFreeParserInputBuffer(input); 7283 return (NULL); 7284 } 7285 inputPush(ctxt, stream); 7286 return (htmlDoRead(ctxt, URL, encoding, options, 1)); 7287 } 7288 7289 #endif /* LIBXML_HTML_ENABLED */ 7290