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