Coverage Report

Created: 2024-02-11 06:19

/src/libxml2/HTMLparser.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * HTMLparser.c : an HTML 4.0 non-verifying parser
3
 *
4
 * See Copyright for the status of this software.
5
 *
6
 * daniel@veillard.com
7
 */
8
9
#define IN_LIBXML
10
#include "libxml.h"
11
#ifdef LIBXML_HTML_ENABLED
12
13
#include <string.h>
14
#include <ctype.h>
15
#include <stdlib.h>
16
17
#include <libxml/HTMLparser.h>
18
#include <libxml/xmlmemory.h>
19
#include <libxml/tree.h>
20
#include <libxml/parser.h>
21
#include <libxml/parserInternals.h>
22
#include <libxml/xmlerror.h>
23
#include <libxml/HTMLtree.h>
24
#include <libxml/entities.h>
25
#include <libxml/encoding.h>
26
#include <libxml/xmlIO.h>
27
#include <libxml/uri.h>
28
29
#include "private/buf.h"
30
#include "private/enc.h"
31
#include "private/error.h"
32
#include "private/html.h"
33
#include "private/io.h"
34
#include "private/parser.h"
35
#include "private/tree.h"
36
37
#define HTML_MAX_NAMELEN 1000
38
0
#define HTML_PARSER_BIG_BUFFER_SIZE 1000
39
0
#define HTML_PARSER_BUFFER_SIZE 100
40
41
static int htmlOmittedDefaultValue = 1;
42
43
xmlChar * htmlDecodeEntities(htmlParserCtxtPtr ctxt, int len,
44
           xmlChar end, xmlChar  end2, xmlChar end3);
45
static void htmlParseComment(htmlParserCtxtPtr ctxt);
46
47
/************************************************************************
48
 *                  *
49
 *    Some factorized error routines        *
50
 *                  *
51
 ************************************************************************/
52
53
/**
54
 * htmlErrMemory:
55
 * @ctxt:  an HTML parser context
56
 * @extra:  extra information
57
 *
58
 * Handle a redefinition of attribute error
59
 */
60
static void
61
htmlErrMemory(xmlParserCtxtPtr ctxt)
62
0
{
63
0
    xmlCtxtErrMemory(ctxt);
64
0
}
65
66
/**
67
 * htmlParseErr:
68
 * @ctxt:  an HTML parser context
69
 * @error:  the error number
70
 * @msg:  the error message
71
 * @str1:  string infor
72
 * @str2:  string infor
73
 *
74
 * Handle a fatal parser error, i.e. violating Well-Formedness constraints
75
 */
76
static void LIBXML_ATTR_FORMAT(3,0)
77
htmlParseErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
78
             const char *msg, const xmlChar *str1, const xmlChar *str2)
79
0
{
80
0
    xmlCtxtErr(ctxt, NULL, XML_FROM_HTML, error, XML_ERR_ERROR,
81
0
               str1, str2, NULL, 0, msg, str1, str2);
82
0
}
83
84
/**
85
 * htmlParseErrInt:
86
 * @ctxt:  an HTML parser context
87
 * @error:  the error number
88
 * @msg:  the error message
89
 * @val:  integer info
90
 *
91
 * Handle a fatal parser error, i.e. violating Well-Formedness constraints
92
 */
93
static void LIBXML_ATTR_FORMAT(3,0)
94
htmlParseErrInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
95
             const char *msg, int val)
96
0
{
97
0
    xmlCtxtErr(ctxt, NULL, XML_FROM_HTML, error, XML_ERR_ERROR,
98
0
               NULL, NULL, NULL, val, msg, val);
99
0
}
100
101
/************************************************************************
102
 *                  *
103
 *  Parser stacks related functions and macros    *
104
 *                  *
105
 ************************************************************************/
106
107
/**
108
 * htmlnamePush:
109
 * @ctxt:  an HTML parser context
110
 * @value:  the element name
111
 *
112
 * Pushes a new element name on top of the name stack
113
 *
114
 * Returns -1 in case of error, the index in the stack otherwise
115
 */
116
static int
117
htmlnamePush(htmlParserCtxtPtr ctxt, const xmlChar * value)
118
0
{
119
0
    if ((ctxt->html < 3) && (xmlStrEqual(value, BAD_CAST "head")))
120
0
        ctxt->html = 3;
121
0
    if ((ctxt->html < 10) && (xmlStrEqual(value, BAD_CAST "body")))
122
0
        ctxt->html = 10;
123
0
    if (ctxt->nameNr >= ctxt->nameMax) {
124
0
        size_t newSize = ctxt->nameMax * 2;
125
0
        const xmlChar **tmp;
126
127
0
        tmp = xmlRealloc((xmlChar **) ctxt->nameTab,
128
0
                         newSize * sizeof(ctxt->nameTab[0]));
129
0
        if (tmp == NULL) {
130
0
            htmlErrMemory(ctxt);
131
0
            return (-1);
132
0
        }
133
0
        ctxt->nameTab = tmp;
134
0
        ctxt->nameMax = newSize;
135
0
    }
136
0
    ctxt->nameTab[ctxt->nameNr] = value;
137
0
    ctxt->name = value;
138
0
    return (ctxt->nameNr++);
139
0
}
140
/**
141
 * htmlnamePop:
142
 * @ctxt: an HTML parser context
143
 *
144
 * Pops the top element name from the name stack
145
 *
146
 * Returns the name just removed
147
 */
148
static const xmlChar *
149
htmlnamePop(htmlParserCtxtPtr ctxt)
150
0
{
151
0
    const xmlChar *ret;
152
153
0
    if (ctxt->nameNr <= 0)
154
0
        return (NULL);
155
0
    ctxt->nameNr--;
156
0
    if (ctxt->nameNr < 0)
157
0
        return (NULL);
158
0
    if (ctxt->nameNr > 0)
159
0
        ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
160
0
    else
161
0
        ctxt->name = NULL;
162
0
    ret = ctxt->nameTab[ctxt->nameNr];
163
0
    ctxt->nameTab[ctxt->nameNr] = NULL;
164
0
    return (ret);
165
0
}
166
167
/**
168
 * htmlNodeInfoPush:
169
 * @ctxt:  an HTML parser context
170
 * @value:  the node info
171
 *
172
 * Pushes a new element name on top of the node info stack
173
 *
174
 * Returns 0 in case of error, the index in the stack otherwise
175
 */
176
static int
177
htmlNodeInfoPush(htmlParserCtxtPtr ctxt, htmlParserNodeInfo *value)
178
0
{
179
0
    if (ctxt->nodeInfoNr >= ctxt->nodeInfoMax) {
180
0
        if (ctxt->nodeInfoMax == 0)
181
0
                ctxt->nodeInfoMax = 5;
182
0
        ctxt->nodeInfoMax *= 2;
183
0
        ctxt->nodeInfoTab = (htmlParserNodeInfo *)
184
0
                         xmlRealloc((htmlParserNodeInfo *)ctxt->nodeInfoTab,
185
0
                                    ctxt->nodeInfoMax *
186
0
                                    sizeof(ctxt->nodeInfoTab[0]));
187
0
        if (ctxt->nodeInfoTab == NULL) {
188
0
            htmlErrMemory(ctxt);
189
0
            return (0);
190
0
        }
191
0
    }
192
0
    ctxt->nodeInfoTab[ctxt->nodeInfoNr] = *value;
193
0
    ctxt->nodeInfo = &ctxt->nodeInfoTab[ctxt->nodeInfoNr];
194
0
    return (ctxt->nodeInfoNr++);
195
0
}
196
197
/**
198
 * htmlNodeInfoPop:
199
 * @ctxt:  an HTML parser context
200
 *
201
 * Pops the top element name from the node info stack
202
 *
203
 * Returns 0 in case of error, the pointer to NodeInfo otherwise
204
 */
205
static htmlParserNodeInfo *
206
htmlNodeInfoPop(htmlParserCtxtPtr ctxt)
207
0
{
208
0
    if (ctxt->nodeInfoNr <= 0)
209
0
        return (NULL);
210
0
    ctxt->nodeInfoNr--;
211
0
    if (ctxt->nodeInfoNr < 0)
212
0
        return (NULL);
213
0
    if (ctxt->nodeInfoNr > 0)
214
0
        ctxt->nodeInfo = &ctxt->nodeInfoTab[ctxt->nodeInfoNr - 1];
215
0
    else
216
0
        ctxt->nodeInfo = NULL;
217
0
    return &ctxt->nodeInfoTab[ctxt->nodeInfoNr];
218
0
}
219
220
/*
221
 * Macros for accessing the content. Those should be used only by the parser,
222
 * and not exported.
223
 *
224
 * Dirty macros, i.e. one need to make assumption on the context to use them
225
 *
226
 *   CUR_PTR return the current pointer to the xmlChar to be parsed.
227
 *   CUR     returns the current xmlChar value, i.e. a 8 bit value if compiled
228
 *           in ISO-Latin or UTF-8, and the current 16 bit value if compiled
229
 *           in UNICODE mode. This should be used internally by the parser
230
 *           only to compare to ASCII values otherwise it would break when
231
 *           running with UTF-8 encoding.
232
 *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
233
 *           to compare on ASCII based substring.
234
 *   UPP(n)  returns the n'th next xmlChar converted to uppercase. Same as CUR
235
 *           it should be used only to compare on ASCII based substring.
236
 *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
237
 *           strings without newlines within the parser.
238
 *
239
 * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
240
 *
241
 *   NEXT    Skip to the next character, this does the proper decoding
242
 *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
243
 *   NEXTL(l) Skip the current unicode character of l xmlChars long.
244
 *   COPY(to) copy one char to *to, increment CUR_PTR and to accordingly
245
 */
246
247
0
#define UPPER (toupper(*ctxt->input->cur))
248
249
0
#define SKIP(val) ctxt->input->cur += (val),ctxt->input->col+=(val)
250
251
0
#define NXT(val) ctxt->input->cur[(val)]
252
253
0
#define UPP(val) (toupper(ctxt->input->cur[(val)]))
254
255
0
#define CUR_PTR ctxt->input->cur
256
0
#define BASE_PTR ctxt->input->base
257
258
#define SHRINK \
259
0
    if ((!PARSER_PROGRESSIVE(ctxt)) && \
260
0
        (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
261
0
  (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
262
0
  xmlParserShrink(ctxt);
263
264
#define GROW \
265
0
    if ((!PARSER_PROGRESSIVE(ctxt)) && \
266
0
        (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \
267
0
  xmlParserGrow(ctxt);
268
269
0
#define SKIP_BLANKS htmlSkipBlankChars(ctxt)
270
271
/* Imported from XML */
272
273
0
#define CUR (*ctxt->input->cur)
274
0
#define NEXT xmlNextChar(ctxt)
275
276
0
#define RAW (*ctxt->input->cur)
277
278
279
0
#define NEXTL(l) do {             \
280
0
    if (*(ctxt->input->cur) == '\n') {         \
281
0
  ctxt->input->line++; ctxt->input->col = 1;      \
282
0
    } else ctxt->input->col++;           \
283
0
    ctxt->input->cur += l;            \
284
0
  } while (0)
285
286
/************
287
    \
288
    if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
289
    if (*ctxt->input->cur == '&') xmlParserHandleReference(ctxt);
290
 ************/
291
292
0
#define CUR_CHAR(l) htmlCurrentChar(ctxt, &l)
293
294
#define COPY_BUF(l,b,i,v)           \
295
0
    if (l == 1) b[i++] = v;           \
296
0
    else i += xmlCopyChar(l,&b[i],v)
297
298
/**
299
 * htmlFindEncoding:
300
 * @the HTML parser context
301
 *
302
 * Ty to find and encoding in the current data available in the input
303
 * buffer this is needed to try to switch to the proper encoding when
304
 * one face a character error.
305
 * That's an heuristic, since it's operating outside of parsing it could
306
 * try to use a meta which had been commented out, that's the reason it
307
 * should only be used in case of error, not as a default.
308
 *
309
 * Returns an encoding string or NULL if not found, the string need to
310
 *   be freed
311
 */
312
static xmlChar *
313
0
htmlFindEncoding(xmlParserCtxtPtr ctxt) {
314
0
    const xmlChar *start, *cur, *end;
315
0
    xmlChar *ret;
316
317
0
    if ((ctxt == NULL) || (ctxt->input == NULL) ||
318
0
        (ctxt->input->flags & XML_INPUT_HAS_ENCODING))
319
0
        return(NULL);
320
0
    if ((ctxt->input->cur == NULL) || (ctxt->input->end == NULL))
321
0
        return(NULL);
322
323
0
    start = ctxt->input->cur;
324
0
    end = ctxt->input->end;
325
    /* we also expect the input buffer to be zero terminated */
326
0
    if (*end != 0)
327
0
        return(NULL);
328
329
0
    cur = xmlStrcasestr(start, BAD_CAST "HTTP-EQUIV");
330
0
    if (cur == NULL)
331
0
        return(NULL);
332
0
    cur = xmlStrcasestr(cur, BAD_CAST  "CONTENT");
333
0
    if (cur == NULL)
334
0
        return(NULL);
335
0
    cur = xmlStrcasestr(cur, BAD_CAST  "CHARSET=");
336
0
    if (cur == NULL)
337
0
        return(NULL);
338
0
    cur += 8;
339
0
    start = cur;
340
0
    while (((*cur >= 'A') && (*cur <= 'Z')) ||
341
0
           ((*cur >= 'a') && (*cur <= 'z')) ||
342
0
           ((*cur >= '0') && (*cur <= '9')) ||
343
0
           (*cur == '-') || (*cur == '_') || (*cur == ':') || (*cur == '/'))
344
0
           cur++;
345
0
    if (cur == start)
346
0
        return(NULL);
347
0
    ret = xmlStrndup(start, cur - start);
348
0
    if (ret == NULL)
349
0
        htmlErrMemory(ctxt);
350
0
    return(ret);
351
0
}
352
353
/**
354
 * htmlCurrentChar:
355
 * @ctxt:  the HTML parser context
356
 * @len:  pointer to the length of the char read
357
 *
358
 * The current char value, if using UTF-8 this may actually span multiple
359
 * bytes in the input buffer. Implement the end of line normalization:
360
 * 2.11 End-of-Line Handling
361
 * If the encoding is unspecified, in the case we find an ISO-Latin-1
362
 * char, then the encoding converter is plugged in automatically.
363
 *
364
 * Returns the current char value and its length
365
 */
366
367
static int
368
0
htmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) {
369
0
    const unsigned char *cur;
370
0
    unsigned char c;
371
0
    unsigned int val;
372
373
0
    if (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)
374
0
        xmlParserGrow(ctxt);
375
376
0
    if ((ctxt->input->flags & XML_INPUT_HAS_ENCODING) == 0) {
377
0
        xmlChar * guess;
378
379
        /*
380
         * Assume it's a fixed length encoding (1) with
381
         * a compatible encoding for the ASCII set, since
382
         * HTML constructs only use < 128 chars
383
         */
384
0
        if (*ctxt->input->cur < 0x80) {
385
0
            if (*ctxt->input->cur == 0) {
386
0
                if (ctxt->input->cur < ctxt->input->end) {
387
0
                    htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
388
0
                                    "Char 0x%X out of allowed range\n", 0);
389
0
                    *len = 1;
390
0
                    return(' ');
391
0
                } else {
392
0
                    *len = 0;
393
0
                    return(0);
394
0
                }
395
0
            }
396
0
            *len = 1;
397
0
            return(*ctxt->input->cur);
398
0
        }
399
400
        /*
401
         * Humm this is bad, do an automatic flow conversion
402
         */
403
0
        guess = htmlFindEncoding(ctxt);
404
0
        if (guess == NULL) {
405
0
            xmlSwitchEncoding(ctxt, XML_CHAR_ENCODING_8859_1);
406
0
        } else {
407
0
            xmlSwitchEncodingName(ctxt, (const char *) guess);
408
0
            xmlFree(guess);
409
0
        }
410
0
        ctxt->input->flags |= XML_INPUT_HAS_ENCODING;
411
0
    }
412
413
    /*
414
     * We are supposed to handle UTF8, check it's valid
415
     * From rfc2044: encoding of the Unicode values on UTF-8:
416
     *
417
     * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
418
     * 0000 0000-0000 007F   0xxxxxxx
419
     * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
420
     * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
421
     *
422
     * Check for the 0x110000 limit too
423
     */
424
0
    cur = ctxt->input->cur;
425
0
    c = *cur;
426
0
    if (c & 0x80) {
427
0
        size_t avail;
428
429
0
        if ((c & 0x40) == 0)
430
0
            goto encoding_error;
431
432
0
        avail = ctxt->input->end - ctxt->input->cur;
433
434
0
        if ((avail < 2) || ((cur[1] & 0xc0) != 0x80))
435
0
            goto encoding_error;
436
0
        if ((c & 0xe0) == 0xe0) {
437
0
            if ((avail < 3) || ((cur[2] & 0xc0) != 0x80))
438
0
                goto encoding_error;
439
0
            if ((c & 0xf0) == 0xf0) {
440
0
                if (((c & 0xf8) != 0xf0) ||
441
0
                    (avail < 4) || ((cur[3] & 0xc0) != 0x80))
442
0
                    goto encoding_error;
443
                /* 4-byte code */
444
0
                *len = 4;
445
0
                val = (cur[0] & 0x7) << 18;
446
0
                val |= (cur[1] & 0x3f) << 12;
447
0
                val |= (cur[2] & 0x3f) << 6;
448
0
                val |= cur[3] & 0x3f;
449
0
                if (val < 0x10000)
450
0
                    goto encoding_error;
451
0
            } else {
452
              /* 3-byte code */
453
0
                *len = 3;
454
0
                val = (cur[0] & 0xf) << 12;
455
0
                val |= (cur[1] & 0x3f) << 6;
456
0
                val |= cur[2] & 0x3f;
457
0
                if (val < 0x800)
458
0
                    goto encoding_error;
459
0
            }
460
0
        } else {
461
          /* 2-byte code */
462
0
            *len = 2;
463
0
            val = (cur[0] & 0x1f) << 6;
464
0
            val |= cur[1] & 0x3f;
465
0
            if (val < 0x80)
466
0
                goto encoding_error;
467
0
        }
468
0
        if (!IS_CHAR(val)) {
469
0
            htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
470
0
                            "Char 0x%X out of allowed range\n", val);
471
0
        }
472
0
        return(val);
473
0
    } else {
474
0
        if (*ctxt->input->cur == 0) {
475
0
            if (ctxt->input->cur < ctxt->input->end) {
476
0
                htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
477
0
                                "Char 0x%X out of allowed range\n", 0);
478
0
                *len = 1;
479
0
                return(' ');
480
0
            } else {
481
0
                *len = 0;
482
0
                return(0);
483
0
            }
484
0
        }
485
        /* 1-byte code */
486
0
        *len = 1;
487
0
        return(*ctxt->input->cur);
488
0
    }
489
490
0
encoding_error:
491
0
    xmlCtxtErrIO(ctxt, XML_ERR_INVALID_ENCODING, NULL);
492
493
0
    if ((ctxt->input->flags & XML_INPUT_HAS_ENCODING) == 0)
494
0
        xmlSwitchEncoding(ctxt, XML_CHAR_ENCODING_8859_1);
495
0
    *len = 1;
496
0
    return(*ctxt->input->cur);
497
0
}
498
499
/**
500
 * htmlSkipBlankChars:
501
 * @ctxt:  the HTML parser context
502
 *
503
 * skip all blanks character found at that point in the input streams.
504
 *
505
 * Returns the number of space chars skipped
506
 */
507
508
static int
509
0
htmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
510
0
    int res = 0;
511
512
0
    while (IS_BLANK_CH(*(ctxt->input->cur))) {
513
0
        if (*(ctxt->input->cur) == '\n') {
514
0
            ctxt->input->line++; ctxt->input->col = 1;
515
0
        } else ctxt->input->col++;
516
0
        ctxt->input->cur++;
517
0
        if (*ctxt->input->cur == 0)
518
0
            xmlParserGrow(ctxt);
519
0
  if (res < INT_MAX)
520
0
      res++;
521
0
    }
522
0
    return(res);
523
0
}
524
525
526
527
/************************************************************************
528
 *                  *
529
 *  The list of HTML elements and their properties    *
530
 *                  *
531
 ************************************************************************/
532
533
/*
534
 *  Start Tag: 1 means the start tag can be omitted
535
 *  End Tag:   1 means the end tag can be omitted
536
 *             2 means it's forbidden (empty elements)
537
 *             3 means the tag is stylistic and should be closed easily
538
 *  Depr:      this element is deprecated
539
 *  DTD:       1 means that this element is valid only in the Loose DTD
540
 *             2 means that this element is valid only in the Frameset DTD
541
 *
542
 * Name,Start Tag,End Tag,Save End,Empty,Deprecated,DTD,inline,Description
543
  , subElements , impliedsubelt , Attributes, userdata
544
 */
545
546
/* Definitions and a couple of vars for HTML Elements */
547
548
#define FONTSTYLE "tt", "i", "b", "u", "s", "strike", "big", "small"
549
#define NB_FONTSTYLE 8
550
#define PHRASE "em", "strong", "dfn", "code", "samp", "kbd", "var", "cite", "abbr", "acronym"
551
#define NB_PHRASE 10
552
#define SPECIAL "a", "img", "applet", "embed", "object", "font", "basefont", "br", "script", "map", "q", "sub", "sup", "span", "bdo", "iframe"
553
#define NB_SPECIAL 16
554
#define INLINE FONTSTYLE, PHRASE, SPECIAL, FORMCTRL
555
#define NB_INLINE NB_PCDATA + NB_FONTSTYLE + NB_PHRASE + NB_SPECIAL + NB_FORMCTRL
556
#define BLOCK HEADING, LIST, "pre", "p", "dl", "div", "center", "noscript", "noframes", "blockquote", "form", "isindex", "hr", "table", "fieldset", "address"
557
#define NB_BLOCK NB_HEADING + NB_LIST + 14
558
#define FORMCTRL "input", "select", "textarea", "label", "button"
559
#define NB_FORMCTRL 5
560
#define PCDATA
561
#define NB_PCDATA 0
562
#define HEADING "h1", "h2", "h3", "h4", "h5", "h6"
563
#define NB_HEADING 6
564
#define LIST "ul", "ol", "dir", "menu"
565
#define NB_LIST 4
566
#define MODIFIER
567
#define NB_MODIFIER 0
568
#define FLOW BLOCK,INLINE
569
#define NB_FLOW NB_BLOCK + NB_INLINE
570
#define EMPTY NULL
571
572
573
static const char* const html_flow[] = { FLOW, NULL } ;
574
static const char* const html_inline[] = { INLINE, NULL } ;
575
576
/* placeholders: elts with content but no subelements */
577
static const char* const html_pcdata[] = { NULL } ;
578
#define html_cdata html_pcdata
579
580
581
/* ... and for HTML Attributes */
582
583
#define COREATTRS "id", "class", "style", "title"
584
#define NB_COREATTRS 4
585
#define I18N "lang", "dir"
586
#define NB_I18N 2
587
#define EVENTS "onclick", "ondblclick", "onmousedown", "onmouseup", "onmouseover", "onmouseout", "onkeypress", "onkeydown", "onkeyup"
588
#define NB_EVENTS 9
589
#define ATTRS COREATTRS,I18N,EVENTS
590
#define NB_ATTRS NB_NB_COREATTRS + NB_I18N + NB_EVENTS
591
#define CELLHALIGN "align", "char", "charoff"
592
#define NB_CELLHALIGN 3
593
#define CELLVALIGN "valign"
594
#define NB_CELLVALIGN 1
595
596
static const char* const html_attrs[] = { ATTRS, NULL } ;
597
static const char* const core_i18n_attrs[] = { COREATTRS, I18N, NULL } ;
598
static const char* const core_attrs[] = { COREATTRS, NULL } ;
599
static const char* const i18n_attrs[] = { I18N, NULL } ;
600
601
602
/* Other declarations that should go inline ... */
603
static const char* const a_attrs[] = { ATTRS, "charset", "type", "name",
604
  "href", "hreflang", "rel", "rev", "accesskey", "shape", "coords",
605
  "tabindex", "onfocus", "onblur", NULL } ;
606
static const char* const target_attr[] = { "target", NULL } ;
607
static const char* const rows_cols_attr[] = { "rows", "cols", NULL } ;
608
static const char* const alt_attr[] = { "alt", NULL } ;
609
static const char* const src_alt_attrs[] = { "src", "alt", NULL } ;
610
static const char* const href_attrs[] = { "href", NULL } ;
611
static const char* const clear_attrs[] = { "clear", NULL } ;
612
static const char* const inline_p[] = { INLINE, "p", NULL } ;
613
614
static const char* const flow_param[] = { FLOW, "param", NULL } ;
615
static const char* const applet_attrs[] = { COREATTRS , "codebase",
616
    "archive", "alt", "name", "height", "width", "align",
617
    "hspace", "vspace", NULL } ;
618
static const char* const area_attrs[] = { "shape", "coords", "href", "nohref",
619
  "tabindex", "accesskey", "onfocus", "onblur", NULL } ;
620
static const char* const basefont_attrs[] =
621
  { "id", "size", "color", "face", NULL } ;
622
static const char* const quote_attrs[] = { ATTRS, "cite", NULL } ;
623
static const char* const body_contents[] = { FLOW, "ins", "del", NULL } ;
624
static const char* const body_attrs[] = { ATTRS, "onload", "onunload", NULL } ;
625
static const char* const body_depr[] = { "background", "bgcolor", "text",
626
  "link", "vlink", "alink", NULL } ;
627
static const char* const button_attrs[] = { ATTRS, "name", "value", "type",
628
  "disabled", "tabindex", "accesskey", "onfocus", "onblur", NULL } ;
629
630
631
static const char* const col_attrs[] = { ATTRS, "span", "width", CELLHALIGN, CELLVALIGN, NULL } ;
632
static const char* const col_elt[] = { "col", NULL } ;
633
static const char* const edit_attrs[] = { ATTRS, "datetime", "cite", NULL } ;
634
static const char* const compact_attrs[] = { ATTRS, "compact", NULL } ;
635
static const char* const dl_contents[] = { "dt", "dd", NULL } ;
636
static const char* const compact_attr[] = { "compact", NULL } ;
637
static const char* const label_attr[] = { "label", NULL } ;
638
static const char* const fieldset_contents[] = { FLOW, "legend" } ;
639
static const char* const font_attrs[] = { COREATTRS, I18N, "size", "color", "face" , NULL } ;
640
static const char* const form_contents[] = { HEADING, LIST, INLINE, "pre", "p", "div", "center", "noscript", "noframes", "blockquote", "isindex", "hr", "table", "fieldset", "address", NULL } ;
641
static const char* const form_attrs[] = { ATTRS, "method", "enctype", "accept", "name", "onsubmit", "onreset", "accept-charset", NULL } ;
642
static const char* const frame_attrs[] = { COREATTRS, "longdesc", "name", "src", "frameborder", "marginwidth", "marginheight", "noresize", "scrolling" , NULL } ;
643
static const char* const frameset_attrs[] = { COREATTRS, "rows", "cols", "onload", "onunload", NULL } ;
644
static const char* const frameset_contents[] = { "frameset", "frame", "noframes", NULL } ;
645
static const char* const head_attrs[] = { I18N, "profile", NULL } ;
646
static const char* const head_contents[] = { "title", "isindex", "base", "script", "style", "meta", "link", "object", NULL } ;
647
static const char* const hr_depr[] = { "align", "noshade", "size", "width", NULL } ;
648
static const char* const version_attr[] = { "version", NULL } ;
649
static const char* const html_content[] = { "head", "body", "frameset", NULL } ;
650
static const char* const iframe_attrs[] = { COREATTRS, "longdesc", "name", "src", "frameborder", "marginwidth", "marginheight", "scrolling", "align", "height", "width", NULL } ;
651
static const char* const img_attrs[] = { ATTRS, "longdesc", "name", "height", "width", "usemap", "ismap", NULL } ;
652
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 } ;
653
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 } ;
654
static const char* const prompt_attrs[] = { COREATTRS, I18N, "prompt", NULL } ;
655
static const char* const label_attrs[] = { ATTRS, "for", "accesskey", "onfocus", "onblur", NULL } ;
656
static const char* const legend_attrs[] = { ATTRS, "accesskey", NULL } ;
657
static const char* const align_attr[] = { "align", NULL } ;
658
static const char* const link_attrs[] = { ATTRS, "charset", "href", "hreflang", "type", "rel", "rev", "media", NULL } ;
659
static const char* const map_contents[] = { BLOCK, "area", NULL } ;
660
static const char* const name_attr[] = { "name", NULL } ;
661
static const char* const action_attr[] = { "action", NULL } ;
662
static const char* const blockli_elt[] = { BLOCK, "li", NULL } ;
663
static const char* const meta_attrs[] = { I18N, "http-equiv", "name", "scheme", "charset", NULL } ;
664
static const char* const content_attr[] = { "content", NULL } ;
665
static const char* const type_attr[] = { "type", NULL } ;
666
static const char* const noframes_content[] = { "body", FLOW MODIFIER, NULL } ;
667
static const char* const object_contents[] = { FLOW, "param", NULL } ;
668
static const char* const object_attrs[] = { ATTRS, "declare", "classid", "codebase", "data", "type", "codetype", "archive", "standby", "height", "width", "usemap", "name", "tabindex", NULL } ;
669
static const char* const object_depr[] = { "align", "border", "hspace", "vspace", NULL } ;
670
static const char* const ol_attrs[] = { "type", "compact", "start", NULL} ;
671
static const char* const option_elt[] = { "option", NULL } ;
672
static const char* const optgroup_attrs[] = { ATTRS, "disabled", NULL } ;
673
static const char* const option_attrs[] = { ATTRS, "disabled", "label", "selected", "value", NULL } ;
674
static const char* const param_attrs[] = { "id", "value", "valuetype", "type", NULL } ;
675
static const char* const width_attr[] = { "width", NULL } ;
676
static const char* const pre_content[] = { PHRASE, "tt", "i", "b", "u", "s", "strike", "a", "br", "script", "map", "q", "span", "bdo", "iframe", NULL } ;
677
static const char* const script_attrs[] = { "charset", "src", "defer", "event", "for", NULL } ;
678
static const char* const language_attr[] = { "language", NULL } ;
679
static const char* const select_content[] = { "optgroup", "option", NULL } ;
680
static const char* const select_attrs[] = { ATTRS, "name", "size", "multiple", "disabled", "tabindex", "onfocus", "onblur", "onchange", NULL } ;
681
static const char* const style_attrs[] = { I18N, "media", "title", NULL } ;
682
static const char* const table_attrs[] = { ATTRS, "summary", "width", "border", "frame", "rules", "cellspacing", "cellpadding", "datapagesize", NULL } ;
683
static const char* const table_depr[] = { "align", "bgcolor", NULL } ;
684
static const char* const table_contents[] = { "caption", "col", "colgroup", "thead", "tfoot", "tbody", "tr", NULL} ;
685
static const char* const tr_elt[] = { "tr", NULL } ;
686
static const char* const talign_attrs[] = { ATTRS, CELLHALIGN, CELLVALIGN, NULL} ;
687
static const char* const th_td_depr[] = { "nowrap", "bgcolor", "width", "height", NULL } ;
688
static const char* const th_td_attr[] = { ATTRS, "abbr", "axis", "headers", "scope", "rowspan", "colspan", CELLHALIGN, CELLVALIGN, NULL } ;
689
static const char* const textarea_attrs[] = { ATTRS, "name", "disabled", "readonly", "tabindex", "accesskey", "onfocus", "onblur", "onselect", "onchange", NULL } ;
690
static const char* const tr_contents[] = { "th", "td", NULL } ;
691
static const char* const bgcolor_attr[] = { "bgcolor", NULL } ;
692
static const char* const li_elt[] = { "li", NULL } ;
693
static const char* const ul_depr[] = { "type", "compact", NULL} ;
694
static const char* const dir_attr[] = { "dir", NULL} ;
695
696
#define DECL (const char**)
697
698
static const htmlElemDesc
699
html40ElementTable[] = {
700
{ "a",    0, 0, 0, 0, 0, 0, 1, "anchor ",
701
  DECL html_inline , NULL , DECL a_attrs , DECL target_attr, NULL
702
},
703
{ "abbr", 0, 0, 0, 0, 0, 0, 1, "abbreviated form",
704
  DECL html_inline , NULL , DECL html_attrs, NULL, NULL
705
},
706
{ "acronym",  0, 0, 0, 0, 0, 0, 1, "",
707
  DECL html_inline , NULL , DECL html_attrs, NULL, NULL
708
},
709
{ "address",  0, 0, 0, 0, 0, 0, 0, "information on author ",
710
  DECL inline_p  , NULL , DECL html_attrs, NULL, NULL
711
},
712
{ "applet", 0, 0, 0, 0, 1, 1, 2, "java applet ",
713
  DECL flow_param , NULL , NULL , DECL applet_attrs, NULL
714
},
715
{ "area", 0, 2, 2, 1, 0, 0, 0, "client-side image map area ",
716
  EMPTY ,  NULL , DECL area_attrs , DECL target_attr, DECL alt_attr
717
},
718
{ "b",    0, 3, 0, 0, 0, 0, 1, "bold text style",
719
  DECL html_inline , NULL , DECL html_attrs, NULL, NULL
720
},
721
{ "base", 0, 2, 2, 1, 0, 0, 0, "document base uri ",
722
  EMPTY , NULL , NULL , DECL target_attr, DECL href_attrs
723
},
724
{ "basefont", 0, 2, 2, 1, 1, 1, 1, "base font size " ,
725
  EMPTY , NULL , NULL, DECL basefont_attrs, NULL
726
},
727
{ "bdo",  0, 0, 0, 0, 0, 0, 1, "i18n bidi over-ride ",
728
  DECL html_inline , NULL , DECL core_i18n_attrs, NULL, DECL dir_attr
729
},
730
{ "big",  0, 3, 0, 0, 0, 0, 1, "large text style",
731
  DECL html_inline , NULL , DECL html_attrs, NULL, NULL
732
},
733
{ "blockquote", 0, 0, 0, 0, 0, 0, 0, "long quotation ",
734
  DECL html_flow , NULL , DECL quote_attrs , NULL, NULL
735
},
736
{ "body", 1, 1, 0, 0, 0, 0, 0, "document body ",
737
  DECL body_contents , "div" , DECL body_attrs, DECL body_depr, NULL
738
},
739
{ "br",   0, 2, 2, 1, 0, 0, 1, "forced line break ",
740
  EMPTY , NULL , DECL core_attrs, DECL clear_attrs , NULL
741
},
742
{ "button", 0, 0, 0, 0, 0, 0, 2, "push button ",
743
  DECL html_flow MODIFIER , NULL , DECL button_attrs, NULL, NULL
744
},
745
{ "caption",  0, 0, 0, 0, 0, 0, 0, "table caption ",
746
  DECL html_inline , NULL , DECL html_attrs, NULL, NULL
747
},
748
{ "center", 0, 3, 0, 0, 1, 1, 0, "shorthand for div align=center ",
749
  DECL html_flow , NULL , NULL, DECL html_attrs, NULL
750
},
751
{ "cite", 0, 0, 0, 0, 0, 0, 1, "citation",
752
  DECL html_inline , NULL , DECL html_attrs, NULL, NULL
753
},
754
{ "code", 0, 0, 0, 0, 0, 0, 1, "computer code fragment",
755
  DECL html_inline , NULL , DECL html_attrs, NULL, NULL
756
},
757
{ "col",  0, 2, 2, 1, 0, 0, 0, "table column ",
758
  EMPTY , NULL , DECL col_attrs , NULL, NULL
759
},
760
{ "colgroup", 0, 1, 0, 0, 0, 0, 0, "table column group ",
761
  DECL col_elt , "col" , DECL col_attrs , NULL, NULL
762
},
763
{ "dd",   0, 1, 0, 0, 0, 0, 0, "definition description ",
764
  DECL html_flow , NULL , DECL html_attrs, NULL, NULL
765
},
766
{ "del",  0, 0, 0, 0, 0, 0, 2, "deleted text ",
767
  DECL html_flow , NULL , DECL edit_attrs , NULL, NULL
768
},
769
{ "dfn",  0, 0, 0, 0, 0, 0, 1, "instance definition",
770
  DECL html_inline , NULL , DECL html_attrs, NULL, NULL
771
},
772
{ "dir",  0, 0, 0, 0, 1, 1, 0, "directory list",
773
  DECL blockli_elt, "li" , NULL, DECL compact_attrs, NULL
774
},
775
{ "div",  0, 0, 0, 0, 0, 0, 0, "generic language/style container",
776
  DECL html_flow, NULL, DECL html_attrs, DECL align_attr, NULL
777
},
778
{ "dl",   0, 0, 0, 0, 0, 0, 0, "definition list ",
779
  DECL dl_contents , "dd" , DECL html_attrs, DECL compact_attr, NULL
780
},
781
{ "dt",   0, 1, 0, 0, 0, 0, 0, "definition term ",
782
  DECL html_inline, NULL, DECL html_attrs, NULL, NULL
783
},
784
{ "em",   0, 3, 0, 0, 0, 0, 1, "emphasis",
785
  DECL html_inline, NULL, DECL html_attrs, NULL, NULL
786
},
787
{ "embed",  0, 1, 0, 0, 1, 1, 1, "generic embedded object ",
788
  EMPTY, NULL, DECL embed_attrs, NULL, NULL
789
},
790
{ "fieldset", 0, 0, 0, 0, 0, 0, 0, "form control group ",
791
  DECL fieldset_contents , NULL, DECL html_attrs, NULL, NULL
792
},
793
{ "font", 0, 3, 0, 0, 1, 1, 1, "local change to font ",
794
  DECL html_inline, NULL, NULL, DECL font_attrs, NULL
795
},
796
{ "form", 0, 0, 0, 0, 0, 0, 0, "interactive form ",
797
  DECL form_contents, "fieldset", DECL form_attrs , DECL target_attr, DECL action_attr
798
},
799
{ "frame",  0, 2, 2, 1, 0, 2, 0, "subwindow " ,
800
  EMPTY, NULL, NULL, DECL frame_attrs, NULL
801
},
802
{ "frameset", 0, 0, 0, 0, 0, 2, 0, "window subdivision" ,
803
  DECL frameset_contents, "noframes" , NULL , DECL frameset_attrs, NULL
804
},
805
{ "h1",   0, 0, 0, 0, 0, 0, 0, "heading ",
806
  DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
807
},
808
{ "h2",   0, 0, 0, 0, 0, 0, 0, "heading ",
809
  DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
810
},
811
{ "h3",   0, 0, 0, 0, 0, 0, 0, "heading ",
812
  DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
813
},
814
{ "h4",   0, 0, 0, 0, 0, 0, 0, "heading ",
815
  DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
816
},
817
{ "h5",   0, 0, 0, 0, 0, 0, 0, "heading ",
818
  DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
819
},
820
{ "h6",   0, 0, 0, 0, 0, 0, 0, "heading ",
821
  DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
822
},
823
{ "head", 1, 1, 0, 0, 0, 0, 0, "document head ",
824
  DECL head_contents, NULL, DECL head_attrs, NULL, NULL
825
},
826
{ "hr",   0, 2, 2, 1, 0, 0, 0, "horizontal rule " ,
827
  EMPTY, NULL, DECL html_attrs, DECL hr_depr, NULL
828
},
829
{ "html", 1, 1, 0, 0, 0, 0, 0, "document root element ",
830
  DECL html_content , NULL , DECL i18n_attrs, DECL version_attr, NULL
831
},
832
{ "i",    0, 3, 0, 0, 0, 0, 1, "italic text style",
833
  DECL html_inline, NULL, DECL html_attrs, NULL, NULL
834
},
835
{ "iframe", 0, 0, 0, 0, 0, 1, 2, "inline subwindow ",
836
  DECL html_flow, NULL, NULL, DECL iframe_attrs, NULL
837
},
838
{ "img",  0, 2, 2, 1, 0, 0, 1, "embedded image ",
839
  EMPTY, NULL, DECL img_attrs, DECL align_attr, DECL src_alt_attrs
840
},
841
{ "input",  0, 2, 2, 1, 0, 0, 1, "form control ",
842
  EMPTY, NULL, DECL input_attrs , DECL align_attr, NULL
843
},
844
{ "ins",  0, 0, 0, 0, 0, 0, 2, "inserted text",
845
  DECL html_flow, NULL, DECL edit_attrs, NULL, NULL
846
},
847
{ "isindex",  0, 2, 2, 1, 1, 1, 0, "single line prompt ",
848
  EMPTY, NULL, NULL, DECL prompt_attrs, NULL
849
},
850
{ "kbd",  0, 0, 0, 0, 0, 0, 1, "text to be entered by the user",
851
  DECL html_inline, NULL, DECL html_attrs, NULL, NULL
852
},
853
{ "label",  0, 0, 0, 0, 0, 0, 1, "form field label text ",
854
  DECL html_inline MODIFIER, NULL, DECL label_attrs , NULL, NULL
855
},
856
{ "legend", 0, 0, 0, 0, 0, 0, 0, "fieldset legend ",
857
  DECL html_inline, NULL, DECL legend_attrs , DECL align_attr, NULL
858
},
859
{ "li",   0, 1, 1, 0, 0, 0, 0, "list item ",
860
  DECL html_flow, NULL, DECL html_attrs, NULL, NULL
861
},
862
{ "link", 0, 2, 2, 1, 0, 0, 0, "a media-independent link ",
863
  EMPTY, NULL, DECL link_attrs, DECL target_attr, NULL
864
},
865
{ "map",  0, 0, 0, 0, 0, 0, 2, "client-side image map ",
866
  DECL map_contents , NULL, DECL html_attrs , NULL, DECL name_attr
867
},
868
{ "menu", 0, 0, 0, 0, 1, 1, 0, "menu list ",
869
  DECL blockli_elt , NULL, NULL, DECL compact_attrs, NULL
870
},
871
{ "meta", 0, 2, 2, 1, 0, 0, 0, "generic metainformation ",
872
  EMPTY, NULL, DECL meta_attrs , NULL , DECL content_attr
873
},
874
{ "noframes", 0, 0, 0, 0, 0, 2, 0, "alternate content container for non frame-based rendering ",
875
  DECL noframes_content, "body" , DECL html_attrs, NULL, NULL
876
},
877
{ "noscript", 0, 0, 0, 0, 0, 0, 0, "alternate content container for non script-based rendering ",
878
  DECL html_flow, "div", DECL html_attrs, NULL, NULL
879
},
880
{ "object", 0, 0, 0, 0, 0, 0, 2, "generic embedded object ",
881
  DECL object_contents , "div" , DECL object_attrs, DECL object_depr, NULL
882
},
883
{ "ol",   0, 0, 0, 0, 0, 0, 0, "ordered list ",
884
  DECL li_elt , "li" , DECL html_attrs, DECL ol_attrs, NULL
885
},
886
{ "optgroup", 0, 0, 0, 0, 0, 0, 0, "option group ",
887
  DECL option_elt , "option", DECL optgroup_attrs, NULL, DECL label_attr
888
},
889
{ "option", 0, 1, 0, 0, 0, 0, 0, "selectable choice " ,
890
  DECL html_pcdata, NULL, DECL option_attrs, NULL, NULL
891
},
892
{ "p",    0, 1, 0, 0, 0, 0, 0, "paragraph ",
893
  DECL html_inline, NULL, DECL html_attrs, DECL align_attr, NULL
894
},
895
{ "param",  0, 2, 2, 1, 0, 0, 0, "named property value ",
896
  EMPTY, NULL, DECL param_attrs, NULL, DECL name_attr
897
},
898
{ "pre",  0, 0, 0, 0, 0, 0, 0, "preformatted text ",
899
  DECL pre_content, NULL, DECL html_attrs, DECL width_attr, NULL
900
},
901
{ "q",    0, 0, 0, 0, 0, 0, 1, "short inline quotation ",
902
  DECL html_inline, NULL, DECL quote_attrs, NULL, NULL
903
},
904
{ "s",    0, 3, 0, 0, 1, 1, 1, "strike-through text style",
905
  DECL html_inline, NULL, NULL, DECL html_attrs, NULL
906
},
907
{ "samp", 0, 0, 0, 0, 0, 0, 1, "sample program output, scripts, etc.",
908
  DECL html_inline, NULL, DECL html_attrs, NULL, NULL
909
},
910
{ "script", 0, 0, 0, 0, 0, 0, 2, "script statements ",
911
  DECL html_cdata, NULL, DECL script_attrs, DECL language_attr, DECL type_attr
912
},
913
{ "select", 0, 0, 0, 0, 0, 0, 1, "option selector ",
914
  DECL select_content, NULL, DECL select_attrs, NULL, NULL
915
},
916
{ "small",  0, 3, 0, 0, 0, 0, 1, "small text style",
917
  DECL html_inline, NULL, DECL html_attrs, NULL, NULL
918
},
919
{ "span", 0, 0, 0, 0, 0, 0, 1, "generic language/style container ",
920
  DECL html_inline, NULL, DECL html_attrs, NULL, NULL
921
},
922
{ "strike", 0, 3, 0, 0, 1, 1, 1, "strike-through text",
923
  DECL html_inline, NULL, NULL, DECL html_attrs, NULL
924
},
925
{ "strong", 0, 3, 0, 0, 0, 0, 1, "strong emphasis",
926
  DECL html_inline, NULL, DECL html_attrs, NULL, NULL
927
},
928
{ "style",  0, 0, 0, 0, 0, 0, 0, "style info ",
929
  DECL html_cdata, NULL, DECL style_attrs, NULL, DECL type_attr
930
},
931
{ "sub",  0, 3, 0, 0, 0, 0, 1, "subscript",
932
  DECL html_inline, NULL, DECL html_attrs, NULL, NULL
933
},
934
{ "sup",  0, 3, 0, 0, 0, 0, 1, "superscript ",
935
  DECL html_inline, NULL, DECL html_attrs, NULL, NULL
936
},
937
{ "table",  0, 0, 0, 0, 0, 0, 0, "",
938
  DECL table_contents , "tr" , DECL table_attrs , DECL table_depr, NULL
939
},
940
{ "tbody",  1, 0, 0, 0, 0, 0, 0, "table body ",
941
  DECL tr_elt , "tr" , DECL talign_attrs, NULL, NULL
942
},
943
{ "td",   0, 0, 0, 0, 0, 0, 0, "table data cell",
944
  DECL html_flow, NULL, DECL th_td_attr, DECL th_td_depr, NULL
945
},
946
{ "textarea", 0, 0, 0, 0, 0, 0, 1, "multi-line text field ",
947
  DECL html_pcdata, NULL, DECL textarea_attrs, NULL, DECL rows_cols_attr
948
},
949
{ "tfoot",  0, 1, 0, 0, 0, 0, 0, "table footer ",
950
  DECL tr_elt , "tr" , DECL talign_attrs, NULL, NULL
951
},
952
{ "th",   0, 1, 0, 0, 0, 0, 0, "table header cell",
953
  DECL html_flow, NULL, DECL th_td_attr, DECL th_td_depr, NULL
954
},
955
{ "thead",  0, 1, 0, 0, 0, 0, 0, "table header ",
956
  DECL tr_elt , "tr" , DECL talign_attrs, NULL, NULL
957
},
958
{ "title",  0, 0, 0, 0, 0, 0, 0, "document title ",
959
  DECL html_pcdata, NULL, DECL i18n_attrs, NULL, NULL
960
},
961
{ "tr",   0, 0, 0, 0, 0, 0, 0, "table row ",
962
  DECL tr_contents , "td" , DECL talign_attrs, DECL bgcolor_attr, NULL
963
},
964
{ "tt",   0, 3, 0, 0, 0, 0, 1, "teletype or monospaced text style",
965
  DECL html_inline, NULL, DECL html_attrs, NULL, NULL
966
},
967
{ "u",    0, 3, 0, 0, 1, 1, 1, "underlined text style",
968
  DECL html_inline, NULL, NULL, DECL html_attrs, NULL
969
},
970
{ "ul",   0, 0, 0, 0, 0, 0, 0, "unordered list ",
971
  DECL li_elt , "li" , DECL html_attrs, DECL ul_depr, NULL
972
},
973
{ "var",  0, 0, 0, 0, 0, 0, 1, "instance of a variable or program argument",
974
  DECL html_inline, NULL, DECL html_attrs, NULL, NULL
975
}
976
};
977
978
typedef struct {
979
    const char *oldTag;
980
    const char *newTag;
981
} htmlStartCloseEntry;
982
983
/*
984
 * start tags that imply the end of current element
985
 */
986
static const htmlStartCloseEntry htmlStartClose[] = {
987
    { "a", "a" },
988
    { "a", "fieldset" },
989
    { "a", "table" },
990
    { "a", "td" },
991
    { "a", "th" },
992
    { "address", "dd" },
993
    { "address", "dl" },
994
    { "address", "dt" },
995
    { "address", "form" },
996
    { "address", "li" },
997
    { "address", "ul" },
998
    { "b", "center" },
999
    { "b", "p" },
1000
    { "b", "td" },
1001
    { "b", "th" },
1002
    { "big", "p" },
1003
    { "caption", "col" },
1004
    { "caption", "colgroup" },
1005
    { "caption", "tbody" },
1006
    { "caption", "tfoot" },
1007
    { "caption", "thead" },
1008
    { "caption", "tr" },
1009
    { "col", "col" },
1010
    { "col", "colgroup" },
1011
    { "col", "tbody" },
1012
    { "col", "tfoot" },
1013
    { "col", "thead" },
1014
    { "col", "tr" },
1015
    { "colgroup", "colgroup" },
1016
    { "colgroup", "tbody" },
1017
    { "colgroup", "tfoot" },
1018
    { "colgroup", "thead" },
1019
    { "colgroup", "tr" },
1020
    { "dd", "dt" },
1021
    { "dir", "dd" },
1022
    { "dir", "dl" },
1023
    { "dir", "dt" },
1024
    { "dir", "form" },
1025
    { "dir", "ul" },
1026
    { "dl", "form" },
1027
    { "dl", "li" },
1028
    { "dt", "dd" },
1029
    { "dt", "dl" },
1030
    { "font", "center" },
1031
    { "font", "td" },
1032
    { "font", "th" },
1033
    { "form", "form" },
1034
    { "h1", "fieldset" },
1035
    { "h1", "form" },
1036
    { "h1", "li" },
1037
    { "h1", "p" },
1038
    { "h1", "table" },
1039
    { "h2", "fieldset" },
1040
    { "h2", "form" },
1041
    { "h2", "li" },
1042
    { "h2", "p" },
1043
    { "h2", "table" },
1044
    { "h3", "fieldset" },
1045
    { "h3", "form" },
1046
    { "h3", "li" },
1047
    { "h3", "p" },
1048
    { "h3", "table" },
1049
    { "h4", "fieldset" },
1050
    { "h4", "form" },
1051
    { "h4", "li" },
1052
    { "h4", "p" },
1053
    { "h4", "table" },
1054
    { "h5", "fieldset" },
1055
    { "h5", "form" },
1056
    { "h5", "li" },
1057
    { "h5", "p" },
1058
    { "h5", "table" },
1059
    { "h6", "fieldset" },
1060
    { "h6", "form" },
1061
    { "h6", "li" },
1062
    { "h6", "p" },
1063
    { "h6", "table" },
1064
    { "head", "a" },
1065
    { "head", "abbr" },
1066
    { "head", "acronym" },
1067
    { "head", "address" },
1068
    { "head", "b" },
1069
    { "head", "bdo" },
1070
    { "head", "big" },
1071
    { "head", "blockquote" },
1072
    { "head", "body" },
1073
    { "head", "br" },
1074
    { "head", "center" },
1075
    { "head", "cite" },
1076
    { "head", "code" },
1077
    { "head", "dd" },
1078
    { "head", "dfn" },
1079
    { "head", "dir" },
1080
    { "head", "div" },
1081
    { "head", "dl" },
1082
    { "head", "dt" },
1083
    { "head", "em" },
1084
    { "head", "fieldset" },
1085
    { "head", "font" },
1086
    { "head", "form" },
1087
    { "head", "frameset" },
1088
    { "head", "h1" },
1089
    { "head", "h2" },
1090
    { "head", "h3" },
1091
    { "head", "h4" },
1092
    { "head", "h5" },
1093
    { "head", "h6" },
1094
    { "head", "hr" },
1095
    { "head", "i" },
1096
    { "head", "iframe" },
1097
    { "head", "img" },
1098
    { "head", "kbd" },
1099
    { "head", "li" },
1100
    { "head", "listing" },
1101
    { "head", "map" },
1102
    { "head", "menu" },
1103
    { "head", "ol" },
1104
    { "head", "p" },
1105
    { "head", "pre" },
1106
    { "head", "q" },
1107
    { "head", "s" },
1108
    { "head", "samp" },
1109
    { "head", "small" },
1110
    { "head", "span" },
1111
    { "head", "strike" },
1112
    { "head", "strong" },
1113
    { "head", "sub" },
1114
    { "head", "sup" },
1115
    { "head", "table" },
1116
    { "head", "tt" },
1117
    { "head", "u" },
1118
    { "head", "ul" },
1119
    { "head", "var" },
1120
    { "head", "xmp" },
1121
    { "hr", "form" },
1122
    { "i", "center" },
1123
    { "i", "p" },
1124
    { "i", "td" },
1125
    { "i", "th" },
1126
    { "legend", "fieldset" },
1127
    { "li", "li" },
1128
    { "link", "body" },
1129
    { "link", "frameset" },
1130
    { "listing", "dd" },
1131
    { "listing", "dl" },
1132
    { "listing", "dt" },
1133
    { "listing", "fieldset" },
1134
    { "listing", "form" },
1135
    { "listing", "li" },
1136
    { "listing", "table" },
1137
    { "listing", "ul" },
1138
    { "menu", "dd" },
1139
    { "menu", "dl" },
1140
    { "menu", "dt" },
1141
    { "menu", "form" },
1142
    { "menu", "ul" },
1143
    { "ol", "form" },
1144
    { "option", "optgroup" },
1145
    { "option", "option" },
1146
    { "p", "address" },
1147
    { "p", "blockquote" },
1148
    { "p", "body" },
1149
    { "p", "caption" },
1150
    { "p", "center" },
1151
    { "p", "col" },
1152
    { "p", "colgroup" },
1153
    { "p", "dd" },
1154
    { "p", "dir" },
1155
    { "p", "div" },
1156
    { "p", "dl" },
1157
    { "p", "dt" },
1158
    { "p", "fieldset" },
1159
    { "p", "form" },
1160
    { "p", "frameset" },
1161
    { "p", "h1" },
1162
    { "p", "h2" },
1163
    { "p", "h3" },
1164
    { "p", "h4" },
1165
    { "p", "h5" },
1166
    { "p", "h6" },
1167
    { "p", "head" },
1168
    { "p", "hr" },
1169
    { "p", "li" },
1170
    { "p", "listing" },
1171
    { "p", "menu" },
1172
    { "p", "ol" },
1173
    { "p", "p" },
1174
    { "p", "pre" },
1175
    { "p", "table" },
1176
    { "p", "tbody" },
1177
    { "p", "td" },
1178
    { "p", "tfoot" },
1179
    { "p", "th" },
1180
    { "p", "title" },
1181
    { "p", "tr" },
1182
    { "p", "ul" },
1183
    { "p", "xmp" },
1184
    { "pre", "dd" },
1185
    { "pre", "dl" },
1186
    { "pre", "dt" },
1187
    { "pre", "fieldset" },
1188
    { "pre", "form" },
1189
    { "pre", "li" },
1190
    { "pre", "table" },
1191
    { "pre", "ul" },
1192
    { "s", "p" },
1193
    { "script", "noscript" },
1194
    { "small", "p" },
1195
    { "span", "td" },
1196
    { "span", "th" },
1197
    { "strike", "p" },
1198
    { "style", "body" },
1199
    { "style", "frameset" },
1200
    { "tbody", "tbody" },
1201
    { "tbody", "tfoot" },
1202
    { "td", "tbody" },
1203
    { "td", "td" },
1204
    { "td", "tfoot" },
1205
    { "td", "th" },
1206
    { "td", "tr" },
1207
    { "tfoot", "tbody" },
1208
    { "th", "tbody" },
1209
    { "th", "td" },
1210
    { "th", "tfoot" },
1211
    { "th", "th" },
1212
    { "th", "tr" },
1213
    { "thead", "tbody" },
1214
    { "thead", "tfoot" },
1215
    { "title", "body" },
1216
    { "title", "frameset" },
1217
    { "tr", "tbody" },
1218
    { "tr", "tfoot" },
1219
    { "tr", "tr" },
1220
    { "tt", "p" },
1221
    { "u", "p" },
1222
    { "u", "td" },
1223
    { "u", "th" },
1224
    { "ul", "address" },
1225
    { "ul", "form" },
1226
    { "ul", "menu" },
1227
    { "ul", "pre" },
1228
    { "xmp", "dd" },
1229
    { "xmp", "dl" },
1230
    { "xmp", "dt" },
1231
    { "xmp", "fieldset" },
1232
    { "xmp", "form" },
1233
    { "xmp", "li" },
1234
    { "xmp", "table" },
1235
    { "xmp", "ul" }
1236
};
1237
1238
/*
1239
 * The list of HTML elements which are supposed not to have
1240
 * CDATA content and where a p element will be implied
1241
 *
1242
 * TODO: extend that list by reading the HTML SGML DTD on
1243
 *       implied paragraph
1244
 */
1245
static const char *const htmlNoContentElements[] = {
1246
    "html",
1247
    "head",
1248
    NULL
1249
};
1250
1251
/*
1252
 * The list of HTML attributes which are of content %Script;
1253
 * NOTE: when adding ones, check htmlIsScriptAttribute() since
1254
 *       it assumes the name starts with 'on'
1255
 */
1256
static const char *const htmlScriptAttributes[] = {
1257
    "onclick",
1258
    "ondblclick",
1259
    "onmousedown",
1260
    "onmouseup",
1261
    "onmouseover",
1262
    "onmousemove",
1263
    "onmouseout",
1264
    "onkeypress",
1265
    "onkeydown",
1266
    "onkeyup",
1267
    "onload",
1268
    "onunload",
1269
    "onfocus",
1270
    "onblur",
1271
    "onsubmit",
1272
    "onreset",
1273
    "onchange",
1274
    "onselect"
1275
};
1276
1277
/*
1278
 * This table is used by the htmlparser to know what to do with
1279
 * broken html pages. By assigning different priorities to different
1280
 * elements the parser can decide how to handle extra endtags.
1281
 * Endtags are only allowed to close elements with lower or equal
1282
 * priority.
1283
 */
1284
1285
typedef struct {
1286
    const char *name;
1287
    int priority;
1288
} elementPriority;
1289
1290
static const elementPriority htmlEndPriority[] = {
1291
    {"div",   150},
1292
    {"td",    160},
1293
    {"th",    160},
1294
    {"tr",    170},
1295
    {"thead", 180},
1296
    {"tbody", 180},
1297
    {"tfoot", 180},
1298
    {"table", 190},
1299
    {"head",  200},
1300
    {"body",  200},
1301
    {"html",  220},
1302
    {NULL,    100} /* Default priority */
1303
};
1304
1305
/************************************************************************
1306
 *                  *
1307
 *  functions to handle HTML specific data      *
1308
 *                  *
1309
 ************************************************************************/
1310
1311
/**
1312
 * htmlInitAutoClose:
1313
 *
1314
 * DEPRECATED: This is a no-op.
1315
 */
1316
void
1317
0
htmlInitAutoClose(void) {
1318
0
}
1319
1320
static int
1321
12.0M
htmlCompareTags(const void *key, const void *member) {
1322
12.0M
    const xmlChar *tag = (const xmlChar *) key;
1323
12.0M
    const htmlElemDesc *desc = (const htmlElemDesc *) member;
1324
1325
12.0M
    return(xmlStrcasecmp(tag, BAD_CAST desc->name));
1326
12.0M
}
1327
1328
/**
1329
 * htmlTagLookup:
1330
 * @tag:  The tag name in lowercase
1331
 *
1332
 * Lookup the HTML tag in the ElementTable
1333
 *
1334
 * Returns the related htmlElemDescPtr or NULL if not found.
1335
 */
1336
const htmlElemDesc *
1337
1.73M
htmlTagLookup(const xmlChar *tag) {
1338
1.73M
    if (tag == NULL)
1339
0
        return(NULL);
1340
1341
1.73M
    return((const htmlElemDesc *) bsearch(tag, html40ElementTable,
1342
1.73M
                sizeof(html40ElementTable) / sizeof(htmlElemDesc),
1343
1.73M
                sizeof(htmlElemDesc), htmlCompareTags));
1344
1.73M
}
1345
1346
/**
1347
 * htmlGetEndPriority:
1348
 * @name: The name of the element to look up the priority for.
1349
 *
1350
 * Return value: The "endtag" priority.
1351
 **/
1352
static int
1353
0
htmlGetEndPriority (const xmlChar *name) {
1354
0
    int i = 0;
1355
1356
0
    while ((htmlEndPriority[i].name != NULL) &&
1357
0
     (!xmlStrEqual((const xmlChar *)htmlEndPriority[i].name, name)))
1358
0
  i++;
1359
1360
0
    return(htmlEndPriority[i].priority);
1361
0
}
1362
1363
1364
static int
1365
0
htmlCompareStartClose(const void *vkey, const void *member) {
1366
0
    const htmlStartCloseEntry *key = (const htmlStartCloseEntry *) vkey;
1367
0
    const htmlStartCloseEntry *entry = (const htmlStartCloseEntry *) member;
1368
0
    int ret;
1369
1370
0
    ret = strcmp(key->oldTag, entry->oldTag);
1371
0
    if (ret == 0)
1372
0
        ret = strcmp(key->newTag, entry->newTag);
1373
1374
0
    return(ret);
1375
0
}
1376
1377
/**
1378
 * htmlCheckAutoClose:
1379
 * @newtag:  The new tag name
1380
 * @oldtag:  The old tag name
1381
 *
1382
 * Checks whether the new tag is one of the registered valid tags for
1383
 * closing old.
1384
 *
1385
 * Returns 0 if no, 1 if yes.
1386
 */
1387
static int
1388
htmlCheckAutoClose(const xmlChar * newtag, const xmlChar * oldtag)
1389
0
{
1390
0
    htmlStartCloseEntry key;
1391
0
    void *res;
1392
1393
0
    key.oldTag = (const char *) oldtag;
1394
0
    key.newTag = (const char *) newtag;
1395
0
    res = bsearch(&key, htmlStartClose,
1396
0
            sizeof(htmlStartClose) / sizeof(htmlStartCloseEntry),
1397
0
            sizeof(htmlStartCloseEntry), htmlCompareStartClose);
1398
0
    return(res != NULL);
1399
0
}
1400
1401
/**
1402
 * htmlAutoCloseOnClose:
1403
 * @ctxt:  an HTML parser context
1404
 * @newtag:  The new tag name
1405
 * @force:  force the tag closure
1406
 *
1407
 * The HTML DTD allows an ending tag to implicitly close other tags.
1408
 */
1409
static void
1410
htmlAutoCloseOnClose(htmlParserCtxtPtr ctxt, const xmlChar * newtag)
1411
0
{
1412
0
    const htmlElemDesc *info;
1413
0
    int i, priority;
1414
1415
0
    priority = htmlGetEndPriority(newtag);
1416
1417
0
    for (i = (ctxt->nameNr - 1); i >= 0; i--) {
1418
1419
0
        if (xmlStrEqual(newtag, ctxt->nameTab[i]))
1420
0
            break;
1421
        /*
1422
         * A misplaced endtag can only close elements with lower
1423
         * or equal priority, so if we find an element with higher
1424
         * priority before we find an element with
1425
         * matching name, we just ignore this endtag
1426
         */
1427
0
        if (htmlGetEndPriority(ctxt->nameTab[i]) > priority)
1428
0
            return;
1429
0
    }
1430
0
    if (i < 0)
1431
0
        return;
1432
1433
0
    while (!xmlStrEqual(newtag, ctxt->name)) {
1434
0
        info = htmlTagLookup(ctxt->name);
1435
0
        if ((info != NULL) && (info->endTag == 3)) {
1436
0
            htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
1437
0
                   "Opening and ending tag mismatch: %s and %s\n",
1438
0
       newtag, ctxt->name);
1439
0
        }
1440
0
        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
1441
0
            ctxt->sax->endElement(ctxt->userData, ctxt->name);
1442
0
  htmlnamePop(ctxt);
1443
0
    }
1444
0
}
1445
1446
/**
1447
 * htmlAutoCloseOnEnd:
1448
 * @ctxt:  an HTML parser context
1449
 *
1450
 * Close all remaining tags at the end of the stream
1451
 */
1452
static void
1453
htmlAutoCloseOnEnd(htmlParserCtxtPtr ctxt)
1454
0
{
1455
0
    int i;
1456
1457
0
    if (ctxt->nameNr == 0)
1458
0
        return;
1459
0
    for (i = (ctxt->nameNr - 1); i >= 0; i--) {
1460
0
        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
1461
0
            ctxt->sax->endElement(ctxt->userData, ctxt->name);
1462
0
  htmlnamePop(ctxt);
1463
0
    }
1464
0
}
1465
1466
/**
1467
 * htmlAutoClose:
1468
 * @ctxt:  an HTML parser context
1469
 * @newtag:  The new tag name or NULL
1470
 *
1471
 * The HTML DTD allows a tag to implicitly close other tags.
1472
 * The list is kept in htmlStartClose array. This function is
1473
 * called when a new tag has been detected and generates the
1474
 * appropriates closes if possible/needed.
1475
 * If newtag is NULL this mean we are at the end of the resource
1476
 * and we should check
1477
 */
1478
static void
1479
htmlAutoClose(htmlParserCtxtPtr ctxt, const xmlChar * newtag)
1480
0
{
1481
0
    if (newtag == NULL)
1482
0
        return;
1483
1484
0
    while ((ctxt->name != NULL) &&
1485
0
           (htmlCheckAutoClose(newtag, ctxt->name))) {
1486
0
        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
1487
0
            ctxt->sax->endElement(ctxt->userData, ctxt->name);
1488
0
  htmlnamePop(ctxt);
1489
0
    }
1490
0
}
1491
1492
/**
1493
 * htmlAutoCloseTag:
1494
 * @doc:  the HTML document
1495
 * @name:  The tag name
1496
 * @elem:  the HTML element
1497
 *
1498
 * The HTML DTD allows a tag to implicitly close other tags.
1499
 * The list is kept in htmlStartClose array. This function checks
1500
 * if the element or one of it's children would autoclose the
1501
 * given tag.
1502
 *
1503
 * Returns 1 if autoclose, 0 otherwise
1504
 */
1505
int
1506
0
htmlAutoCloseTag(htmlDocPtr doc, const xmlChar *name, htmlNodePtr elem) {
1507
0
    htmlNodePtr child;
1508
1509
0
    if (elem == NULL) return(1);
1510
0
    if (xmlStrEqual(name, elem->name)) return(0);
1511
0
    if (htmlCheckAutoClose(elem->name, name)) return(1);
1512
0
    child = elem->children;
1513
0
    while (child != NULL) {
1514
0
        if (htmlAutoCloseTag(doc, name, child)) return(1);
1515
0
  child = child->next;
1516
0
    }
1517
0
    return(0);
1518
0
}
1519
1520
/**
1521
 * htmlIsAutoClosed:
1522
 * @doc:  the HTML document
1523
 * @elem:  the HTML element
1524
 *
1525
 * The HTML DTD allows a tag to implicitly close other tags.
1526
 * The list is kept in htmlStartClose array. This function checks
1527
 * if a tag is autoclosed by one of it's child
1528
 *
1529
 * Returns 1 if autoclosed, 0 otherwise
1530
 */
1531
int
1532
0
htmlIsAutoClosed(htmlDocPtr doc, htmlNodePtr elem) {
1533
0
    htmlNodePtr child;
1534
1535
0
    if (elem == NULL) return(1);
1536
0
    child = elem->children;
1537
0
    while (child != NULL) {
1538
0
  if (htmlAutoCloseTag(doc, elem->name, child)) return(1);
1539
0
  child = child->next;
1540
0
    }
1541
0
    return(0);
1542
0
}
1543
1544
/**
1545
 * htmlCheckImplied:
1546
 * @ctxt:  an HTML parser context
1547
 * @newtag:  The new tag name
1548
 *
1549
 * The HTML DTD allows a tag to exists only implicitly
1550
 * called when a new tag has been detected and generates the
1551
 * appropriates implicit tags if missing
1552
 */
1553
static void
1554
0
htmlCheckImplied(htmlParserCtxtPtr ctxt, const xmlChar *newtag) {
1555
0
    int i;
1556
1557
0
    if (ctxt->options & HTML_PARSE_NOIMPLIED)
1558
0
        return;
1559
0
    if (!htmlOmittedDefaultValue)
1560
0
  return;
1561
0
    if (xmlStrEqual(newtag, BAD_CAST"html"))
1562
0
  return;
1563
0
    if (ctxt->nameNr <= 0) {
1564
0
  htmlnamePush(ctxt, BAD_CAST"html");
1565
0
  if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
1566
0
      ctxt->sax->startElement(ctxt->userData, BAD_CAST"html", NULL);
1567
0
    }
1568
0
    if ((xmlStrEqual(newtag, BAD_CAST"body")) || (xmlStrEqual(newtag, BAD_CAST"head")))
1569
0
        return;
1570
0
    if ((ctxt->nameNr <= 1) &&
1571
0
        ((xmlStrEqual(newtag, BAD_CAST"script")) ||
1572
0
   (xmlStrEqual(newtag, BAD_CAST"style")) ||
1573
0
   (xmlStrEqual(newtag, BAD_CAST"meta")) ||
1574
0
   (xmlStrEqual(newtag, BAD_CAST"link")) ||
1575
0
   (xmlStrEqual(newtag, BAD_CAST"title")) ||
1576
0
   (xmlStrEqual(newtag, BAD_CAST"base")))) {
1577
0
        if (ctxt->html >= 3) {
1578
            /* we already saw or generated an <head> before */
1579
0
            return;
1580
0
        }
1581
        /*
1582
         * dropped OBJECT ... i you put it first BODY will be
1583
         * assumed !
1584
         */
1585
0
        htmlnamePush(ctxt, BAD_CAST"head");
1586
0
        if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
1587
0
            ctxt->sax->startElement(ctxt->userData, BAD_CAST"head", NULL);
1588
0
    } else if ((!xmlStrEqual(newtag, BAD_CAST"noframes")) &&
1589
0
         (!xmlStrEqual(newtag, BAD_CAST"frame")) &&
1590
0
         (!xmlStrEqual(newtag, BAD_CAST"frameset"))) {
1591
0
        if (ctxt->html >= 10) {
1592
            /* we already saw or generated a <body> before */
1593
0
            return;
1594
0
        }
1595
0
  for (i = 0;i < ctxt->nameNr;i++) {
1596
0
      if (xmlStrEqual(ctxt->nameTab[i], BAD_CAST"body")) {
1597
0
    return;
1598
0
      }
1599
0
      if (xmlStrEqual(ctxt->nameTab[i], BAD_CAST"head")) {
1600
0
    return;
1601
0
      }
1602
0
  }
1603
1604
0
  htmlnamePush(ctxt, BAD_CAST"body");
1605
0
  if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
1606
0
      ctxt->sax->startElement(ctxt->userData, BAD_CAST"body", NULL);
1607
0
    }
1608
0
}
1609
1610
/**
1611
 * htmlCheckParagraph
1612
 * @ctxt:  an HTML parser context
1613
 *
1614
 * Check whether a p element need to be implied before inserting
1615
 * characters in the current element.
1616
 *
1617
 * Returns 1 if a paragraph has been inserted, 0 if not and -1
1618
 *         in case of error.
1619
 */
1620
1621
static int
1622
0
htmlCheckParagraph(htmlParserCtxtPtr ctxt) {
1623
0
    const xmlChar *tag;
1624
0
    int i;
1625
1626
0
    if (ctxt == NULL)
1627
0
  return(-1);
1628
0
    tag = ctxt->name;
1629
0
    if (tag == NULL) {
1630
0
  htmlAutoClose(ctxt, BAD_CAST"p");
1631
0
  htmlCheckImplied(ctxt, BAD_CAST"p");
1632
0
  htmlnamePush(ctxt, BAD_CAST"p");
1633
0
  if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
1634
0
      ctxt->sax->startElement(ctxt->userData, BAD_CAST"p", NULL);
1635
0
  return(1);
1636
0
    }
1637
0
    if (!htmlOmittedDefaultValue)
1638
0
  return(0);
1639
0
    for (i = 0; htmlNoContentElements[i] != NULL; i++) {
1640
0
  if (xmlStrEqual(tag, BAD_CAST htmlNoContentElements[i])) {
1641
0
      htmlAutoClose(ctxt, BAD_CAST"p");
1642
0
      htmlCheckImplied(ctxt, BAD_CAST"p");
1643
0
      htmlnamePush(ctxt, BAD_CAST"p");
1644
0
      if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
1645
0
    ctxt->sax->startElement(ctxt->userData, BAD_CAST"p", NULL);
1646
0
      return(1);
1647
0
  }
1648
0
    }
1649
0
    return(0);
1650
0
}
1651
1652
/**
1653
 * htmlIsScriptAttribute:
1654
 * @name:  an attribute name
1655
 *
1656
 * Check if an attribute is of content type Script
1657
 *
1658
 * Returns 1 is the attribute is a script 0 otherwise
1659
 */
1660
int
1661
0
htmlIsScriptAttribute(const xmlChar *name) {
1662
0
    unsigned int i;
1663
1664
0
    if (name == NULL)
1665
0
      return(0);
1666
    /*
1667
     * all script attributes start with 'on'
1668
     */
1669
0
    if ((name[0] != 'o') || (name[1] != 'n'))
1670
0
      return(0);
1671
0
    for (i = 0;
1672
0
   i < sizeof(htmlScriptAttributes)/sizeof(htmlScriptAttributes[0]);
1673
0
   i++) {
1674
0
  if (xmlStrEqual(name, (const xmlChar *) htmlScriptAttributes[i]))
1675
0
      return(1);
1676
0
    }
1677
0
    return(0);
1678
0
}
1679
1680
/************************************************************************
1681
 *                  *
1682
 *  The list of HTML predefined entities      *
1683
 *                  *
1684
 ************************************************************************/
1685
1686
1687
static const htmlEntityDesc  html40EntitiesTable[] = {
1688
/*
1689
 * the 4 absolute ones, plus apostrophe.
1690
 */
1691
{ 34, "quot", "quotation mark = APL quote, U+0022 ISOnum" },
1692
{ 38, "amp",  "ampersand, U+0026 ISOnum" },
1693
{ 39, "apos", "single quote" },
1694
{ 60, "lt", "less-than sign, U+003C ISOnum" },
1695
{ 62, "gt", "greater-than sign, U+003E ISOnum" },
1696
1697
/*
1698
 * A bunch still in the 128-255 range
1699
 * Replacing them depend really on the charset used.
1700
 */
1701
{ 160,  "nbsp", "no-break space = non-breaking space, U+00A0 ISOnum" },
1702
{ 161,  "iexcl","inverted exclamation mark, U+00A1 ISOnum" },
1703
{ 162,  "cent", "cent sign, U+00A2 ISOnum" },
1704
{ 163,  "pound","pound sign, U+00A3 ISOnum" },
1705
{ 164,  "curren","currency sign, U+00A4 ISOnum" },
1706
{ 165,  "yen",  "yen sign = yuan sign, U+00A5 ISOnum" },
1707
{ 166,  "brvbar","broken bar = broken vertical bar, U+00A6 ISOnum" },
1708
{ 167,  "sect", "section sign, U+00A7 ISOnum" },
1709
{ 168,  "uml",  "diaeresis = spacing diaeresis, U+00A8 ISOdia" },
1710
{ 169,  "copy", "copyright sign, U+00A9 ISOnum" },
1711
{ 170,  "ordf", "feminine ordinal indicator, U+00AA ISOnum" },
1712
{ 171,  "laquo","left-pointing double angle quotation mark = left pointing guillemet, U+00AB ISOnum" },
1713
{ 172,  "not",  "not sign, U+00AC ISOnum" },
1714
{ 173,  "shy",  "soft hyphen = discretionary hyphen, U+00AD ISOnum" },
1715
{ 174,  "reg",  "registered sign = registered trade mark sign, U+00AE ISOnum" },
1716
{ 175,  "macr", "macron = spacing macron = overline = APL overbar, U+00AF ISOdia" },
1717
{ 176,  "deg",  "degree sign, U+00B0 ISOnum" },
1718
{ 177,  "plusmn","plus-minus sign = plus-or-minus sign, U+00B1 ISOnum" },
1719
{ 178,  "sup2", "superscript two = superscript digit two = squared, U+00B2 ISOnum" },
1720
{ 179,  "sup3", "superscript three = superscript digit three = cubed, U+00B3 ISOnum" },
1721
{ 180,  "acute","acute accent = spacing acute, U+00B4 ISOdia" },
1722
{ 181,  "micro","micro sign, U+00B5 ISOnum" },
1723
{ 182,  "para", "pilcrow sign = paragraph sign, U+00B6 ISOnum" },
1724
{ 183,  "middot","middle dot = Georgian comma Greek middle dot, U+00B7 ISOnum" },
1725
{ 184,  "cedil","cedilla = spacing cedilla, U+00B8 ISOdia" },
1726
{ 185,  "sup1", "superscript one = superscript digit one, U+00B9 ISOnum" },
1727
{ 186,  "ordm", "masculine ordinal indicator, U+00BA ISOnum" },
1728
{ 187,  "raquo","right-pointing double angle quotation mark right pointing guillemet, U+00BB ISOnum" },
1729
{ 188,  "frac14","vulgar fraction one quarter = fraction one quarter, U+00BC ISOnum" },
1730
{ 189,  "frac12","vulgar fraction one half = fraction one half, U+00BD ISOnum" },
1731
{ 190,  "frac34","vulgar fraction three quarters = fraction three quarters, U+00BE ISOnum" },
1732
{ 191,  "iquest","inverted question mark = turned question mark, U+00BF ISOnum" },
1733
{ 192,  "Agrave","latin capital letter A with grave = latin capital letter A grave, U+00C0 ISOlat1" },
1734
{ 193,  "Aacute","latin capital letter A with acute, U+00C1 ISOlat1" },
1735
{ 194,  "Acirc","latin capital letter A with circumflex, U+00C2 ISOlat1" },
1736
{ 195,  "Atilde","latin capital letter A with tilde, U+00C3 ISOlat1" },
1737
{ 196,  "Auml", "latin capital letter A with diaeresis, U+00C4 ISOlat1" },
1738
{ 197,  "Aring","latin capital letter A with ring above = latin capital letter A ring, U+00C5 ISOlat1" },
1739
{ 198,  "AElig","latin capital letter AE = latin capital ligature AE, U+00C6 ISOlat1" },
1740
{ 199,  "Ccedil","latin capital letter C with cedilla, U+00C7 ISOlat1" },
1741
{ 200,  "Egrave","latin capital letter E with grave, U+00C8 ISOlat1" },
1742
{ 201,  "Eacute","latin capital letter E with acute, U+00C9 ISOlat1" },
1743
{ 202,  "Ecirc","latin capital letter E with circumflex, U+00CA ISOlat1" },
1744
{ 203,  "Euml", "latin capital letter E with diaeresis, U+00CB ISOlat1" },
1745
{ 204,  "Igrave","latin capital letter I with grave, U+00CC ISOlat1" },
1746
{ 205,  "Iacute","latin capital letter I with acute, U+00CD ISOlat1" },
1747
{ 206,  "Icirc","latin capital letter I with circumflex, U+00CE ISOlat1" },
1748
{ 207,  "Iuml", "latin capital letter I with diaeresis, U+00CF ISOlat1" },
1749
{ 208,  "ETH",  "latin capital letter ETH, U+00D0 ISOlat1" },
1750
{ 209,  "Ntilde","latin capital letter N with tilde, U+00D1 ISOlat1" },
1751
{ 210,  "Ograve","latin capital letter O with grave, U+00D2 ISOlat1" },
1752
{ 211,  "Oacute","latin capital letter O with acute, U+00D3 ISOlat1" },
1753
{ 212,  "Ocirc","latin capital letter O with circumflex, U+00D4 ISOlat1" },
1754
{ 213,  "Otilde","latin capital letter O with tilde, U+00D5 ISOlat1" },
1755
{ 214,  "Ouml", "latin capital letter O with diaeresis, U+00D6 ISOlat1" },
1756
{ 215,  "times","multiplication sign, U+00D7 ISOnum" },
1757
{ 216,  "Oslash","latin capital letter O with stroke latin capital letter O slash, U+00D8 ISOlat1" },
1758
{ 217,  "Ugrave","latin capital letter U with grave, U+00D9 ISOlat1" },
1759
{ 218,  "Uacute","latin capital letter U with acute, U+00DA ISOlat1" },
1760
{ 219,  "Ucirc","latin capital letter U with circumflex, U+00DB ISOlat1" },
1761
{ 220,  "Uuml", "latin capital letter U with diaeresis, U+00DC ISOlat1" },
1762
{ 221,  "Yacute","latin capital letter Y with acute, U+00DD ISOlat1" },
1763
{ 222,  "THORN","latin capital letter THORN, U+00DE ISOlat1" },
1764
{ 223,  "szlig","latin small letter sharp s = ess-zed, U+00DF ISOlat1" },
1765
{ 224,  "agrave","latin small letter a with grave = latin small letter a grave, U+00E0 ISOlat1" },
1766
{ 225,  "aacute","latin small letter a with acute, U+00E1 ISOlat1" },
1767
{ 226,  "acirc","latin small letter a with circumflex, U+00E2 ISOlat1" },
1768
{ 227,  "atilde","latin small letter a with tilde, U+00E3 ISOlat1" },
1769
{ 228,  "auml", "latin small letter a with diaeresis, U+00E4 ISOlat1" },
1770
{ 229,  "aring","latin small letter a with ring above = latin small letter a ring, U+00E5 ISOlat1" },
1771
{ 230,  "aelig","latin small letter ae = latin small ligature ae, U+00E6 ISOlat1" },
1772
{ 231,  "ccedil","latin small letter c with cedilla, U+00E7 ISOlat1" },
1773
{ 232,  "egrave","latin small letter e with grave, U+00E8 ISOlat1" },
1774
{ 233,  "eacute","latin small letter e with acute, U+00E9 ISOlat1" },
1775
{ 234,  "ecirc","latin small letter e with circumflex, U+00EA ISOlat1" },
1776
{ 235,  "euml", "latin small letter e with diaeresis, U+00EB ISOlat1" },
1777
{ 236,  "igrave","latin small letter i with grave, U+00EC ISOlat1" },
1778
{ 237,  "iacute","latin small letter i with acute, U+00ED ISOlat1" },
1779
{ 238,  "icirc","latin small letter i with circumflex, U+00EE ISOlat1" },
1780
{ 239,  "iuml", "latin small letter i with diaeresis, U+00EF ISOlat1" },
1781
{ 240,  "eth",  "latin small letter eth, U+00F0 ISOlat1" },
1782
{ 241,  "ntilde","latin small letter n with tilde, U+00F1 ISOlat1" },
1783
{ 242,  "ograve","latin small letter o with grave, U+00F2 ISOlat1" },
1784
{ 243,  "oacute","latin small letter o with acute, U+00F3 ISOlat1" },
1785
{ 244,  "ocirc","latin small letter o with circumflex, U+00F4 ISOlat1" },
1786
{ 245,  "otilde","latin small letter o with tilde, U+00F5 ISOlat1" },
1787
{ 246,  "ouml", "latin small letter o with diaeresis, U+00F6 ISOlat1" },
1788
{ 247,  "divide","division sign, U+00F7 ISOnum" },
1789
{ 248,  "oslash","latin small letter o with stroke, = latin small letter o slash, U+00F8 ISOlat1" },
1790
{ 249,  "ugrave","latin small letter u with grave, U+00F9 ISOlat1" },
1791
{ 250,  "uacute","latin small letter u with acute, U+00FA ISOlat1" },
1792
{ 251,  "ucirc","latin small letter u with circumflex, U+00FB ISOlat1" },
1793
{ 252,  "uuml", "latin small letter u with diaeresis, U+00FC ISOlat1" },
1794
{ 253,  "yacute","latin small letter y with acute, U+00FD ISOlat1" },
1795
{ 254,  "thorn","latin small letter thorn with, U+00FE ISOlat1" },
1796
{ 255,  "yuml", "latin small letter y with diaeresis, U+00FF ISOlat1" },
1797
1798
{ 338,  "OElig","latin capital ligature OE, U+0152 ISOlat2" },
1799
{ 339,  "oelig","latin small ligature oe, U+0153 ISOlat2" },
1800
{ 352,  "Scaron","latin capital letter S with caron, U+0160 ISOlat2" },
1801
{ 353,  "scaron","latin small letter s with caron, U+0161 ISOlat2" },
1802
{ 376,  "Yuml", "latin capital letter Y with diaeresis, U+0178 ISOlat2" },
1803
1804
/*
1805
 * Anything below should really be kept as entities references
1806
 */
1807
{ 402,  "fnof", "latin small f with hook = function = florin, U+0192 ISOtech" },
1808
1809
{ 710,  "circ", "modifier letter circumflex accent, U+02C6 ISOpub" },
1810
{ 732,  "tilde","small tilde, U+02DC ISOdia" },
1811
1812
{ 913,  "Alpha","greek capital letter alpha, U+0391" },
1813
{ 914,  "Beta", "greek capital letter beta, U+0392" },
1814
{ 915,  "Gamma","greek capital letter gamma, U+0393 ISOgrk3" },
1815
{ 916,  "Delta","greek capital letter delta, U+0394 ISOgrk3" },
1816
{ 917,  "Epsilon","greek capital letter epsilon, U+0395" },
1817
{ 918,  "Zeta", "greek capital letter zeta, U+0396" },
1818
{ 919,  "Eta",  "greek capital letter eta, U+0397" },
1819
{ 920,  "Theta","greek capital letter theta, U+0398 ISOgrk3" },
1820
{ 921,  "Iota", "greek capital letter iota, U+0399" },
1821
{ 922,  "Kappa","greek capital letter kappa, U+039A" },
1822
{ 923,  "Lambda", "greek capital letter lambda, U+039B ISOgrk3" },
1823
{ 924,  "Mu", "greek capital letter mu, U+039C" },
1824
{ 925,  "Nu", "greek capital letter nu, U+039D" },
1825
{ 926,  "Xi", "greek capital letter xi, U+039E ISOgrk3" },
1826
{ 927,  "Omicron","greek capital letter omicron, U+039F" },
1827
{ 928,  "Pi", "greek capital letter pi, U+03A0 ISOgrk3" },
1828
{ 929,  "Rho",  "greek capital letter rho, U+03A1" },
1829
{ 931,  "Sigma","greek capital letter sigma, U+03A3 ISOgrk3" },
1830
{ 932,  "Tau",  "greek capital letter tau, U+03A4" },
1831
{ 933,  "Upsilon","greek capital letter upsilon, U+03A5 ISOgrk3" },
1832
{ 934,  "Phi",  "greek capital letter phi, U+03A6 ISOgrk3" },
1833
{ 935,  "Chi",  "greek capital letter chi, U+03A7" },
1834
{ 936,  "Psi",  "greek capital letter psi, U+03A8 ISOgrk3" },
1835
{ 937,  "Omega","greek capital letter omega, U+03A9 ISOgrk3" },
1836
1837
{ 945,  "alpha","greek small letter alpha, U+03B1 ISOgrk3" },
1838
{ 946,  "beta", "greek small letter beta, U+03B2 ISOgrk3" },
1839
{ 947,  "gamma","greek small letter gamma, U+03B3 ISOgrk3" },
1840
{ 948,  "delta","greek small letter delta, U+03B4 ISOgrk3" },
1841
{ 949,  "epsilon","greek small letter epsilon, U+03B5 ISOgrk3" },
1842
{ 950,  "zeta", "greek small letter zeta, U+03B6 ISOgrk3" },
1843
{ 951,  "eta",  "greek small letter eta, U+03B7 ISOgrk3" },
1844
{ 952,  "theta","greek small letter theta, U+03B8 ISOgrk3" },
1845
{ 953,  "iota", "greek small letter iota, U+03B9 ISOgrk3" },
1846
{ 954,  "kappa","greek small letter kappa, U+03BA ISOgrk3" },
1847
{ 955,  "lambda","greek small letter lambda, U+03BB ISOgrk3" },
1848
{ 956,  "mu", "greek small letter mu, U+03BC ISOgrk3" },
1849
{ 957,  "nu", "greek small letter nu, U+03BD ISOgrk3" },
1850
{ 958,  "xi", "greek small letter xi, U+03BE ISOgrk3" },
1851
{ 959,  "omicron","greek small letter omicron, U+03BF NEW" },
1852
{ 960,  "pi", "greek small letter pi, U+03C0 ISOgrk3" },
1853
{ 961,  "rho",  "greek small letter rho, U+03C1 ISOgrk3" },
1854
{ 962,  "sigmaf","greek small letter final sigma, U+03C2 ISOgrk3" },
1855
{ 963,  "sigma","greek small letter sigma, U+03C3 ISOgrk3" },
1856
{ 964,  "tau",  "greek small letter tau, U+03C4 ISOgrk3" },
1857
{ 965,  "upsilon","greek small letter upsilon, U+03C5 ISOgrk3" },
1858
{ 966,  "phi",  "greek small letter phi, U+03C6 ISOgrk3" },
1859
{ 967,  "chi",  "greek small letter chi, U+03C7 ISOgrk3" },
1860
{ 968,  "psi",  "greek small letter psi, U+03C8 ISOgrk3" },
1861
{ 969,  "omega","greek small letter omega, U+03C9 ISOgrk3" },
1862
{ 977,  "thetasym","greek small letter theta symbol, U+03D1 NEW" },
1863
{ 978,  "upsih","greek upsilon with hook symbol, U+03D2 NEW" },
1864
{ 982,  "piv",  "greek pi symbol, U+03D6 ISOgrk3" },
1865
1866
{ 8194, "ensp", "en space, U+2002 ISOpub" },
1867
{ 8195, "emsp", "em space, U+2003 ISOpub" },
1868
{ 8201, "thinsp","thin space, U+2009 ISOpub" },
1869
{ 8204, "zwnj", "zero width non-joiner, U+200C NEW RFC 2070" },
1870
{ 8205, "zwj",  "zero width joiner, U+200D NEW RFC 2070" },
1871
{ 8206, "lrm",  "left-to-right mark, U+200E NEW RFC 2070" },
1872
{ 8207, "rlm",  "right-to-left mark, U+200F NEW RFC 2070" },
1873
{ 8211, "ndash","en dash, U+2013 ISOpub" },
1874
{ 8212, "mdash","em dash, U+2014 ISOpub" },
1875
{ 8216, "lsquo","left single quotation mark, U+2018 ISOnum" },
1876
{ 8217, "rsquo","right single quotation mark, U+2019 ISOnum" },
1877
{ 8218, "sbquo","single low-9 quotation mark, U+201A NEW" },
1878
{ 8220, "ldquo","left double quotation mark, U+201C ISOnum" },
1879
{ 8221, "rdquo","right double quotation mark, U+201D ISOnum" },
1880
{ 8222, "bdquo","double low-9 quotation mark, U+201E NEW" },
1881
{ 8224, "dagger","dagger, U+2020 ISOpub" },
1882
{ 8225, "Dagger","double dagger, U+2021 ISOpub" },
1883
1884
{ 8226, "bull", "bullet = black small circle, U+2022 ISOpub" },
1885
{ 8230, "hellip","horizontal ellipsis = three dot leader, U+2026 ISOpub" },
1886
1887
{ 8240, "permil","per mille sign, U+2030 ISOtech" },
1888
1889
{ 8242, "prime","prime = minutes = feet, U+2032 ISOtech" },
1890
{ 8243, "Prime","double prime = seconds = inches, U+2033 ISOtech" },
1891
1892
{ 8249, "lsaquo","single left-pointing angle quotation mark, U+2039 ISO proposed" },
1893
{ 8250, "rsaquo","single right-pointing angle quotation mark, U+203A ISO proposed" },
1894
1895
{ 8254, "oline","overline = spacing overscore, U+203E NEW" },
1896
{ 8260, "frasl","fraction slash, U+2044 NEW" },
1897
1898
{ 8364, "euro", "euro sign, U+20AC NEW" },
1899
1900
{ 8465, "image","blackletter capital I = imaginary part, U+2111 ISOamso" },
1901
{ 8472, "weierp","script capital P = power set = Weierstrass p, U+2118 ISOamso" },
1902
{ 8476, "real", "blackletter capital R = real part symbol, U+211C ISOamso" },
1903
{ 8482, "trade","trade mark sign, U+2122 ISOnum" },
1904
{ 8501, "alefsym","alef symbol = first transfinite cardinal, U+2135 NEW" },
1905
{ 8592, "larr", "leftwards arrow, U+2190 ISOnum" },
1906
{ 8593, "uarr", "upwards arrow, U+2191 ISOnum" },
1907
{ 8594, "rarr", "rightwards arrow, U+2192 ISOnum" },
1908
{ 8595, "darr", "downwards arrow, U+2193 ISOnum" },
1909
{ 8596, "harr", "left right arrow, U+2194 ISOamsa" },
1910
{ 8629, "crarr","downwards arrow with corner leftwards = carriage return, U+21B5 NEW" },
1911
{ 8656, "lArr", "leftwards double arrow, U+21D0 ISOtech" },
1912
{ 8657, "uArr", "upwards double arrow, U+21D1 ISOamsa" },
1913
{ 8658, "rArr", "rightwards double arrow, U+21D2 ISOtech" },
1914
{ 8659, "dArr", "downwards double arrow, U+21D3 ISOamsa" },
1915
{ 8660, "hArr", "left right double arrow, U+21D4 ISOamsa" },
1916
1917
{ 8704, "forall","for all, U+2200 ISOtech" },
1918
{ 8706, "part", "partial differential, U+2202 ISOtech" },
1919
{ 8707, "exist","there exists, U+2203 ISOtech" },
1920
{ 8709, "empty","empty set = null set = diameter, U+2205 ISOamso" },
1921
{ 8711, "nabla","nabla = backward difference, U+2207 ISOtech" },
1922
{ 8712, "isin", "element of, U+2208 ISOtech" },
1923
{ 8713, "notin","not an element of, U+2209 ISOtech" },
1924
{ 8715, "ni", "contains as member, U+220B ISOtech" },
1925
{ 8719, "prod", "n-ary product = product sign, U+220F ISOamsb" },
1926
{ 8721, "sum",  "n-ary summation, U+2211 ISOamsb" },
1927
{ 8722, "minus","minus sign, U+2212 ISOtech" },
1928
{ 8727, "lowast","asterisk operator, U+2217 ISOtech" },
1929
{ 8730, "radic","square root = radical sign, U+221A ISOtech" },
1930
{ 8733, "prop", "proportional to, U+221D ISOtech" },
1931
{ 8734, "infin","infinity, U+221E ISOtech" },
1932
{ 8736, "ang",  "angle, U+2220 ISOamso" },
1933
{ 8743, "and",  "logical and = wedge, U+2227 ISOtech" },
1934
{ 8744, "or", "logical or = vee, U+2228 ISOtech" },
1935
{ 8745, "cap",  "intersection = cap, U+2229 ISOtech" },
1936
{ 8746, "cup",  "union = cup, U+222A ISOtech" },
1937
{ 8747, "int",  "integral, U+222B ISOtech" },
1938
{ 8756, "there4","therefore, U+2234 ISOtech" },
1939
{ 8764, "sim",  "tilde operator = varies with = similar to, U+223C ISOtech" },
1940
{ 8773, "cong", "approximately equal to, U+2245 ISOtech" },
1941
{ 8776, "asymp","almost equal to = asymptotic to, U+2248 ISOamsr" },
1942
{ 8800, "ne", "not equal to, U+2260 ISOtech" },
1943
{ 8801, "equiv","identical to, U+2261 ISOtech" },
1944
{ 8804, "le", "less-than or equal to, U+2264 ISOtech" },
1945
{ 8805, "ge", "greater-than or equal to, U+2265 ISOtech" },
1946
{ 8834, "sub",  "subset of, U+2282 ISOtech" },
1947
{ 8835, "sup",  "superset of, U+2283 ISOtech" },
1948
{ 8836, "nsub", "not a subset of, U+2284 ISOamsn" },
1949
{ 8838, "sube", "subset of or equal to, U+2286 ISOtech" },
1950
{ 8839, "supe", "superset of or equal to, U+2287 ISOtech" },
1951
{ 8853, "oplus","circled plus = direct sum, U+2295 ISOamsb" },
1952
{ 8855, "otimes","circled times = vector product, U+2297 ISOamsb" },
1953
{ 8869, "perp", "up tack = orthogonal to = perpendicular, U+22A5 ISOtech" },
1954
{ 8901, "sdot", "dot operator, U+22C5 ISOamsb" },
1955
{ 8968, "lceil","left ceiling = apl upstile, U+2308 ISOamsc" },
1956
{ 8969, "rceil","right ceiling, U+2309 ISOamsc" },
1957
{ 8970, "lfloor","left floor = apl downstile, U+230A ISOamsc" },
1958
{ 8971, "rfloor","right floor, U+230B ISOamsc" },
1959
{ 9001, "lang", "left-pointing angle bracket = bra, U+2329 ISOtech" },
1960
{ 9002, "rang", "right-pointing angle bracket = ket, U+232A ISOtech" },
1961
{ 9674, "loz",  "lozenge, U+25CA ISOpub" },
1962
1963
{ 9824, "spades","black spade suit, U+2660 ISOpub" },
1964
{ 9827, "clubs","black club suit = shamrock, U+2663 ISOpub" },
1965
{ 9829, "hearts","black heart suit = valentine, U+2665 ISOpub" },
1966
{ 9830, "diams","black diamond suit, U+2666 ISOpub" },
1967
1968
};
1969
1970
/************************************************************************
1971
 *                  *
1972
 *    Commodity functions to handle entities      *
1973
 *                  *
1974
 ************************************************************************/
1975
1976
/*
1977
 * Macro used to grow the current buffer.
1978
 */
1979
0
#define growBuffer(buffer) {           \
1980
0
    xmlChar *tmp;             \
1981
0
    buffer##_size *= 2;             \
1982
0
    tmp = (xmlChar *) xmlRealloc(buffer, buffer##_size);    \
1983
0
    if (tmp == NULL) {             \
1984
0
  htmlErrMemory(ctxt);      \
1985
0
  xmlFree(buffer);            \
1986
0
  return(NULL);             \
1987
0
    }                  \
1988
0
    buffer = tmp;             \
1989
0
}
1990
1991
/**
1992
 * htmlEntityLookup:
1993
 * @name: the entity name
1994
 *
1995
 * Lookup the given entity in EntitiesTable
1996
 *
1997
 * TODO: the linear scan is really ugly, an hash table is really needed.
1998
 *
1999
 * Returns the associated htmlEntityDescPtr if found, NULL otherwise.
2000
 */
2001
const htmlEntityDesc *
2002
0
htmlEntityLookup(const xmlChar *name) {
2003
0
    unsigned int i;
2004
2005
0
    for (i = 0;i < (sizeof(html40EntitiesTable)/
2006
0
                    sizeof(html40EntitiesTable[0]));i++) {
2007
0
        if (xmlStrEqual(name, BAD_CAST html40EntitiesTable[i].name)) {
2008
0
            return((htmlEntityDescPtr) &html40EntitiesTable[i]);
2009
0
  }
2010
0
    }
2011
0
    return(NULL);
2012
0
}
2013
2014
/**
2015
 * htmlEntityValueLookup:
2016
 * @value: the entity's unicode value
2017
 *
2018
 * Lookup the given entity in EntitiesTable
2019
 *
2020
 * TODO: the linear scan is really ugly, an hash table is really needed.
2021
 *
2022
 * Returns the associated htmlEntityDescPtr if found, NULL otherwise.
2023
 */
2024
const htmlEntityDesc *
2025
0
htmlEntityValueLookup(unsigned int value) {
2026
0
    unsigned int i;
2027
2028
0
    for (i = 0;i < (sizeof(html40EntitiesTable)/
2029
0
                    sizeof(html40EntitiesTable[0]));i++) {
2030
0
        if (html40EntitiesTable[i].value >= value) {
2031
0
      if (html40EntitiesTable[i].value > value)
2032
0
    break;
2033
0
            return((htmlEntityDescPtr) &html40EntitiesTable[i]);
2034
0
  }
2035
0
    }
2036
0
    return(NULL);
2037
0
}
2038
2039
/**
2040
 * UTF8ToHtml:
2041
 * @out:  a pointer to an array of bytes to store the result
2042
 * @outlen:  the length of @out
2043
 * @in:  a pointer to an array of UTF-8 chars
2044
 * @inlen:  the length of @in
2045
 *
2046
 * Take a block of UTF-8 chars in and try to convert it to an ASCII
2047
 * plus HTML entities block of chars out.
2048
 *
2049
 * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise
2050
 * The value of @inlen after return is the number of octets consumed
2051
 *     as the return value is positive, else unpredictable.
2052
 * The value of @outlen after return is the number of octets consumed.
2053
 */
2054
int
2055
UTF8ToHtml(unsigned char* out, int *outlen,
2056
0
              const unsigned char* in, int *inlen) {
2057
0
    const unsigned char* processed = in;
2058
0
    const unsigned char* outend;
2059
0
    const unsigned char* outstart = out;
2060
0
    const unsigned char* instart = in;
2061
0
    const unsigned char* inend;
2062
0
    unsigned int c, d;
2063
0
    int trailing;
2064
2065
0
    if ((out == NULL) || (outlen == NULL) || (inlen == NULL)) return(-1);
2066
0
    if (in == NULL) {
2067
        /*
2068
   * initialization nothing to do
2069
   */
2070
0
  *outlen = 0;
2071
0
  *inlen = 0;
2072
0
  return(0);
2073
0
    }
2074
0
    inend = in + (*inlen);
2075
0
    outend = out + (*outlen);
2076
0
    while (in < inend) {
2077
0
  d = *in++;
2078
0
  if      (d < 0x80)  { c= d; trailing= 0; }
2079
0
  else if (d < 0xC0) {
2080
      /* trailing byte in leading position */
2081
0
      *outlen = out - outstart;
2082
0
      *inlen = processed - instart;
2083
0
      return(-2);
2084
0
        } else if (d < 0xE0)  { c= d & 0x1F; trailing= 1; }
2085
0
        else if (d < 0xF0)  { c= d & 0x0F; trailing= 2; }
2086
0
        else if (d < 0xF8)  { c= d & 0x07; trailing= 3; }
2087
0
  else {
2088
      /* no chance for this in Ascii */
2089
0
      *outlen = out - outstart;
2090
0
      *inlen = processed - instart;
2091
0
      return(-2);
2092
0
  }
2093
2094
0
  if (inend - in < trailing) {
2095
0
      break;
2096
0
  }
2097
2098
0
  for ( ; trailing; trailing--) {
2099
0
      if ((in >= inend) || (((d= *in++) & 0xC0) != 0x80))
2100
0
    break;
2101
0
      c <<= 6;
2102
0
      c |= d & 0x3F;
2103
0
  }
2104
2105
  /* assertion: c is a single UTF-4 value */
2106
0
  if (c < 0x80) {
2107
0
      if (out + 1 >= outend)
2108
0
    break;
2109
0
      *out++ = c;
2110
0
  } else {
2111
0
      int len;
2112
0
      const htmlEntityDesc * ent;
2113
0
      const char *cp;
2114
0
      char nbuf[16];
2115
2116
      /*
2117
       * Try to lookup a predefined HTML entity for it
2118
       */
2119
2120
0
      ent = htmlEntityValueLookup(c);
2121
0
      if (ent == NULL) {
2122
0
        snprintf(nbuf, sizeof(nbuf), "#%u", c);
2123
0
        cp = nbuf;
2124
0
      }
2125
0
      else
2126
0
        cp = ent->name;
2127
0
      len = strlen(cp);
2128
0
      if (out + 2 + len >= outend)
2129
0
    break;
2130
0
      *out++ = '&';
2131
0
      memcpy(out, cp, len);
2132
0
      out += len;
2133
0
      *out++ = ';';
2134
0
  }
2135
0
  processed = in;
2136
0
    }
2137
0
    *outlen = out - outstart;
2138
0
    *inlen = processed - instart;
2139
0
    return(0);
2140
0
}
2141
2142
/**
2143
 * htmlEncodeEntities:
2144
 * @out:  a pointer to an array of bytes to store the result
2145
 * @outlen:  the length of @out
2146
 * @in:  a pointer to an array of UTF-8 chars
2147
 * @inlen:  the length of @in
2148
 * @quoteChar: the quote character to escape (' or ") or zero.
2149
 *
2150
 * Take a block of UTF-8 chars in and try to convert it to an ASCII
2151
 * plus HTML entities block of chars out.
2152
 *
2153
 * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise
2154
 * The value of @inlen after return is the number of octets consumed
2155
 *     as the return value is positive, else unpredictable.
2156
 * The value of @outlen after return is the number of octets consumed.
2157
 */
2158
int
2159
htmlEncodeEntities(unsigned char* out, int *outlen,
2160
0
       const unsigned char* in, int *inlen, int quoteChar) {
2161
0
    const unsigned char* processed = in;
2162
0
    const unsigned char* outend;
2163
0
    const unsigned char* outstart = out;
2164
0
    const unsigned char* instart = in;
2165
0
    const unsigned char* inend;
2166
0
    unsigned int c, d;
2167
0
    int trailing;
2168
2169
0
    if ((out == NULL) || (outlen == NULL) || (inlen == NULL) || (in == NULL))
2170
0
        return(-1);
2171
0
    outend = out + (*outlen);
2172
0
    inend = in + (*inlen);
2173
0
    while (in < inend) {
2174
0
  d = *in++;
2175
0
  if      (d < 0x80)  { c= d; trailing= 0; }
2176
0
  else if (d < 0xC0) {
2177
      /* trailing byte in leading position */
2178
0
      *outlen = out - outstart;
2179
0
      *inlen = processed - instart;
2180
0
      return(-2);
2181
0
        } else if (d < 0xE0)  { c= d & 0x1F; trailing= 1; }
2182
0
        else if (d < 0xF0)  { c= d & 0x0F; trailing= 2; }
2183
0
        else if (d < 0xF8)  { c= d & 0x07; trailing= 3; }
2184
0
  else {
2185
      /* no chance for this in Ascii */
2186
0
      *outlen = out - outstart;
2187
0
      *inlen = processed - instart;
2188
0
      return(-2);
2189
0
  }
2190
2191
0
  if (inend - in < trailing)
2192
0
      break;
2193
2194
0
  while (trailing--) {
2195
0
      if (((d= *in++) & 0xC0) != 0x80) {
2196
0
    *outlen = out - outstart;
2197
0
    *inlen = processed - instart;
2198
0
    return(-2);
2199
0
      }
2200
0
      c <<= 6;
2201
0
      c |= d & 0x3F;
2202
0
  }
2203
2204
  /* assertion: c is a single UTF-4 value */
2205
0
  if ((c < 0x80) && (c != (unsigned int) quoteChar) &&
2206
0
      (c != '&') && (c != '<') && (c != '>')) {
2207
0
      if (out >= outend)
2208
0
    break;
2209
0
      *out++ = c;
2210
0
  } else {
2211
0
      const htmlEntityDesc * ent;
2212
0
      const char *cp;
2213
0
      char nbuf[16];
2214
0
      int len;
2215
2216
      /*
2217
       * Try to lookup a predefined HTML entity for it
2218
       */
2219
0
      ent = htmlEntityValueLookup(c);
2220
0
      if (ent == NULL) {
2221
0
    snprintf(nbuf, sizeof(nbuf), "#%u", c);
2222
0
    cp = nbuf;
2223
0
      }
2224
0
      else
2225
0
    cp = ent->name;
2226
0
      len = strlen(cp);
2227
0
      if (outend - out < len + 2)
2228
0
    break;
2229
0
      *out++ = '&';
2230
0
      memcpy(out, cp, len);
2231
0
      out += len;
2232
0
      *out++ = ';';
2233
0
  }
2234
0
  processed = in;
2235
0
    }
2236
0
    *outlen = out - outstart;
2237
0
    *inlen = processed - instart;
2238
0
    return(0);
2239
0
}
2240
2241
/************************************************************************
2242
 *                  *
2243
 *    Commodity functions, cleanup needed ?     *
2244
 *                  *
2245
 ************************************************************************/
2246
/*
2247
 * all tags allowing pc data from the html 4.01 loose dtd
2248
 * NOTE: it might be more appropriate to integrate this information
2249
 * into the html40ElementTable array but I don't want to risk any
2250
 * binary incompatibility
2251
 */
2252
static const char *allowPCData[] = {
2253
    "a", "abbr", "acronym", "address", "applet", "b", "bdo", "big",
2254
    "blockquote", "body", "button", "caption", "center", "cite", "code",
2255
    "dd", "del", "dfn", "div", "dt", "em", "font", "form", "h1", "h2",
2256
    "h3", "h4", "h5", "h6", "i", "iframe", "ins", "kbd", "label", "legend",
2257
    "li", "noframes", "noscript", "object", "p", "pre", "q", "s", "samp",
2258
    "small", "span", "strike", "strong", "td", "th", "tt", "u", "var"
2259
};
2260
2261
/**
2262
 * areBlanks:
2263
 * @ctxt:  an HTML parser context
2264
 * @str:  a xmlChar *
2265
 * @len:  the size of @str
2266
 *
2267
 * Is this a sequence of blank chars that one can ignore ?
2268
 *
2269
 * Returns 1 if ignorable 0 otherwise.
2270
 */
2271
2272
0
static int areBlanks(htmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
2273
0
    unsigned int i;
2274
0
    int j;
2275
0
    xmlNodePtr lastChild;
2276
0
    xmlDtdPtr dtd;
2277
2278
0
    for (j = 0;j < len;j++)
2279
0
        if (!(IS_BLANK_CH(str[j]))) return(0);
2280
2281
0
    if (CUR == 0) return(1);
2282
0
    if (CUR != '<') return(0);
2283
0
    if (ctxt->name == NULL)
2284
0
  return(1);
2285
0
    if (xmlStrEqual(ctxt->name, BAD_CAST"html"))
2286
0
  return(1);
2287
0
    if (xmlStrEqual(ctxt->name, BAD_CAST"head"))
2288
0
  return(1);
2289
2290
    /* Only strip CDATA children of the body tag for strict HTML DTDs */
2291
0
    if (xmlStrEqual(ctxt->name, BAD_CAST "body") && ctxt->myDoc != NULL) {
2292
0
        dtd = xmlGetIntSubset(ctxt->myDoc);
2293
0
        if (dtd != NULL && dtd->ExternalID != NULL) {
2294
0
            if (!xmlStrcasecmp(dtd->ExternalID, BAD_CAST "-//W3C//DTD HTML 4.01//EN") ||
2295
0
                    !xmlStrcasecmp(dtd->ExternalID, BAD_CAST "-//W3C//DTD HTML 4//EN"))
2296
0
                return(1);
2297
0
        }
2298
0
    }
2299
2300
0
    if (ctxt->node == NULL) return(0);
2301
0
    lastChild = xmlGetLastChild(ctxt->node);
2302
0
    while ((lastChild) && (lastChild->type == XML_COMMENT_NODE))
2303
0
  lastChild = lastChild->prev;
2304
0
    if (lastChild == NULL) {
2305
0
        if ((ctxt->node->type != XML_ELEMENT_NODE) &&
2306
0
            (ctxt->node->content != NULL)) return(0);
2307
  /* keep ws in constructs like ...<b> </b>...
2308
     for all tags "b" allowing PCDATA */
2309
0
  for ( i = 0; i < sizeof(allowPCData)/sizeof(allowPCData[0]); i++ ) {
2310
0
      if ( xmlStrEqual(ctxt->name, BAD_CAST allowPCData[i]) ) {
2311
0
    return(0);
2312
0
      }
2313
0
  }
2314
0
    } else if (xmlNodeIsText(lastChild)) {
2315
0
        return(0);
2316
0
    } else {
2317
  /* keep ws in constructs like <p><b>xy</b> <i>z</i><p>
2318
     for all tags "p" allowing PCDATA */
2319
0
  for ( i = 0; i < sizeof(allowPCData)/sizeof(allowPCData[0]); i++ ) {
2320
0
      if ( xmlStrEqual(lastChild->name, BAD_CAST allowPCData[i]) ) {
2321
0
    return(0);
2322
0
      }
2323
0
  }
2324
0
    }
2325
0
    return(1);
2326
0
}
2327
2328
/**
2329
 * htmlNewDocNoDtD:
2330
 * @URI:  URI for the dtd, or NULL
2331
 * @ExternalID:  the external ID of the DTD, or NULL
2332
 *
2333
 * Creates a new HTML document without a DTD node if @URI and @ExternalID
2334
 * are NULL
2335
 *
2336
 * Returns a new document, do not initialize the DTD if not provided
2337
 */
2338
htmlDocPtr
2339
124
htmlNewDocNoDtD(const xmlChar *URI, const xmlChar *ExternalID) {
2340
124
    xmlDocPtr cur;
2341
2342
    /*
2343
     * Allocate a new document and fill the fields.
2344
     */
2345
124
    cur = (xmlDocPtr) xmlMalloc(sizeof(xmlDoc));
2346
124
    if (cur == NULL)
2347
0
  return(NULL);
2348
124
    memset(cur, 0, sizeof(xmlDoc));
2349
2350
124
    cur->type = XML_HTML_DOCUMENT_NODE;
2351
124
    cur->version = NULL;
2352
124
    cur->intSubset = NULL;
2353
124
    cur->doc = cur;
2354
124
    cur->name = NULL;
2355
124
    cur->children = NULL;
2356
124
    cur->extSubset = NULL;
2357
124
    cur->oldNs = NULL;
2358
124
    cur->encoding = NULL;
2359
124
    cur->standalone = 1;
2360
124
    cur->compression = 0;
2361
124
    cur->ids = NULL;
2362
124
    cur->refs = NULL;
2363
124
    cur->_private = NULL;
2364
124
    cur->charset = XML_CHAR_ENCODING_UTF8;
2365
124
    cur->properties = XML_DOC_HTML | XML_DOC_USERBUILT;
2366
124
    if ((ExternalID != NULL) ||
2367
124
  (URI != NULL)) {
2368
124
        xmlDtdPtr intSubset;
2369
2370
124
  intSubset = xmlCreateIntSubset(cur, BAD_CAST "html", ExternalID, URI);
2371
124
        if (intSubset == NULL) {
2372
0
            xmlFree(cur);
2373
0
            return(NULL);
2374
0
        }
2375
124
    }
2376
124
    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
2377
0
  xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
2378
124
    return(cur);
2379
124
}
2380
2381
/**
2382
 * htmlNewDoc:
2383
 * @URI:  URI for the dtd, or NULL
2384
 * @ExternalID:  the external ID of the DTD, or NULL
2385
 *
2386
 * Creates a new HTML document
2387
 *
2388
 * Returns a new document
2389
 */
2390
htmlDocPtr
2391
124
htmlNewDoc(const xmlChar *URI, const xmlChar *ExternalID) {
2392
124
    if ((URI == NULL) && (ExternalID == NULL))
2393
124
  return(htmlNewDocNoDtD(
2394
124
        BAD_CAST "http://www.w3.org/TR/REC-html40/loose.dtd",
2395
124
        BAD_CAST "-//W3C//DTD HTML 4.0 Transitional//EN"));
2396
2397
0
    return(htmlNewDocNoDtD(URI, ExternalID));
2398
124
}
2399
2400
2401
/************************************************************************
2402
 *                  *
2403
 *      The parser itself       *
2404
 *  Relates to http://www.w3.org/TR/html40        *
2405
 *                  *
2406
 ************************************************************************/
2407
2408
/************************************************************************
2409
 *                  *
2410
 *      The parser itself       *
2411
 *                  *
2412
 ************************************************************************/
2413
2414
static const xmlChar * htmlParseNameComplex(xmlParserCtxtPtr ctxt);
2415
2416
static void
2417
0
htmlSkipBogusComment(htmlParserCtxtPtr ctxt) {
2418
0
    int c;
2419
2420
0
    htmlParseErr(ctxt, XML_HTML_INCORRECTLY_OPENED_COMMENT,
2421
0
                 "Incorrectly opened comment\n", NULL, NULL);
2422
2423
0
    while (PARSER_STOPPED(ctxt) == 0) {
2424
0
        c = CUR;
2425
0
        if (c == 0)
2426
0
            break;
2427
0
        NEXT;
2428
0
        if (c == '>')
2429
0
            break;
2430
0
    }
2431
0
}
2432
2433
/**
2434
 * htmlParseHTMLName:
2435
 * @ctxt:  an HTML parser context
2436
 *
2437
 * parse an HTML tag or attribute name, note that we convert it to lowercase
2438
 * since HTML names are not case-sensitive.
2439
 *
2440
 * Returns the Tag Name parsed or NULL
2441
 */
2442
2443
static const xmlChar *
2444
0
htmlParseHTMLName(htmlParserCtxtPtr ctxt) {
2445
0
    const xmlChar *ret;
2446
0
    int i = 0;
2447
0
    xmlChar loc[HTML_PARSER_BUFFER_SIZE];
2448
2449
0
    if (!IS_ASCII_LETTER(CUR) && (CUR != '_') &&
2450
0
        (CUR != ':') && (CUR != '.')) return(NULL);
2451
2452
0
    while ((i < HTML_PARSER_BUFFER_SIZE) &&
2453
0
           ((IS_ASCII_LETTER(CUR)) || (IS_ASCII_DIGIT(CUR)) ||
2454
0
     (CUR == ':') || (CUR == '-') || (CUR == '_') ||
2455
0
           (CUR == '.'))) {
2456
0
  if ((CUR >= 'A') && (CUR <= 'Z')) loc[i] = CUR + 0x20;
2457
0
        else loc[i] = CUR;
2458
0
  i++;
2459
2460
0
  NEXT;
2461
0
    }
2462
2463
0
    ret = xmlDictLookup(ctxt->dict, loc, i);
2464
0
    if (ret == NULL)
2465
0
        htmlErrMemory(ctxt);
2466
2467
0
    return(ret);
2468
0
}
2469
2470
2471
/**
2472
 * htmlParseHTMLName_nonInvasive:
2473
 * @ctxt:  an HTML parser context
2474
 *
2475
 * parse an HTML tag or attribute name, note that we convert it to lowercase
2476
 * since HTML names are not case-sensitive, this doesn't consume the data
2477
 * from the stream, it's a look-ahead
2478
 *
2479
 * Returns the Tag Name parsed or NULL
2480
 */
2481
2482
static const xmlChar *
2483
0
htmlParseHTMLName_nonInvasive(htmlParserCtxtPtr ctxt) {
2484
0
    int i = 0;
2485
0
    xmlChar loc[HTML_PARSER_BUFFER_SIZE];
2486
0
    const xmlChar *ret;
2487
2488
0
    if (!IS_ASCII_LETTER(NXT(1)) && (NXT(1) != '_') &&
2489
0
        (NXT(1) != ':')) return(NULL);
2490
2491
0
    while ((i < HTML_PARSER_BUFFER_SIZE) &&
2492
0
           ((IS_ASCII_LETTER(NXT(1+i))) || (IS_ASCII_DIGIT(NXT(1+i))) ||
2493
0
     (NXT(1+i) == ':') || (NXT(1+i) == '-') || (NXT(1+i) == '_'))) {
2494
0
  if ((NXT(1+i) >= 'A') && (NXT(1+i) <= 'Z')) loc[i] = NXT(1+i) + 0x20;
2495
0
        else loc[i] = NXT(1+i);
2496
0
  i++;
2497
0
    }
2498
2499
0
    ret = xmlDictLookup(ctxt->dict, loc, i);
2500
0
    if (ret == NULL)
2501
0
        htmlErrMemory(ctxt);
2502
2503
0
    return(ret);
2504
0
}
2505
2506
2507
/**
2508
 * htmlParseName:
2509
 * @ctxt:  an HTML parser context
2510
 *
2511
 * parse an HTML name, this routine is case sensitive.
2512
 *
2513
 * Returns the Name parsed or NULL
2514
 */
2515
2516
static const xmlChar *
2517
0
htmlParseName(htmlParserCtxtPtr ctxt) {
2518
0
    const xmlChar *in;
2519
0
    const xmlChar *ret;
2520
0
    int count = 0;
2521
2522
0
    GROW;
2523
2524
    /*
2525
     * Accelerator for simple ASCII names
2526
     */
2527
0
    in = ctxt->input->cur;
2528
0
    if (((*in >= 0x61) && (*in <= 0x7A)) ||
2529
0
  ((*in >= 0x41) && (*in <= 0x5A)) ||
2530
0
  (*in == '_') || (*in == ':')) {
2531
0
  in++;
2532
0
  while (((*in >= 0x61) && (*in <= 0x7A)) ||
2533
0
         ((*in >= 0x41) && (*in <= 0x5A)) ||
2534
0
         ((*in >= 0x30) && (*in <= 0x39)) ||
2535
0
         (*in == '_') || (*in == '-') ||
2536
0
         (*in == ':') || (*in == '.'))
2537
0
      in++;
2538
2539
0
  if (in == ctxt->input->end)
2540
0
      return(NULL);
2541
2542
0
  if ((*in > 0) && (*in < 0x80)) {
2543
0
      count = in - ctxt->input->cur;
2544
0
      ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
2545
0
            if (ret == NULL)
2546
0
                htmlErrMemory(ctxt);
2547
0
      ctxt->input->cur = in;
2548
0
      ctxt->input->col += count;
2549
0
      return(ret);
2550
0
  }
2551
0
    }
2552
0
    return(htmlParseNameComplex(ctxt));
2553
0
}
2554
2555
static const xmlChar *
2556
0
htmlParseNameComplex(xmlParserCtxtPtr ctxt) {
2557
0
    int len = 0, l;
2558
0
    int c;
2559
0
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
2560
0
                    XML_MAX_TEXT_LENGTH :
2561
0
                    XML_MAX_NAME_LENGTH;
2562
0
    const xmlChar *base = ctxt->input->base;
2563
0
    const xmlChar *ret;
2564
2565
    /*
2566
     * Handler for more complex cases
2567
     */
2568
0
    c = CUR_CHAR(l);
2569
0
    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
2570
0
  (!IS_LETTER(c) && (c != '_') &&
2571
0
         (c != ':'))) {
2572
0
  return(NULL);
2573
0
    }
2574
2575
0
    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
2576
0
     ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
2577
0
            (c == '.') || (c == '-') ||
2578
0
      (c == '_') || (c == ':') ||
2579
0
      (IS_COMBINING(c)) ||
2580
0
      (IS_EXTENDER(c)))) {
2581
0
  len += l;
2582
0
        if (len > maxLength) {
2583
0
            htmlParseErr(ctxt, XML_ERR_NAME_TOO_LONG, "name too long", NULL, NULL);
2584
0
            return(NULL);
2585
0
        }
2586
0
  NEXTL(l);
2587
0
  c = CUR_CHAR(l);
2588
0
  if (ctxt->input->base != base) {
2589
      /*
2590
       * We changed encoding from an unknown encoding
2591
       * Input buffer changed location, so we better start again
2592
       */
2593
0
      return(htmlParseNameComplex(ctxt));
2594
0
  }
2595
0
    }
2596
2597
0
    if (ctxt->input->cur - ctxt->input->base < len) {
2598
        /* Sanity check */
2599
0
  htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
2600
0
                     "unexpected change of input buffer", NULL, NULL);
2601
0
        return (NULL);
2602
0
    }
2603
2604
0
    ret = xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len);
2605
0
    if (ret == NULL)
2606
0
        htmlErrMemory(ctxt);
2607
2608
0
    return(ret);
2609
0
}
2610
2611
2612
/**
2613
 * htmlParseHTMLAttribute:
2614
 * @ctxt:  an HTML parser context
2615
 * @stop:  a char stop value
2616
 *
2617
 * parse an HTML attribute value till the stop (quote), if
2618
 * stop is 0 then it stops at the first space
2619
 *
2620
 * Returns the attribute parsed or NULL
2621
 */
2622
2623
static xmlChar *
2624
0
htmlParseHTMLAttribute(htmlParserCtxtPtr ctxt, const xmlChar stop) {
2625
0
    xmlChar *buffer = NULL;
2626
0
    int buffer_size = 0;
2627
0
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
2628
0
                    XML_MAX_HUGE_LENGTH :
2629
0
                    XML_MAX_TEXT_LENGTH;
2630
0
    xmlChar *out = NULL;
2631
0
    const xmlChar *name = NULL;
2632
0
    const xmlChar *cur = NULL;
2633
0
    const htmlEntityDesc * ent;
2634
2635
    /*
2636
     * allocate a translation buffer.
2637
     */
2638
0
    buffer_size = HTML_PARSER_BUFFER_SIZE;
2639
0
    buffer = (xmlChar *) xmlMallocAtomic(buffer_size);
2640
0
    if (buffer == NULL) {
2641
0
  htmlErrMemory(ctxt);
2642
0
  return(NULL);
2643
0
    }
2644
0
    out = buffer;
2645
2646
    /*
2647
     * Ok loop until we reach one of the ending chars
2648
     */
2649
0
    while ((PARSER_STOPPED(ctxt) == 0) &&
2650
0
           (CUR != 0) && (CUR != stop)) {
2651
0
  if ((stop == 0) && (CUR == '>')) break;
2652
0
  if ((stop == 0) && (IS_BLANK_CH(CUR))) break;
2653
0
        if (CUR == '&') {
2654
0
      if (NXT(1) == '#') {
2655
0
    unsigned int c;
2656
0
    int bits;
2657
2658
0
    c = htmlParseCharRef(ctxt);
2659
0
    if      (c <    0x80)
2660
0
            { *out++  = c;                bits= -6; }
2661
0
    else if (c <   0x800)
2662
0
            { *out++  =((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
2663
0
    else if (c < 0x10000)
2664
0
            { *out++  =((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
2665
0
    else
2666
0
            { *out++  =((c >> 18) & 0x07) | 0xF0;  bits= 12; }
2667
2668
0
    for ( ; bits >= 0; bits-= 6) {
2669
0
        *out++  = ((c >> bits) & 0x3F) | 0x80;
2670
0
    }
2671
2672
0
    if (out - buffer > buffer_size - 100) {
2673
0
      int indx = out - buffer;
2674
2675
0
      growBuffer(buffer);
2676
0
      out = &buffer[indx];
2677
0
    }
2678
0
      } else {
2679
0
    ent = htmlParseEntityRef(ctxt, &name);
2680
0
    if (name == NULL) {
2681
0
        *out++ = '&';
2682
0
        if (out - buffer > buffer_size - 100) {
2683
0
      int indx = out - buffer;
2684
2685
0
      growBuffer(buffer);
2686
0
      out = &buffer[indx];
2687
0
        }
2688
0
    } else if (ent == NULL) {
2689
0
        *out++ = '&';
2690
0
        cur = name;
2691
0
        while (*cur != 0) {
2692
0
      if (out - buffer > buffer_size - 100) {
2693
0
          int indx = out - buffer;
2694
2695
0
          growBuffer(buffer);
2696
0
          out = &buffer[indx];
2697
0
      }
2698
0
      *out++ = *cur++;
2699
0
        }
2700
0
    } else {
2701
0
        unsigned int c;
2702
0
        int bits;
2703
2704
0
        if (out - buffer > buffer_size - 100) {
2705
0
      int indx = out - buffer;
2706
2707
0
      growBuffer(buffer);
2708
0
      out = &buffer[indx];
2709
0
        }
2710
0
        c = ent->value;
2711
0
        if      (c <    0x80)
2712
0
      { *out++  = c;                bits= -6; }
2713
0
        else if (c <   0x800)
2714
0
      { *out++  =((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
2715
0
        else if (c < 0x10000)
2716
0
      { *out++  =((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
2717
0
        else
2718
0
      { *out++  =((c >> 18) & 0x07) | 0xF0;  bits= 12; }
2719
2720
0
        for ( ; bits >= 0; bits-= 6) {
2721
0
      *out++  = ((c >> bits) & 0x3F) | 0x80;
2722
0
        }
2723
0
    }
2724
0
      }
2725
0
  } else {
2726
0
      unsigned int c;
2727
0
      int bits, l;
2728
2729
0
      if (out - buffer > buffer_size - 100) {
2730
0
    int indx = out - buffer;
2731
2732
0
    growBuffer(buffer);
2733
0
    out = &buffer[indx];
2734
0
      }
2735
0
      c = CUR_CHAR(l);
2736
0
      if      (c <    0x80)
2737
0
        { *out++  = c;                bits= -6; }
2738
0
      else if (c <   0x800)
2739
0
        { *out++  =((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
2740
0
      else if (c < 0x10000)
2741
0
        { *out++  =((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
2742
0
      else
2743
0
        { *out++  =((c >> 18) & 0x07) | 0xF0;  bits= 12; }
2744
2745
0
      for ( ; bits >= 0; bits-= 6) {
2746
0
    *out++  = ((c >> bits) & 0x3F) | 0x80;
2747
0
      }
2748
0
      NEXTL(l);
2749
0
  }
2750
0
        if (out - buffer > maxLength) {
2751
0
            htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
2752
0
                         "attribute value too long\n", NULL, NULL);
2753
0
            xmlFree(buffer);
2754
0
            return(NULL);
2755
0
        }
2756
0
    }
2757
0
    *out = 0;
2758
0
    return(buffer);
2759
0
}
2760
2761
/**
2762
 * htmlParseEntityRef:
2763
 * @ctxt:  an HTML parser context
2764
 * @str:  location to store the entity name
2765
 *
2766
 * DEPRECATED: Internal function, don't use.
2767
 *
2768
 * parse an HTML ENTITY references
2769
 *
2770
 * [68] EntityRef ::= '&' Name ';'
2771
 *
2772
 * Returns the associated htmlEntityDescPtr if found, or NULL otherwise,
2773
 *         if non-NULL *str will have to be freed by the caller.
2774
 */
2775
const htmlEntityDesc *
2776
0
htmlParseEntityRef(htmlParserCtxtPtr ctxt, const xmlChar **str) {
2777
0
    const xmlChar *name;
2778
0
    const htmlEntityDesc * ent = NULL;
2779
2780
0
    if (str != NULL) *str = NULL;
2781
0
    if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL);
2782
2783
0
    if (CUR == '&') {
2784
0
        NEXT;
2785
0
        name = htmlParseName(ctxt);
2786
0
  if (name == NULL) {
2787
0
      htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
2788
0
                   "htmlParseEntityRef: no name\n", NULL, NULL);
2789
0
  } else {
2790
0
      GROW;
2791
0
      if (CUR == ';') {
2792
0
          if (str != NULL)
2793
0
        *str = name;
2794
2795
    /*
2796
     * Lookup the entity in the table.
2797
     */
2798
0
    ent = htmlEntityLookup(name);
2799
0
    if (ent != NULL) /* OK that's ugly !!! */
2800
0
        NEXT;
2801
0
      } else {
2802
0
    htmlParseErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING,
2803
0
                 "htmlParseEntityRef: expecting ';'\n",
2804
0
           NULL, NULL);
2805
0
          if (str != NULL)
2806
0
        *str = name;
2807
0
      }
2808
0
  }
2809
0
    }
2810
0
    return(ent);
2811
0
}
2812
2813
/**
2814
 * htmlParseAttValue:
2815
 * @ctxt:  an HTML parser context
2816
 *
2817
 * parse a value for an attribute
2818
 * Note: the parser won't do substitution of entities here, this
2819
 * will be handled later in xmlStringGetNodeList, unless it was
2820
 * asked for ctxt->replaceEntities != 0
2821
 *
2822
 * Returns the AttValue parsed or NULL.
2823
 */
2824
2825
static xmlChar *
2826
0
htmlParseAttValue(htmlParserCtxtPtr ctxt) {
2827
0
    xmlChar *ret = NULL;
2828
2829
0
    if (CUR == '"') {
2830
0
        NEXT;
2831
0
  ret = htmlParseHTMLAttribute(ctxt, '"');
2832
0
        if (CUR != '"') {
2833
0
      htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
2834
0
                   "AttValue: \" expected\n", NULL, NULL);
2835
0
  } else
2836
0
      NEXT;
2837
0
    } else if (CUR == '\'') {
2838
0
        NEXT;
2839
0
  ret = htmlParseHTMLAttribute(ctxt, '\'');
2840
0
        if (CUR != '\'') {
2841
0
      htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
2842
0
                   "AttValue: ' expected\n", NULL, NULL);
2843
0
  } else
2844
0
      NEXT;
2845
0
    } else {
2846
        /*
2847
   * That's an HTMLism, the attribute value may not be quoted
2848
   */
2849
0
  ret = htmlParseHTMLAttribute(ctxt, 0);
2850
0
  if (ret == NULL) {
2851
0
      htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
2852
0
                   "AttValue: no value found\n", NULL, NULL);
2853
0
  }
2854
0
    }
2855
0
    return(ret);
2856
0
}
2857
2858
/**
2859
 * htmlParseSystemLiteral:
2860
 * @ctxt:  an HTML parser context
2861
 *
2862
 * parse an HTML Literal
2863
 *
2864
 * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
2865
 *
2866
 * Returns the SystemLiteral parsed or NULL
2867
 */
2868
2869
static xmlChar *
2870
0
htmlParseSystemLiteral(htmlParserCtxtPtr ctxt) {
2871
0
    size_t len = 0, startPosition = 0;
2872
0
    int err = 0;
2873
0
    int quote;
2874
0
    xmlChar *ret = NULL;
2875
2876
0
    if ((CUR != '"') && (CUR != '\'')) {
2877
0
  htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_STARTED,
2878
0
               "SystemLiteral \" or ' expected\n", NULL, NULL);
2879
0
        return(NULL);
2880
0
    }
2881
0
    quote = CUR;
2882
0
    NEXT;
2883
2884
0
    if (CUR_PTR < BASE_PTR)
2885
0
        return(ret);
2886
0
    startPosition = CUR_PTR - BASE_PTR;
2887
2888
0
    while ((PARSER_STOPPED(ctxt) == 0) &&
2889
0
           (CUR != 0) && (CUR != quote)) {
2890
        /* TODO: Handle UTF-8 */
2891
0
        if (!IS_CHAR_CH(CUR)) {
2892
0
            htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
2893
0
                            "Invalid char in SystemLiteral 0x%X\n", CUR);
2894
0
            err = 1;
2895
0
        }
2896
0
        NEXT;
2897
0
        len++;
2898
0
    }
2899
0
    if (CUR != quote) {
2900
0
        htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED,
2901
0
                     "Unfinished SystemLiteral\n", NULL, NULL);
2902
0
    } else {
2903
0
        if (err == 0) {
2904
0
            ret = xmlStrndup((BASE_PTR+startPosition), len);
2905
0
            if (ret == NULL) {
2906
0
                htmlErrMemory(ctxt);
2907
0
                return(NULL);
2908
0
            }
2909
0
        }
2910
0
        NEXT;
2911
0
    }
2912
2913
0
    return(ret);
2914
0
}
2915
2916
/**
2917
 * htmlParsePubidLiteral:
2918
 * @ctxt:  an HTML parser context
2919
 *
2920
 * parse an HTML public literal
2921
 *
2922
 * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
2923
 *
2924
 * Returns the PubidLiteral parsed or NULL.
2925
 */
2926
2927
static xmlChar *
2928
0
htmlParsePubidLiteral(htmlParserCtxtPtr ctxt) {
2929
0
    size_t len = 0, startPosition = 0;
2930
0
    int err = 0;
2931
0
    int quote;
2932
0
    xmlChar *ret = NULL;
2933
2934
0
    if ((CUR != '"') && (CUR != '\'')) {
2935
0
  htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_STARTED,
2936
0
               "PubidLiteral \" or ' expected\n", NULL, NULL);
2937
0
        return(NULL);
2938
0
    }
2939
0
    quote = CUR;
2940
0
    NEXT;
2941
2942
    /*
2943
     * Name ::= (Letter | '_') (NameChar)*
2944
     */
2945
0
    if (CUR_PTR < BASE_PTR)
2946
0
        return(ret);
2947
0
    startPosition = CUR_PTR - BASE_PTR;
2948
2949
0
    while ((PARSER_STOPPED(ctxt) == 0) &&
2950
0
           (CUR != 0) && (CUR != quote)) {
2951
0
        if (!IS_PUBIDCHAR_CH(CUR)) {
2952
0
            htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
2953
0
                            "Invalid char in PubidLiteral 0x%X\n", CUR);
2954
0
            err = 1;
2955
0
        }
2956
0
        len++;
2957
0
        NEXT;
2958
0
    }
2959
2960
0
    if (CUR != quote) {
2961
0
        htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED,
2962
0
                     "Unfinished PubidLiteral\n", NULL, NULL);
2963
0
    } else {
2964
0
        if (err == 0) {
2965
0
            ret = xmlStrndup((BASE_PTR + startPosition), len);
2966
0
            if (ret == NULL) {
2967
0
                htmlErrMemory(ctxt);
2968
0
                return(NULL);
2969
0
            }
2970
0
        }
2971
0
        NEXT;
2972
0
    }
2973
2974
0
    return(ret);
2975
0
}
2976
2977
/**
2978
 * htmlParseScript:
2979
 * @ctxt:  an HTML parser context
2980
 *
2981
 * parse the content of an HTML SCRIPT or STYLE element
2982
 * http://www.w3.org/TR/html4/sgml/dtd.html#Script
2983
 * http://www.w3.org/TR/html4/sgml/dtd.html#StyleSheet
2984
 * http://www.w3.org/TR/html4/types.html#type-script
2985
 * http://www.w3.org/TR/html4/types.html#h-6.15
2986
 * http://www.w3.org/TR/html4/appendix/notes.html#h-B.3.2.1
2987
 *
2988
 * Script data ( %Script; in the DTD) can be the content of the SCRIPT
2989
 * element and the value of intrinsic event attributes. User agents must
2990
 * not evaluate script data as HTML markup but instead must pass it on as
2991
 * data to a script engine.
2992
 * NOTES:
2993
 * - The content is passed like CDATA
2994
 * - the attributes for style and scripting "onXXX" are also described
2995
 *   as CDATA but SGML allows entities references in attributes so their
2996
 *   processing is identical as other attributes
2997
 */
2998
static void
2999
0
htmlParseScript(htmlParserCtxtPtr ctxt) {
3000
0
    xmlChar buf[HTML_PARSER_BIG_BUFFER_SIZE + 5];
3001
0
    int nbchar = 0;
3002
0
    int cur,l;
3003
3004
0
    cur = CUR_CHAR(l);
3005
0
    while (cur != 0) {
3006
0
  if ((cur == '<') && (NXT(1) == '/')) {
3007
            /*
3008
             * One should break here, the specification is clear:
3009
             * Authors should therefore escape "</" within the content.
3010
             * Escape mechanisms are specific to each scripting or
3011
             * style sheet language.
3012
             *
3013
             * In recovery mode, only break if end tag match the
3014
             * current tag, effectively ignoring all tags inside the
3015
             * script/style block and treating the entire block as
3016
             * CDATA.
3017
             */
3018
0
            if (ctxt->recovery) {
3019
0
                if (xmlStrncasecmp(ctxt->name, ctxt->input->cur+2,
3020
0
           xmlStrlen(ctxt->name)) == 0)
3021
0
                {
3022
0
                    break; /* while */
3023
0
                } else {
3024
0
        htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
3025
0
         "Element %s embeds close tag\n",
3026
0
                     ctxt->name, NULL);
3027
0
    }
3028
0
            } else {
3029
0
                if (((NXT(2) >= 'A') && (NXT(2) <= 'Z')) ||
3030
0
                    ((NXT(2) >= 'a') && (NXT(2) <= 'z')))
3031
0
                {
3032
0
                    break; /* while */
3033
0
                }
3034
0
            }
3035
0
  }
3036
0
        if (IS_CHAR(cur)) {
3037
0
      COPY_BUF(l,buf,nbchar,cur);
3038
0
        } else {
3039
0
            htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
3040
0
                            "Invalid char in CDATA 0x%X\n", cur);
3041
0
        }
3042
0
  NEXTL(l);
3043
0
  if (nbchar >= HTML_PARSER_BIG_BUFFER_SIZE) {
3044
0
            buf[nbchar] = 0;
3045
0
      if (ctxt->sax->cdataBlock!= NULL) {
3046
    /*
3047
     * Insert as CDATA, which is the same as HTML_PRESERVE_NODE
3048
     */
3049
0
    ctxt->sax->cdataBlock(ctxt->userData, buf, nbchar);
3050
0
      } else if (ctxt->sax->characters != NULL) {
3051
0
    ctxt->sax->characters(ctxt->userData, buf, nbchar);
3052
0
      }
3053
0
      nbchar = 0;
3054
0
            SHRINK;
3055
0
  }
3056
0
  cur = CUR_CHAR(l);
3057
0
    }
3058
3059
0
    if ((nbchar != 0) && (ctxt->sax != NULL) && (!ctxt->disableSAX)) {
3060
0
        buf[nbchar] = 0;
3061
0
  if (ctxt->sax->cdataBlock!= NULL) {
3062
      /*
3063
       * Insert as CDATA, which is the same as HTML_PRESERVE_NODE
3064
       */
3065
0
      ctxt->sax->cdataBlock(ctxt->userData, buf, nbchar);
3066
0
  } else if (ctxt->sax->characters != NULL) {
3067
0
      ctxt->sax->characters(ctxt->userData, buf, nbchar);
3068
0
  }
3069
0
    }
3070
0
}
3071
3072
3073
/**
3074
 * htmlParseCharDataInternal:
3075
 * @ctxt:  an HTML parser context
3076
 * @readahead: optional read ahead character in ascii range
3077
 *
3078
 * parse a CharData section.
3079
 * if we are within a CDATA section ']]>' marks an end of section.
3080
 *
3081
 * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
3082
 */
3083
3084
static void
3085
0
htmlParseCharDataInternal(htmlParserCtxtPtr ctxt, int readahead) {
3086
0
    xmlChar buf[HTML_PARSER_BIG_BUFFER_SIZE + 6];
3087
0
    int nbchar = 0;
3088
0
    int cur, l;
3089
3090
0
    if (readahead)
3091
0
        buf[nbchar++] = readahead;
3092
3093
0
    cur = CUR_CHAR(l);
3094
0
    while ((cur != '<') &&
3095
0
           (cur != '&') &&
3096
0
     (cur != 0) &&
3097
0
           (!PARSER_STOPPED(ctxt))) {
3098
0
  if (!(IS_CHAR(cur))) {
3099
0
      htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
3100
0
                  "Invalid char in CDATA 0x%X\n", cur);
3101
0
  } else {
3102
0
      COPY_BUF(l,buf,nbchar,cur);
3103
0
  }
3104
0
  NEXTL(l);
3105
0
  if (nbchar >= HTML_PARSER_BIG_BUFFER_SIZE) {
3106
0
            buf[nbchar] = 0;
3107
3108
      /*
3109
       * Ok the segment is to be consumed as chars.
3110
       */
3111
0
      if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
3112
0
    if (areBlanks(ctxt, buf, nbchar)) {
3113
0
        if (ctxt->keepBlanks) {
3114
0
      if (ctxt->sax->characters != NULL)
3115
0
          ctxt->sax->characters(ctxt->userData, buf, nbchar);
3116
0
        } else {
3117
0
      if (ctxt->sax->ignorableWhitespace != NULL)
3118
0
          ctxt->sax->ignorableWhitespace(ctxt->userData,
3119
0
                                         buf, nbchar);
3120
0
        }
3121
0
    } else {
3122
0
        htmlCheckParagraph(ctxt);
3123
0
        if (ctxt->sax->characters != NULL)
3124
0
      ctxt->sax->characters(ctxt->userData, buf, nbchar);
3125
0
    }
3126
0
      }
3127
0
      nbchar = 0;
3128
0
            SHRINK;
3129
0
  }
3130
0
  cur = CUR_CHAR(l);
3131
0
    }
3132
0
    if (nbchar != 0) {
3133
0
        buf[nbchar] = 0;
3134
3135
  /*
3136
   * Ok the segment is to be consumed as chars.
3137
   */
3138
0
  if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
3139
0
      if (areBlanks(ctxt, buf, nbchar)) {
3140
0
    if (ctxt->keepBlanks) {
3141
0
        if (ctxt->sax->characters != NULL)
3142
0
      ctxt->sax->characters(ctxt->userData, buf, nbchar);
3143
0
    } else {
3144
0
        if (ctxt->sax->ignorableWhitespace != NULL)
3145
0
      ctxt->sax->ignorableWhitespace(ctxt->userData,
3146
0
                                     buf, nbchar);
3147
0
    }
3148
0
      } else {
3149
0
    htmlCheckParagraph(ctxt);
3150
0
    if (ctxt->sax->characters != NULL)
3151
0
        ctxt->sax->characters(ctxt->userData, buf, nbchar);
3152
0
      }
3153
0
  }
3154
0
    }
3155
0
}
3156
3157
/**
3158
 * htmlParseCharData:
3159
 * @ctxt:  an HTML parser context
3160
 *
3161
 * parse a CharData section.
3162
 * if we are within a CDATA section ']]>' marks an end of section.
3163
 *
3164
 * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
3165
 */
3166
3167
static void
3168
0
htmlParseCharData(htmlParserCtxtPtr ctxt) {
3169
0
    htmlParseCharDataInternal(ctxt, 0);
3170
0
}
3171
3172
/**
3173
 * htmlParseExternalID:
3174
 * @ctxt:  an HTML parser context
3175
 * @publicID:  a xmlChar** receiving PubidLiteral
3176
 *
3177
 * Parse an External ID or a Public ID
3178
 *
3179
 * [75] ExternalID ::= 'SYSTEM' S SystemLiteral
3180
 *                   | 'PUBLIC' S PubidLiteral S SystemLiteral
3181
 *
3182
 * [83] PublicID ::= 'PUBLIC' S PubidLiteral
3183
 *
3184
 * Returns the function returns SystemLiteral and in the second
3185
 *                case publicID receives PubidLiteral, is strict is off
3186
 *                it is possible to return NULL and have publicID set.
3187
 */
3188
3189
static xmlChar *
3190
0
htmlParseExternalID(htmlParserCtxtPtr ctxt, xmlChar **publicID) {
3191
0
    xmlChar *URI = NULL;
3192
3193
0
    if ((UPPER == 'S') && (UPP(1) == 'Y') &&
3194
0
         (UPP(2) == 'S') && (UPP(3) == 'T') &&
3195
0
   (UPP(4) == 'E') && (UPP(5) == 'M')) {
3196
0
        SKIP(6);
3197
0
  if (!IS_BLANK_CH(CUR)) {
3198
0
      htmlParseErr(ctxt, XML_ERR_SPACE_REQUIRED,
3199
0
                   "Space required after 'SYSTEM'\n", NULL, NULL);
3200
0
  }
3201
0
        SKIP_BLANKS;
3202
0
  URI = htmlParseSystemLiteral(ctxt);
3203
0
  if (URI == NULL) {
3204
0
      htmlParseErr(ctxt, XML_ERR_URI_REQUIRED,
3205
0
                   "htmlParseExternalID: SYSTEM, no URI\n", NULL, NULL);
3206
0
        }
3207
0
    } else if ((UPPER == 'P') && (UPP(1) == 'U') &&
3208
0
         (UPP(2) == 'B') && (UPP(3) == 'L') &&
3209
0
         (UPP(4) == 'I') && (UPP(5) == 'C')) {
3210
0
        SKIP(6);
3211
0
  if (!IS_BLANK_CH(CUR)) {
3212
0
      htmlParseErr(ctxt, XML_ERR_SPACE_REQUIRED,
3213
0
                   "Space required after 'PUBLIC'\n", NULL, NULL);
3214
0
  }
3215
0
        SKIP_BLANKS;
3216
0
  *publicID = htmlParsePubidLiteral(ctxt);
3217
0
  if (*publicID == NULL) {
3218
0
      htmlParseErr(ctxt, XML_ERR_PUBID_REQUIRED,
3219
0
                   "htmlParseExternalID: PUBLIC, no Public Identifier\n",
3220
0
       NULL, NULL);
3221
0
  }
3222
0
        SKIP_BLANKS;
3223
0
        if ((CUR == '"') || (CUR == '\'')) {
3224
0
      URI = htmlParseSystemLiteral(ctxt);
3225
0
  }
3226
0
    }
3227
0
    return(URI);
3228
0
}
3229
3230
/**
3231
 * htmlParsePI:
3232
 * @ctxt:  an HTML parser context
3233
 *
3234
 * Parse an XML Processing Instruction. HTML5 doesn't allow processing
3235
 * instructions, so this will be removed at some point.
3236
 */
3237
static void
3238
0
htmlParsePI(htmlParserCtxtPtr ctxt) {
3239
0
    xmlChar *buf = NULL;
3240
0
    int len = 0;
3241
0
    int size = HTML_PARSER_BUFFER_SIZE;
3242
0
    int cur, l;
3243
0
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
3244
0
                    XML_MAX_HUGE_LENGTH :
3245
0
                    XML_MAX_TEXT_LENGTH;
3246
0
    const xmlChar *target;
3247
0
    xmlParserInputState state;
3248
3249
0
    if ((RAW == '<') && (NXT(1) == '?')) {
3250
0
  state = ctxt->instate;
3251
0
        ctxt->instate = XML_PARSER_PI;
3252
  /*
3253
   * this is a Processing Instruction.
3254
   */
3255
0
  SKIP(2);
3256
3257
  /*
3258
   * Parse the target name and check for special support like
3259
   * namespace.
3260
   */
3261
0
        target = htmlParseName(ctxt);
3262
0
  if (target != NULL) {
3263
0
      if (RAW == '>') {
3264
0
    SKIP(1);
3265
3266
    /*
3267
     * SAX: PI detected.
3268
     */
3269
0
    if ((ctxt->sax) && (!ctxt->disableSAX) &&
3270
0
        (ctxt->sax->processingInstruction != NULL))
3271
0
        ctxt->sax->processingInstruction(ctxt->userData,
3272
0
                                         target, NULL);
3273
0
                goto done;
3274
0
      }
3275
0
      buf = (xmlChar *) xmlMallocAtomic(size);
3276
0
      if (buf == NULL) {
3277
0
    htmlErrMemory(ctxt);
3278
0
    return;
3279
0
      }
3280
0
      cur = CUR;
3281
0
      if (!IS_BLANK(cur)) {
3282
0
    htmlParseErr(ctxt, XML_ERR_SPACE_REQUIRED,
3283
0
        "ParsePI: PI %s space expected\n", target, NULL);
3284
0
      }
3285
0
            SKIP_BLANKS;
3286
0
      cur = CUR_CHAR(l);
3287
0
      while ((cur != 0) && (cur != '>')) {
3288
0
    if (len + 5 >= size) {
3289
0
        xmlChar *tmp;
3290
3291
0
        size *= 2;
3292
0
        tmp = (xmlChar *) xmlRealloc(buf, size);
3293
0
        if (tmp == NULL) {
3294
0
      htmlErrMemory(ctxt);
3295
0
      xmlFree(buf);
3296
0
      return;
3297
0
        }
3298
0
        buf = tmp;
3299
0
    }
3300
0
                if (IS_CHAR(cur)) {
3301
0
        COPY_BUF(l,buf,len,cur);
3302
0
                } else {
3303
0
                    htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
3304
0
                                    "Invalid char in processing instruction "
3305
0
                                    "0x%X\n", cur);
3306
0
                }
3307
0
                if (len > maxLength) {
3308
0
                    htmlParseErr(ctxt, XML_ERR_PI_NOT_FINISHED,
3309
0
                                 "PI %s too long", target, NULL);
3310
0
                    xmlFree(buf);
3311
0
                    goto done;
3312
0
                }
3313
0
    NEXTL(l);
3314
0
    cur = CUR_CHAR(l);
3315
0
      }
3316
0
      buf[len] = 0;
3317
0
      if (cur != '>') {
3318
0
    htmlParseErr(ctxt, XML_ERR_PI_NOT_FINISHED,
3319
0
          "ParsePI: PI %s never end ...\n", target, NULL);
3320
0
      } else {
3321
0
    SKIP(1);
3322
3323
    /*
3324
     * SAX: PI detected.
3325
     */
3326
0
    if ((ctxt->sax) && (!ctxt->disableSAX) &&
3327
0
        (ctxt->sax->processingInstruction != NULL))
3328
0
        ctxt->sax->processingInstruction(ctxt->userData,
3329
0
                                         target, buf);
3330
0
      }
3331
0
      xmlFree(buf);
3332
0
  } else {
3333
0
      htmlParseErr(ctxt, XML_ERR_PI_NOT_STARTED,
3334
0
                         "PI is not started correctly", NULL, NULL);
3335
0
  }
3336
3337
0
done:
3338
0
  ctxt->instate = state;
3339
0
    }
3340
0
}
3341
3342
/**
3343
 * htmlParseComment:
3344
 * @ctxt:  an HTML parser context
3345
 *
3346
 * Parse an HTML comment
3347
 */
3348
static void
3349
0
htmlParseComment(htmlParserCtxtPtr ctxt) {
3350
0
    xmlChar *buf = NULL;
3351
0
    int len;
3352
0
    int size = HTML_PARSER_BUFFER_SIZE;
3353
0
    int q, ql;
3354
0
    int r, rl;
3355
0
    int cur, l;
3356
0
    int next, nl;
3357
0
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
3358
0
                    XML_MAX_HUGE_LENGTH :
3359
0
                    XML_MAX_TEXT_LENGTH;
3360
0
    xmlParserInputState state;
3361
3362
    /*
3363
     * Check that there is a comment right here.
3364
     */
3365
0
    if ((RAW != '<') || (NXT(1) != '!') ||
3366
0
        (NXT(2) != '-') || (NXT(3) != '-')) return;
3367
3368
0
    state = ctxt->instate;
3369
0
    ctxt->instate = XML_PARSER_COMMENT;
3370
0
    SKIP(4);
3371
0
    buf = (xmlChar *) xmlMallocAtomic(size);
3372
0
    if (buf == NULL) {
3373
0
        htmlErrMemory(ctxt);
3374
0
  return;
3375
0
    }
3376
0
    len = 0;
3377
0
    buf[len] = 0;
3378
0
    q = CUR_CHAR(ql);
3379
0
    if (q == 0)
3380
0
        goto unfinished;
3381
0
    if (q == '>') {
3382
0
        htmlParseErr(ctxt, XML_ERR_COMMENT_ABRUPTLY_ENDED, "Comment abruptly ended", NULL, NULL);
3383
0
        cur = '>';
3384
0
        goto finished;
3385
0
    }
3386
0
    NEXTL(ql);
3387
0
    r = CUR_CHAR(rl);
3388
0
    if (r == 0)
3389
0
        goto unfinished;
3390
0
    if (q == '-' && r == '>') {
3391
0
        htmlParseErr(ctxt, XML_ERR_COMMENT_ABRUPTLY_ENDED, "Comment abruptly ended", NULL, NULL);
3392
0
        cur = '>';
3393
0
        goto finished;
3394
0
    }
3395
0
    NEXTL(rl);
3396
0
    cur = CUR_CHAR(l);
3397
0
    while ((cur != 0) &&
3398
0
           ((cur != '>') ||
3399
0
      (r != '-') || (q != '-'))) {
3400
0
  NEXTL(l);
3401
0
  next = CUR_CHAR(nl);
3402
3403
0
  if ((q == '-') && (r == '-') && (cur == '!') && (next == '>')) {
3404
0
    htmlParseErr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
3405
0
           "Comment incorrectly closed by '--!>'", NULL, NULL);
3406
0
    cur = '>';
3407
0
    break;
3408
0
  }
3409
3410
0
  if (len + 5 >= size) {
3411
0
      xmlChar *tmp;
3412
3413
0
      size *= 2;
3414
0
      tmp = (xmlChar *) xmlRealloc(buf, size);
3415
0
      if (tmp == NULL) {
3416
0
          xmlFree(buf);
3417
0
          htmlErrMemory(ctxt);
3418
0
    return;
3419
0
      }
3420
0
      buf = tmp;
3421
0
  }
3422
0
        if (IS_CHAR(q)) {
3423
0
      COPY_BUF(ql,buf,len,q);
3424
0
        } else {
3425
0
            htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
3426
0
                            "Invalid char in comment 0x%X\n", q);
3427
0
        }
3428
0
        if (len > maxLength) {
3429
0
            htmlParseErr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
3430
0
                         "comment too long", NULL, NULL);
3431
0
            xmlFree(buf);
3432
0
            ctxt->instate = state;
3433
0
            return;
3434
0
        }
3435
3436
0
  q = r;
3437
0
  ql = rl;
3438
0
  r = cur;
3439
0
  rl = l;
3440
0
  cur = next;
3441
0
  l = nl;
3442
0
    }
3443
0
finished:
3444
0
    buf[len] = 0;
3445
0
    if (cur == '>') {
3446
0
        NEXT;
3447
0
  if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
3448
0
      (!ctxt->disableSAX))
3449
0
      ctxt->sax->comment(ctxt->userData, buf);
3450
0
  xmlFree(buf);
3451
0
  ctxt->instate = state;
3452
0
  return;
3453
0
    }
3454
3455
0
unfinished:
3456
0
    htmlParseErr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
3457
0
     "Comment not terminated \n<!--%.50s\n", buf, NULL);
3458
0
    xmlFree(buf);
3459
0
}
3460
3461
/**
3462
 * htmlParseCharRef:
3463
 * @ctxt:  an HTML parser context
3464
 *
3465
 * DEPRECATED: Internal function, don't use.
3466
 *
3467
 * parse Reference declarations
3468
 *
3469
 * [66] CharRef ::= '&#' [0-9]+ ';' |
3470
 *                  '&#x' [0-9a-fA-F]+ ';'
3471
 *
3472
 * Returns the value parsed (as an int)
3473
 */
3474
int
3475
0
htmlParseCharRef(htmlParserCtxtPtr ctxt) {
3476
0
    int val = 0;
3477
3478
0
    if ((ctxt == NULL) || (ctxt->input == NULL))
3479
0
        return(0);
3480
0
    if ((CUR == '&') && (NXT(1) == '#') &&
3481
0
        ((NXT(2) == 'x') || NXT(2) == 'X')) {
3482
0
  SKIP(3);
3483
0
  while (CUR != ';') {
3484
0
      if ((CUR >= '0') && (CUR <= '9')) {
3485
0
                if (val < 0x110000)
3486
0
              val = val * 16 + (CUR - '0');
3487
0
            } else if ((CUR >= 'a') && (CUR <= 'f')) {
3488
0
                if (val < 0x110000)
3489
0
              val = val * 16 + (CUR - 'a') + 10;
3490
0
            } else if ((CUR >= 'A') && (CUR <= 'F')) {
3491
0
                if (val < 0x110000)
3492
0
              val = val * 16 + (CUR - 'A') + 10;
3493
0
            } else {
3494
0
          htmlParseErr(ctxt, XML_ERR_INVALID_HEX_CHARREF,
3495
0
                 "htmlParseCharRef: missing semicolon\n",
3496
0
           NULL, NULL);
3497
0
    break;
3498
0
      }
3499
0
      NEXT;
3500
0
  }
3501
0
  if (CUR == ';')
3502
0
      NEXT;
3503
0
    } else if  ((CUR == '&') && (NXT(1) == '#')) {
3504
0
  SKIP(2);
3505
0
  while (CUR != ';') {
3506
0
      if ((CUR >= '0') && (CUR <= '9')) {
3507
0
                if (val < 0x110000)
3508
0
              val = val * 10 + (CUR - '0');
3509
0
            } else {
3510
0
          htmlParseErr(ctxt, XML_ERR_INVALID_DEC_CHARREF,
3511
0
                 "htmlParseCharRef: missing semicolon\n",
3512
0
           NULL, NULL);
3513
0
    break;
3514
0
      }
3515
0
      NEXT;
3516
0
  }
3517
0
  if (CUR == ';')
3518
0
      NEXT;
3519
0
    } else {
3520
0
  htmlParseErr(ctxt, XML_ERR_INVALID_CHARREF,
3521
0
               "htmlParseCharRef: invalid value\n", NULL, NULL);
3522
0
    }
3523
    /*
3524
     * Check the value IS_CHAR ...
3525
     */
3526
0
    if (IS_CHAR(val)) {
3527
0
        return(val);
3528
0
    } else if (val >= 0x110000) {
3529
0
  htmlParseErr(ctxt, XML_ERR_INVALID_CHAR,
3530
0
         "htmlParseCharRef: value too large\n", NULL, NULL);
3531
0
    } else {
3532
0
  htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
3533
0
      "htmlParseCharRef: invalid xmlChar value %d\n",
3534
0
      val);
3535
0
    }
3536
0
    return(0);
3537
0
}
3538
3539
3540
/**
3541
 * htmlParseDocTypeDecl:
3542
 * @ctxt:  an HTML parser context
3543
 *
3544
 * parse a DOCTYPE declaration
3545
 *
3546
 * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?
3547
 *                      ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
3548
 */
3549
3550
static void
3551
0
htmlParseDocTypeDecl(htmlParserCtxtPtr ctxt) {
3552
0
    const xmlChar *name;
3553
0
    xmlChar *ExternalID = NULL;
3554
0
    xmlChar *URI = NULL;
3555
3556
    /*
3557
     * We know that '<!DOCTYPE' has been detected.
3558
     */
3559
0
    SKIP(9);
3560
3561
0
    SKIP_BLANKS;
3562
3563
    /*
3564
     * Parse the DOCTYPE name.
3565
     */
3566
0
    name = htmlParseName(ctxt);
3567
0
    if (name == NULL) {
3568
0
  htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
3569
0
               "htmlParseDocTypeDecl : no DOCTYPE name !\n",
3570
0
         NULL, NULL);
3571
0
    }
3572
    /*
3573
     * Check that upper(name) == "HTML" !!!!!!!!!!!!!
3574
     */
3575
3576
0
    SKIP_BLANKS;
3577
3578
    /*
3579
     * Check for SystemID and ExternalID
3580
     */
3581
0
    URI = htmlParseExternalID(ctxt, &ExternalID);
3582
0
    SKIP_BLANKS;
3583
3584
    /*
3585
     * We should be at the end of the DOCTYPE declaration.
3586
     */
3587
0
    if (CUR != '>') {
3588
0
  htmlParseErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED,
3589
0
               "DOCTYPE improperly terminated\n", NULL, NULL);
3590
        /* Ignore bogus content */
3591
0
        while ((CUR != 0) && (CUR != '>') &&
3592
0
               (PARSER_STOPPED(ctxt) == 0))
3593
0
            NEXT;
3594
0
    }
3595
0
    if (CUR == '>')
3596
0
        NEXT;
3597
3598
    /*
3599
     * Create or update the document accordingly to the DOCTYPE
3600
     */
3601
0
    if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
3602
0
  (!ctxt->disableSAX))
3603
0
  ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
3604
3605
    /*
3606
     * Cleanup, since we don't use all those identifiers
3607
     */
3608
0
    if (URI != NULL) xmlFree(URI);
3609
0
    if (ExternalID != NULL) xmlFree(ExternalID);
3610
0
}
3611
3612
/**
3613
 * htmlParseAttribute:
3614
 * @ctxt:  an HTML parser context
3615
 * @value:  a xmlChar ** used to store the value of the attribute
3616
 *
3617
 * parse an attribute
3618
 *
3619
 * [41] Attribute ::= Name Eq AttValue
3620
 *
3621
 * [25] Eq ::= S? '=' S?
3622
 *
3623
 * With namespace:
3624
 *
3625
 * [NS 11] Attribute ::= QName Eq AttValue
3626
 *
3627
 * Also the case QName == xmlns:??? is handled independently as a namespace
3628
 * definition.
3629
 *
3630
 * Returns the attribute name, and the value in *value.
3631
 */
3632
3633
static const xmlChar *
3634
0
htmlParseAttribute(htmlParserCtxtPtr ctxt, xmlChar **value) {
3635
0
    const xmlChar *name;
3636
0
    xmlChar *val = NULL;
3637
3638
0
    *value = NULL;
3639
0
    name = htmlParseHTMLName(ctxt);
3640
0
    if (name == NULL) {
3641
0
  htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
3642
0
               "error parsing attribute name\n", NULL, NULL);
3643
0
        return(NULL);
3644
0
    }
3645
3646
    /*
3647
     * read the value
3648
     */
3649
0
    SKIP_BLANKS;
3650
0
    if (CUR == '=') {
3651
0
        NEXT;
3652
0
  SKIP_BLANKS;
3653
0
  val = htmlParseAttValue(ctxt);
3654
0
    }
3655
3656
0
    *value = val;
3657
0
    return(name);
3658
0
}
3659
3660
/**
3661
 * htmlCheckEncoding:
3662
 * @ctxt:  an HTML parser context
3663
 * @attvalue: the attribute value
3664
 *
3665
 * Checks an http-equiv attribute from a Meta tag to detect
3666
 * the encoding
3667
 * If a new encoding is detected the parser is switched to decode
3668
 * it and pass UTF8
3669
 */
3670
static void
3671
0
htmlCheckEncoding(htmlParserCtxtPtr ctxt, const xmlChar *attvalue) {
3672
0
    const xmlChar *encoding;
3673
0
    xmlChar *copy;
3674
3675
0
    if (!attvalue)
3676
0
  return;
3677
3678
0
    encoding = xmlStrcasestr(attvalue, BAD_CAST"charset");
3679
0
    if (encoding != NULL) {
3680
0
  encoding += 7;
3681
0
    }
3682
    /*
3683
     * skip blank
3684
     */
3685
0
    if (encoding && IS_BLANK_CH(*encoding))
3686
0
  encoding = xmlStrcasestr(attvalue, BAD_CAST"=");
3687
0
    if (encoding && *encoding == '=') {
3688
0
  encoding ++;
3689
0
        copy = xmlStrdup(encoding);
3690
0
        if (copy == NULL)
3691
0
            htmlErrMemory(ctxt);
3692
0
  xmlSetDeclaredEncoding(ctxt, copy);
3693
0
    }
3694
0
}
3695
3696
/**
3697
 * htmlCheckMeta:
3698
 * @ctxt:  an HTML parser context
3699
 * @atts:  the attributes values
3700
 *
3701
 * Checks an attributes from a Meta tag
3702
 */
3703
static void
3704
0
htmlCheckMeta(htmlParserCtxtPtr ctxt, const xmlChar **atts) {
3705
0
    int i;
3706
0
    const xmlChar *att, *value;
3707
0
    int http = 0;
3708
0
    const xmlChar *content = NULL;
3709
3710
0
    if ((ctxt == NULL) || (atts == NULL))
3711
0
  return;
3712
3713
0
    i = 0;
3714
0
    att = atts[i++];
3715
0
    while (att != NULL) {
3716
0
  value = atts[i++];
3717
0
        if (value != NULL) {
3718
0
            if ((!xmlStrcasecmp(att, BAD_CAST "http-equiv")) &&
3719
0
                (!xmlStrcasecmp(value, BAD_CAST "Content-Type"))) {
3720
0
                http = 1;
3721
0
            } else if (!xmlStrcasecmp(att, BAD_CAST "charset")) {
3722
0
                xmlChar *copy;
3723
3724
0
                copy = xmlStrdup(value);
3725
0
                if (copy == NULL)
3726
0
                    htmlErrMemory(ctxt);
3727
0
                xmlSetDeclaredEncoding(ctxt, copy);
3728
0
            } else if (!xmlStrcasecmp(att, BAD_CAST "content")) {
3729
0
                content = value;
3730
0
            }
3731
0
        }
3732
0
  att = atts[i++];
3733
0
    }
3734
0
    if ((http) && (content != NULL))
3735
0
  htmlCheckEncoding(ctxt, content);
3736
3737
0
}
3738
3739
/**
3740
 * htmlParseStartTag:
3741
 * @ctxt:  an HTML parser context
3742
 *
3743
 * parse a start of tag either for rule element or
3744
 * EmptyElement. In both case we don't parse the tag closing chars.
3745
 *
3746
 * [40] STag ::= '<' Name (S Attribute)* S? '>'
3747
 *
3748
 * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
3749
 *
3750
 * With namespace:
3751
 *
3752
 * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
3753
 *
3754
 * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
3755
 *
3756
 * Returns 0 in case of success, -1 in case of error and 1 if discarded
3757
 */
3758
3759
static int
3760
0
htmlParseStartTag(htmlParserCtxtPtr ctxt) {
3761
0
    const xmlChar *name;
3762
0
    const xmlChar *attname;
3763
0
    xmlChar *attvalue;
3764
0
    const xmlChar **atts;
3765
0
    int nbatts = 0;
3766
0
    int maxatts;
3767
0
    int meta = 0;
3768
0
    int i;
3769
0
    int discardtag = 0;
3770
3771
0
    if ((ctxt == NULL) || (ctxt->input == NULL))
3772
0
  return -1;
3773
0
    if (CUR != '<') return -1;
3774
0
    NEXT;
3775
3776
0
    atts = ctxt->atts;
3777
0
    maxatts = ctxt->maxatts;
3778
3779
0
    GROW;
3780
0
    name = htmlParseHTMLName(ctxt);
3781
0
    if (name == NULL) {
3782
0
  htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
3783
0
               "htmlParseStartTag: invalid element name\n",
3784
0
         NULL, NULL);
3785
  /* Dump the bogus tag like browsers do */
3786
0
  while ((CUR != 0) && (CUR != '>') &&
3787
0
               (PARSER_STOPPED(ctxt) == 0))
3788
0
      NEXT;
3789
0
        return -1;
3790
0
    }
3791
0
    if (xmlStrEqual(name, BAD_CAST"meta"))
3792
0
  meta = 1;
3793
3794
    /*
3795
     * Check for auto-closure of HTML elements.
3796
     */
3797
0
    htmlAutoClose(ctxt, name);
3798
3799
    /*
3800
     * Check for implied HTML elements.
3801
     */
3802
0
    htmlCheckImplied(ctxt, name);
3803
3804
    /*
3805
     * Avoid html at any level > 0, head at any level != 1
3806
     * or any attempt to recurse body
3807
     */
3808
0
    if ((ctxt->nameNr > 0) && (xmlStrEqual(name, BAD_CAST"html"))) {
3809
0
  htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
3810
0
               "htmlParseStartTag: misplaced <html> tag\n",
3811
0
         name, NULL);
3812
0
  discardtag = 1;
3813
0
  ctxt->depth++;
3814
0
    }
3815
0
    if ((ctxt->nameNr != 1) &&
3816
0
  (xmlStrEqual(name, BAD_CAST"head"))) {
3817
0
  htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
3818
0
               "htmlParseStartTag: misplaced <head> tag\n",
3819
0
         name, NULL);
3820
0
  discardtag = 1;
3821
0
  ctxt->depth++;
3822
0
    }
3823
0
    if (xmlStrEqual(name, BAD_CAST"body")) {
3824
0
  int indx;
3825
0
  for (indx = 0;indx < ctxt->nameNr;indx++) {
3826
0
      if (xmlStrEqual(ctxt->nameTab[indx], BAD_CAST"body")) {
3827
0
    htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
3828
0
                 "htmlParseStartTag: misplaced <body> tag\n",
3829
0
           name, NULL);
3830
0
    discardtag = 1;
3831
0
    ctxt->depth++;
3832
0
      }
3833
0
  }
3834
0
    }
3835
3836
    /*
3837
     * Now parse the attributes, it ends up with the ending
3838
     *
3839
     * (S Attribute)* S?
3840
     */
3841
0
    SKIP_BLANKS;
3842
0
    while ((CUR != 0) &&
3843
0
           (CUR != '>') &&
3844
0
     ((CUR != '/') || (NXT(1) != '>')) &&
3845
0
           (PARSER_STOPPED(ctxt) == 0)) {
3846
0
  GROW;
3847
0
  attname = htmlParseAttribute(ctxt, &attvalue);
3848
0
        if (attname != NULL) {
3849
3850
      /*
3851
       * Well formedness requires at most one declaration of an attribute
3852
       */
3853
0
      for (i = 0; i < nbatts;i += 2) {
3854
0
          if (xmlStrEqual(atts[i], attname)) {
3855
0
        htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_REDEFINED,
3856
0
                     "Attribute %s redefined\n", attname, NULL);
3857
0
        if (attvalue != NULL)
3858
0
      xmlFree(attvalue);
3859
0
        goto failed;
3860
0
    }
3861
0
      }
3862
3863
      /*
3864
       * Add the pair to atts
3865
       */
3866
0
      if (atts == NULL) {
3867
0
          maxatts = 22; /* allow for 10 attrs by default */
3868
0
          atts = (const xmlChar **)
3869
0
           xmlMalloc(maxatts * sizeof(xmlChar *));
3870
0
    if (atts == NULL) {
3871
0
        htmlErrMemory(ctxt);
3872
0
        if (attvalue != NULL)
3873
0
      xmlFree(attvalue);
3874
0
        goto failed;
3875
0
    }
3876
0
    ctxt->atts = atts;
3877
0
    ctxt->maxatts = maxatts;
3878
0
      } else if (nbatts + 4 > maxatts) {
3879
0
          const xmlChar **n;
3880
3881
0
          maxatts *= 2;
3882
0
          n = (const xmlChar **) xmlRealloc((void *) atts,
3883
0
               maxatts * sizeof(const xmlChar *));
3884
0
    if (n == NULL) {
3885
0
        htmlErrMemory(ctxt);
3886
0
        if (attvalue != NULL)
3887
0
      xmlFree(attvalue);
3888
0
        goto failed;
3889
0
    }
3890
0
    atts = n;
3891
0
    ctxt->atts = atts;
3892
0
    ctxt->maxatts = maxatts;
3893
0
      }
3894
0
      atts[nbatts++] = attname;
3895
0
      atts[nbatts++] = attvalue;
3896
0
      atts[nbatts] = NULL;
3897
0
      atts[nbatts + 1] = NULL;
3898
0
  }
3899
0
  else {
3900
0
      if (attvalue != NULL)
3901
0
          xmlFree(attvalue);
3902
      /* Dump the bogus attribute string up to the next blank or
3903
       * the end of the tag. */
3904
0
      while ((CUR != 0) &&
3905
0
             !(IS_BLANK_CH(CUR)) && (CUR != '>') &&
3906
0
       ((CUR != '/') || (NXT(1) != '>')) &&
3907
0
                   (PARSER_STOPPED(ctxt) == 0))
3908
0
    NEXT;
3909
0
  }
3910
3911
0
failed:
3912
0
  SKIP_BLANKS;
3913
0
    }
3914
3915
    /*
3916
     * Handle specific association to the META tag
3917
     */
3918
0
    if (meta && (nbatts != 0))
3919
0
  htmlCheckMeta(ctxt, atts);
3920
3921
    /*
3922
     * SAX: Start of Element !
3923
     */
3924
0
    if (!discardtag) {
3925
0
  htmlnamePush(ctxt, name);
3926
0
  if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL)) {
3927
0
      if (nbatts != 0)
3928
0
    ctxt->sax->startElement(ctxt->userData, name, atts);
3929
0
      else
3930
0
    ctxt->sax->startElement(ctxt->userData, name, NULL);
3931
0
  }
3932
0
    }
3933
3934
0
    if (atts != NULL) {
3935
0
        for (i = 1;i < nbatts;i += 2) {
3936
0
      if (atts[i] != NULL)
3937
0
    xmlFree((xmlChar *) atts[i]);
3938
0
  }
3939
0
    }
3940
3941
0
    return(discardtag);
3942
0
}
3943
3944
/**
3945
 * htmlParseEndTag:
3946
 * @ctxt:  an HTML parser context
3947
 *
3948
 * parse an end of tag
3949
 *
3950
 * [42] ETag ::= '</' Name S? '>'
3951
 *
3952
 * With namespace
3953
 *
3954
 * [NS 9] ETag ::= '</' QName S? '>'
3955
 *
3956
 * Returns 1 if the current level should be closed.
3957
 */
3958
3959
static int
3960
htmlParseEndTag(htmlParserCtxtPtr ctxt)
3961
0
{
3962
0
    const xmlChar *name;
3963
0
    const xmlChar *oldname;
3964
0
    int i, ret;
3965
3966
0
    if ((CUR != '<') || (NXT(1) != '/')) {
3967
0
        htmlParseErr(ctxt, XML_ERR_LTSLASH_REQUIRED,
3968
0
               "htmlParseEndTag: '</' not found\n", NULL, NULL);
3969
0
        return (0);
3970
0
    }
3971
0
    SKIP(2);
3972
3973
0
    name = htmlParseHTMLName(ctxt);
3974
0
    if (name == NULL)
3975
0
        return (0);
3976
    /*
3977
     * We should definitely be at the ending "S? '>'" part
3978
     */
3979
0
    SKIP_BLANKS;
3980
0
    if (CUR != '>') {
3981
0
        htmlParseErr(ctxt, XML_ERR_GT_REQUIRED,
3982
0
               "End tag : expected '>'\n", NULL, NULL);
3983
        /* Skip to next '>' */
3984
0
        while ((PARSER_STOPPED(ctxt) == 0) &&
3985
0
               (CUR != 0) && (CUR != '>'))
3986
0
            NEXT;
3987
0
    }
3988
0
    if (CUR == '>')
3989
0
        NEXT;
3990
3991
    /*
3992
     * if we ignored misplaced tags in htmlParseStartTag don't pop them
3993
     * out now.
3994
     */
3995
0
    if ((ctxt->depth > 0) &&
3996
0
        (xmlStrEqual(name, BAD_CAST "html") ||
3997
0
         xmlStrEqual(name, BAD_CAST "body") ||
3998
0
   xmlStrEqual(name, BAD_CAST "head"))) {
3999
0
  ctxt->depth--;
4000
0
  return (0);
4001
0
    }
4002
4003
    /*
4004
     * If the name read is not one of the element in the parsing stack
4005
     * then return, it's just an error.
4006
     */
4007
0
    for (i = (ctxt->nameNr - 1); i >= 0; i--) {
4008
0
        if (xmlStrEqual(name, ctxt->nameTab[i]))
4009
0
            break;
4010
0
    }
4011
0
    if (i < 0) {
4012
0
        htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
4013
0
               "Unexpected end tag : %s\n", name, NULL);
4014
0
        return (0);
4015
0
    }
4016
4017
4018
    /*
4019
     * Check for auto-closure of HTML elements.
4020
     */
4021
4022
0
    htmlAutoCloseOnClose(ctxt, name);
4023
4024
    /*
4025
     * Well formedness constraints, opening and closing must match.
4026
     * With the exception that the autoclose may have popped stuff out
4027
     * of the stack.
4028
     */
4029
0
    if ((ctxt->name != NULL) && (!xmlStrEqual(ctxt->name, name))) {
4030
0
        htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
4031
0
                     "Opening and ending tag mismatch: %s and %s\n",
4032
0
                     name, ctxt->name);
4033
0
    }
4034
4035
    /*
4036
     * SAX: End of Tag
4037
     */
4038
0
    oldname = ctxt->name;
4039
0
    if ((oldname != NULL) && (xmlStrEqual(oldname, name))) {
4040
0
        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
4041
0
            ctxt->sax->endElement(ctxt->userData, name);
4042
0
  htmlNodeInfoPop(ctxt);
4043
0
        htmlnamePop(ctxt);
4044
0
        ret = 1;
4045
0
    } else {
4046
0
        ret = 0;
4047
0
    }
4048
4049
0
    return (ret);
4050
0
}
4051
4052
4053
/**
4054
 * htmlParseReference:
4055
 * @ctxt:  an HTML parser context
4056
 *
4057
 * parse and handle entity references in content,
4058
 * this will end-up in a call to character() since this is either a
4059
 * CharRef, or a predefined entity.
4060
 */
4061
static void
4062
0
htmlParseReference(htmlParserCtxtPtr ctxt) {
4063
0
    const htmlEntityDesc * ent;
4064
0
    xmlChar out[6];
4065
0
    const xmlChar *name;
4066
0
    if (CUR != '&') return;
4067
4068
0
    if (NXT(1) == '#') {
4069
0
  unsigned int c;
4070
0
  int bits, i = 0;
4071
4072
0
  c = htmlParseCharRef(ctxt);
4073
0
  if (c == 0)
4074
0
      return;
4075
4076
0
        if      (c <    0x80) { out[i++]= c;                bits= -6; }
4077
0
        else if (c <   0x800) { out[i++]=((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
4078
0
        else if (c < 0x10000) { out[i++]=((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
4079
0
        else                  { out[i++]=((c >> 18) & 0x07) | 0xF0;  bits= 12; }
4080
4081
0
        for ( ; bits >= 0; bits-= 6) {
4082
0
            out[i++]= ((c >> bits) & 0x3F) | 0x80;
4083
0
        }
4084
0
  out[i] = 0;
4085
4086
0
  htmlCheckParagraph(ctxt);
4087
0
  if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
4088
0
      ctxt->sax->characters(ctxt->userData, out, i);
4089
0
    } else {
4090
0
  ent = htmlParseEntityRef(ctxt, &name);
4091
0
  if (name == NULL) {
4092
0
      htmlCheckParagraph(ctxt);
4093
0
      if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
4094
0
          ctxt->sax->characters(ctxt->userData, BAD_CAST "&", 1);
4095
0
      return;
4096
0
  }
4097
0
  if ((ent == NULL) || !(ent->value > 0)) {
4098
0
      htmlCheckParagraph(ctxt);
4099
0
      if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL)) {
4100
0
    ctxt->sax->characters(ctxt->userData, BAD_CAST "&", 1);
4101
0
    ctxt->sax->characters(ctxt->userData, name, xmlStrlen(name));
4102
    /* ctxt->sax->characters(ctxt->userData, BAD_CAST ";", 1); */
4103
0
      }
4104
0
  } else {
4105
0
      unsigned int c;
4106
0
      int bits, i = 0;
4107
4108
0
      c = ent->value;
4109
0
      if      (c <    0x80)
4110
0
              { out[i++]= c;                bits= -6; }
4111
0
      else if (c <   0x800)
4112
0
              { out[i++]=((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
4113
0
      else if (c < 0x10000)
4114
0
              { out[i++]=((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
4115
0
      else
4116
0
              { out[i++]=((c >> 18) & 0x07) | 0xF0;  bits= 12; }
4117
4118
0
      for ( ; bits >= 0; bits-= 6) {
4119
0
    out[i++]= ((c >> bits) & 0x3F) | 0x80;
4120
0
      }
4121
0
      out[i] = 0;
4122
4123
0
      htmlCheckParagraph(ctxt);
4124
0
      if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
4125
0
    ctxt->sax->characters(ctxt->userData, out, i);
4126
0
  }
4127
0
    }
4128
0
}
4129
4130
/**
4131
 * htmlParseContent:
4132
 * @ctxt:  an HTML parser context
4133
 *
4134
 * Parse a content: comment, sub-element, reference or text.
4135
 * Kept for compatibility with old code
4136
 */
4137
4138
static void
4139
0
htmlParseContent(htmlParserCtxtPtr ctxt) {
4140
0
    xmlChar *currentNode;
4141
0
    int depth;
4142
0
    const xmlChar *name;
4143
4144
0
    currentNode = xmlStrdup(ctxt->name);
4145
0
    depth = ctxt->nameNr;
4146
0
    while (!PARSER_STOPPED(ctxt)) {
4147
0
        GROW;
4148
4149
  /*
4150
   * Our tag or one of it's parent or children is ending.
4151
   */
4152
0
        if ((CUR == '<') && (NXT(1) == '/')) {
4153
0
      if (htmlParseEndTag(ctxt) &&
4154
0
    ((currentNode != NULL) || (ctxt->nameNr == 0))) {
4155
0
    if (currentNode != NULL)
4156
0
        xmlFree(currentNode);
4157
0
    return;
4158
0
      }
4159
0
      continue; /* while */
4160
0
        }
4161
4162
0
  else if ((CUR == '<') &&
4163
0
           ((IS_ASCII_LETTER(NXT(1))) ||
4164
0
      (NXT(1) == '_') || (NXT(1) == ':'))) {
4165
0
      name = htmlParseHTMLName_nonInvasive(ctxt);
4166
0
      if (name == NULL) {
4167
0
          htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
4168
0
       "htmlParseStartTag: invalid element name\n",
4169
0
       NULL, NULL);
4170
          /* Dump the bogus tag like browsers do */
4171
0
                while ((CUR != 0) && (CUR != '>'))
4172
0
              NEXT;
4173
4174
0
          if (currentNode != NULL)
4175
0
              xmlFree(currentNode);
4176
0
          return;
4177
0
      }
4178
4179
0
      if (ctxt->name != NULL) {
4180
0
          if (htmlCheckAutoClose(name, ctxt->name) == 1) {
4181
0
              htmlAutoClose(ctxt, name);
4182
0
              continue;
4183
0
          }
4184
0
      }
4185
0
  }
4186
4187
  /*
4188
   * Has this node been popped out during parsing of
4189
   * the next element
4190
   */
4191
0
        if ((ctxt->nameNr > 0) && (depth >= ctxt->nameNr) &&
4192
0
      (!xmlStrEqual(currentNode, ctxt->name)))
4193
0
       {
4194
0
      if (currentNode != NULL) xmlFree(currentNode);
4195
0
      return;
4196
0
  }
4197
4198
0
  if ((CUR != 0) && ((xmlStrEqual(currentNode, BAD_CAST"script")) ||
4199
0
      (xmlStrEqual(currentNode, BAD_CAST"style")))) {
4200
      /*
4201
       * Handle SCRIPT/STYLE separately
4202
       */
4203
0
      htmlParseScript(ctxt);
4204
0
  }
4205
4206
0
        else if ((CUR == '<') && (NXT(1) == '!')) {
4207
            /*
4208
             * Sometimes DOCTYPE arrives in the middle of the document
4209
             */
4210
0
            if ((UPP(2) == 'D') && (UPP(3) == 'O') &&
4211
0
                (UPP(4) == 'C') && (UPP(5) == 'T') &&
4212
0
                (UPP(6) == 'Y') && (UPP(7) == 'P') &&
4213
0
                (UPP(8) == 'E')) {
4214
0
                htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
4215
0
                             "Misplaced DOCTYPE declaration\n",
4216
0
                             BAD_CAST "DOCTYPE" , NULL);
4217
0
                htmlParseDocTypeDecl(ctxt);
4218
0
            }
4219
            /*
4220
             * First case :  a comment
4221
             */
4222
0
            else if ((NXT(2) == '-') && (NXT(3) == '-')) {
4223
0
                htmlParseComment(ctxt);
4224
0
            }
4225
0
            else {
4226
0
                htmlSkipBogusComment(ctxt);
4227
0
            }
4228
0
        }
4229
4230
        /*
4231
         * Second case : a Processing Instruction.
4232
         */
4233
0
        else if ((CUR == '<') && (NXT(1) == '?')) {
4234
0
            htmlParsePI(ctxt);
4235
0
        }
4236
4237
        /*
4238
         * Third case :  a sub-element.
4239
         */
4240
0
        else if ((CUR == '<') && IS_ASCII_LETTER(NXT(1))) {
4241
0
            htmlParseElement(ctxt);
4242
0
        }
4243
0
        else if (CUR == '<') {
4244
0
            if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
4245
0
                (ctxt->sax->characters != NULL))
4246
0
                ctxt->sax->characters(ctxt->userData, BAD_CAST "<", 1);
4247
0
            NEXT;
4248
0
        }
4249
4250
        /*
4251
         * Fourth case : a reference. If if has not been resolved,
4252
         *    parsing returns it's Name, create the node
4253
         */
4254
0
        else if (CUR == '&') {
4255
0
            htmlParseReference(ctxt);
4256
0
        }
4257
4258
        /*
4259
         * Fifth case : end of the resource
4260
         */
4261
0
        else if (CUR == 0) {
4262
0
            htmlAutoCloseOnEnd(ctxt);
4263
0
            break;
4264
0
        }
4265
4266
        /*
4267
         * Last case, text. Note that References are handled directly.
4268
         */
4269
0
        else {
4270
0
            htmlParseCharData(ctxt);
4271
0
        }
4272
4273
0
        SHRINK;
4274
0
        GROW;
4275
0
    }
4276
0
    if (currentNode != NULL) xmlFree(currentNode);
4277
0
}
4278
4279
/**
4280
 * htmlParseElement:
4281
 * @ctxt:  an HTML parser context
4282
 *
4283
 * DEPRECATED: Internal function, don't use.
4284
 *
4285
 * parse an HTML element, this is highly recursive
4286
 * this is kept for compatibility with previous code versions
4287
 *
4288
 * [39] element ::= EmptyElemTag | STag content ETag
4289
 *
4290
 * [41] Attribute ::= Name Eq AttValue
4291
 */
4292
4293
void
4294
0
htmlParseElement(htmlParserCtxtPtr ctxt) {
4295
0
    const xmlChar *name;
4296
0
    xmlChar *currentNode = NULL;
4297
0
    const htmlElemDesc * info;
4298
0
    htmlParserNodeInfo node_info;
4299
0
    int failed;
4300
0
    int depth;
4301
0
    const xmlChar *oldptr;
4302
4303
0
    if ((ctxt == NULL) || (ctxt->input == NULL))
4304
0
  return;
4305
4306
    /* Capture start position */
4307
0
    if (ctxt->record_info) {
4308
0
        node_info.begin_pos = ctxt->input->consumed +
4309
0
                          (CUR_PTR - ctxt->input->base);
4310
0
  node_info.begin_line = ctxt->input->line;
4311
0
    }
4312
4313
0
    failed = htmlParseStartTag(ctxt);
4314
0
    name = ctxt->name;
4315
0
    if ((failed == -1) || (name == NULL)) {
4316
0
  if (CUR == '>')
4317
0
      NEXT;
4318
0
        return;
4319
0
    }
4320
4321
    /*
4322
     * Lookup the info for that element.
4323
     */
4324
0
    info = htmlTagLookup(name);
4325
0
    if (info == NULL) {
4326
0
  htmlParseErr(ctxt, XML_HTML_UNKNOWN_TAG,
4327
0
               "Tag %s invalid\n", name, NULL);
4328
0
    }
4329
4330
    /*
4331
     * Check for an Empty Element labeled the XML/SGML way
4332
     */
4333
0
    if ((CUR == '/') && (NXT(1) == '>')) {
4334
0
        SKIP(2);
4335
0
  if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
4336
0
      ctxt->sax->endElement(ctxt->userData, name);
4337
0
  htmlnamePop(ctxt);
4338
0
  return;
4339
0
    }
4340
4341
0
    if (CUR == '>') {
4342
0
        NEXT;
4343
0
    } else {
4344
0
  htmlParseErr(ctxt, XML_ERR_GT_REQUIRED,
4345
0
               "Couldn't find end of Start Tag %s\n", name, NULL);
4346
4347
  /*
4348
   * end of parsing of this node.
4349
   */
4350
0
  if (xmlStrEqual(name, ctxt->name)) {
4351
0
      nodePop(ctxt);
4352
0
      htmlnamePop(ctxt);
4353
0
  }
4354
4355
  /*
4356
   * Capture end position and add node
4357
   */
4358
0
  if (ctxt->record_info) {
4359
0
     node_info.end_pos = ctxt->input->consumed +
4360
0
            (CUR_PTR - ctxt->input->base);
4361
0
     node_info.end_line = ctxt->input->line;
4362
0
     node_info.node = ctxt->node;
4363
0
     xmlParserAddNodeInfo(ctxt, &node_info);
4364
0
  }
4365
0
  return;
4366
0
    }
4367
4368
    /*
4369
     * Check for an Empty Element from DTD definition
4370
     */
4371
0
    if ((info != NULL) && (info->empty)) {
4372
0
  if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
4373
0
      ctxt->sax->endElement(ctxt->userData, name);
4374
0
  htmlnamePop(ctxt);
4375
0
  return;
4376
0
    }
4377
4378
    /*
4379
     * Parse the content of the element:
4380
     */
4381
0
    currentNode = xmlStrdup(ctxt->name);
4382
0
    depth = ctxt->nameNr;
4383
0
    while (CUR != 0) {
4384
0
  oldptr = ctxt->input->cur;
4385
0
  htmlParseContent(ctxt);
4386
0
  if (oldptr==ctxt->input->cur) break;
4387
0
  if (ctxt->nameNr < depth) break;
4388
0
    }
4389
4390
    /*
4391
     * Capture end position and add node
4392
     */
4393
0
    if ( currentNode != NULL && ctxt->record_info ) {
4394
0
       node_info.end_pos = ctxt->input->consumed +
4395
0
                          (CUR_PTR - ctxt->input->base);
4396
0
       node_info.end_line = ctxt->input->line;
4397
0
       node_info.node = ctxt->node;
4398
0
       xmlParserAddNodeInfo(ctxt, &node_info);
4399
0
    }
4400
0
    if (CUR == 0) {
4401
0
  htmlAutoCloseOnEnd(ctxt);
4402
0
    }
4403
4404
0
    if (currentNode != NULL)
4405
0
  xmlFree(currentNode);
4406
0
}
4407
4408
static void
4409
0
htmlParserFinishElementParsing(htmlParserCtxtPtr ctxt) {
4410
    /*
4411
     * Capture end position and add node
4412
     */
4413
0
    if ( ctxt->node != NULL && ctxt->record_info ) {
4414
0
       ctxt->nodeInfo->end_pos = ctxt->input->consumed +
4415
0
                                (CUR_PTR - ctxt->input->base);
4416
0
       ctxt->nodeInfo->end_line = ctxt->input->line;
4417
0
       ctxt->nodeInfo->node = ctxt->node;
4418
0
       xmlParserAddNodeInfo(ctxt, ctxt->nodeInfo);
4419
0
       htmlNodeInfoPop(ctxt);
4420
0
    }
4421
0
    if (CUR == 0) {
4422
0
       htmlAutoCloseOnEnd(ctxt);
4423
0
    }
4424
0
}
4425
4426
/**
4427
 * htmlParseElementInternal:
4428
 * @ctxt:  an HTML parser context
4429
 *
4430
 * parse an HTML element, new version, non recursive
4431
 *
4432
 * [39] element ::= EmptyElemTag | STag content ETag
4433
 *
4434
 * [41] Attribute ::= Name Eq AttValue
4435
 */
4436
4437
static void
4438
0
htmlParseElementInternal(htmlParserCtxtPtr ctxt) {
4439
0
    const xmlChar *name;
4440
0
    const htmlElemDesc * info;
4441
0
    htmlParserNodeInfo node_info = { NULL, 0, 0, 0, 0 };
4442
0
    int failed;
4443
4444
0
    if ((ctxt == NULL) || (ctxt->input == NULL))
4445
0
  return;
4446
4447
    /* Capture start position */
4448
0
    if (ctxt->record_info) {
4449
0
        node_info.begin_pos = ctxt->input->consumed +
4450
0
                          (CUR_PTR - ctxt->input->base);
4451
0
  node_info.begin_line = ctxt->input->line;
4452
0
    }
4453
4454
0
    failed = htmlParseStartTag(ctxt);
4455
0
    name = ctxt->name;
4456
0
    if ((failed == -1) || (name == NULL)) {
4457
0
  if (CUR == '>')
4458
0
      NEXT;
4459
0
        return;
4460
0
    }
4461
4462
    /*
4463
     * Lookup the info for that element.
4464
     */
4465
0
    info = htmlTagLookup(name);
4466
0
    if (info == NULL) {
4467
0
  htmlParseErr(ctxt, XML_HTML_UNKNOWN_TAG,
4468
0
               "Tag %s invalid\n", name, NULL);
4469
0
    }
4470
4471
    /*
4472
     * Check for an Empty Element labeled the XML/SGML way
4473
     */
4474
0
    if ((CUR == '/') && (NXT(1) == '>')) {
4475
0
        SKIP(2);
4476
0
  if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
4477
0
      ctxt->sax->endElement(ctxt->userData, name);
4478
0
  htmlnamePop(ctxt);
4479
0
  return;
4480
0
    }
4481
4482
0
    if (CUR == '>') {
4483
0
        NEXT;
4484
0
    } else {
4485
0
  htmlParseErr(ctxt, XML_ERR_GT_REQUIRED,
4486
0
               "Couldn't find end of Start Tag %s\n", name, NULL);
4487
4488
  /*
4489
   * end of parsing of this node.
4490
   */
4491
0
  if (xmlStrEqual(name, ctxt->name)) {
4492
0
      nodePop(ctxt);
4493
0
      htmlnamePop(ctxt);
4494
0
  }
4495
4496
0
        if (ctxt->record_info)
4497
0
            htmlNodeInfoPush(ctxt, &node_info);
4498
0
        htmlParserFinishElementParsing(ctxt);
4499
0
  return;
4500
0
    }
4501
4502
    /*
4503
     * Check for an Empty Element from DTD definition
4504
     */
4505
0
    if ((info != NULL) && (info->empty)) {
4506
0
  if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
4507
0
      ctxt->sax->endElement(ctxt->userData, name);
4508
0
  htmlnamePop(ctxt);
4509
0
  return;
4510
0
    }
4511
4512
0
    if (ctxt->record_info)
4513
0
        htmlNodeInfoPush(ctxt, &node_info);
4514
0
}
4515
4516
/**
4517
 * htmlParseContentInternal:
4518
 * @ctxt:  an HTML parser context
4519
 *
4520
 * Parse a content: comment, sub-element, reference or text.
4521
 * New version for non recursive htmlParseElementInternal
4522
 */
4523
4524
static void
4525
0
htmlParseContentInternal(htmlParserCtxtPtr ctxt) {
4526
0
    xmlChar *currentNode;
4527
0
    int depth;
4528
0
    const xmlChar *name;
4529
4530
0
    depth = ctxt->nameNr;
4531
0
    if (depth <= 0) {
4532
0
        currentNode = NULL;
4533
0
    } else {
4534
0
        currentNode = xmlStrdup(ctxt->name);
4535
0
        if (currentNode == NULL) {
4536
0
            htmlErrMemory(ctxt);
4537
0
            return;
4538
0
        }
4539
0
    }
4540
0
    while (PARSER_STOPPED(ctxt) == 0) {
4541
0
        GROW;
4542
4543
  /*
4544
   * Our tag or one of it's parent or children is ending.
4545
   */
4546
0
        if ((CUR == '<') && (NXT(1) == '/')) {
4547
0
      if (htmlParseEndTag(ctxt) &&
4548
0
    ((currentNode != NULL) || (ctxt->nameNr == 0))) {
4549
0
    if (currentNode != NULL)
4550
0
        xmlFree(currentNode);
4551
4552
0
          depth = ctxt->nameNr;
4553
0
                if (depth <= 0) {
4554
0
                    currentNode = NULL;
4555
0
                } else {
4556
0
                    currentNode = xmlStrdup(ctxt->name);
4557
0
                    if (currentNode == NULL) {
4558
0
                        htmlErrMemory(ctxt);
4559
0
                        break;
4560
0
                    }
4561
0
                }
4562
0
      }
4563
0
      continue; /* while */
4564
0
        }
4565
4566
0
  else if ((CUR == '<') &&
4567
0
           ((IS_ASCII_LETTER(NXT(1))) ||
4568
0
      (NXT(1) == '_') || (NXT(1) == ':'))) {
4569
0
      name = htmlParseHTMLName_nonInvasive(ctxt);
4570
0
      if (name == NULL) {
4571
0
          htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
4572
0
       "htmlParseStartTag: invalid element name\n",
4573
0
       NULL, NULL);
4574
          /* Dump the bogus tag like browsers do */
4575
0
          while ((CUR == 0) && (CUR != '>'))
4576
0
              NEXT;
4577
4578
0
          htmlParserFinishElementParsing(ctxt);
4579
0
          if (currentNode != NULL)
4580
0
              xmlFree(currentNode);
4581
4582
0
                if (ctxt->name == NULL) {
4583
0
                    currentNode = NULL;
4584
0
                } else {
4585
0
                    currentNode = xmlStrdup(ctxt->name);
4586
0
                    if (currentNode == NULL) {
4587
0
                        htmlErrMemory(ctxt);
4588
0
                        break;
4589
0
                    }
4590
0
                }
4591
0
          depth = ctxt->nameNr;
4592
0
          continue;
4593
0
      }
4594
4595
0
      if (ctxt->name != NULL) {
4596
0
          if (htmlCheckAutoClose(name, ctxt->name) == 1) {
4597
0
              htmlAutoClose(ctxt, name);
4598
0
              continue;
4599
0
          }
4600
0
      }
4601
0
  }
4602
4603
  /*
4604
   * Has this node been popped out during parsing of
4605
   * the next element
4606
   */
4607
0
        if ((ctxt->nameNr > 0) && (depth >= ctxt->nameNr) &&
4608
0
      (!xmlStrEqual(currentNode, ctxt->name)))
4609
0
       {
4610
0
      htmlParserFinishElementParsing(ctxt);
4611
0
      if (currentNode != NULL) xmlFree(currentNode);
4612
4613
0
            if (ctxt->name == NULL) {
4614
0
                currentNode = NULL;
4615
0
            } else {
4616
0
                currentNode = xmlStrdup(ctxt->name);
4617
0
                if (currentNode == NULL) {
4618
0
                    htmlErrMemory(ctxt);
4619
0
                    break;
4620
0
                }
4621
0
            }
4622
0
      depth = ctxt->nameNr;
4623
0
      continue;
4624
0
  }
4625
4626
0
  if ((CUR != 0) && ((xmlStrEqual(currentNode, BAD_CAST"script")) ||
4627
0
      (xmlStrEqual(currentNode, BAD_CAST"style")))) {
4628
      /*
4629
       * Handle SCRIPT/STYLE separately
4630
       */
4631
0
      htmlParseScript(ctxt);
4632
0
  }
4633
4634
0
        else if ((CUR == '<') && (NXT(1) == '!')) {
4635
            /*
4636
             * Sometimes DOCTYPE arrives in the middle of the document
4637
             */
4638
0
            if ((UPP(2) == 'D') && (UPP(3) == 'O') &&
4639
0
                (UPP(4) == 'C') && (UPP(5) == 'T') &&
4640
0
                (UPP(6) == 'Y') && (UPP(7) == 'P') &&
4641
0
                (UPP(8) == 'E')) {
4642
0
                htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
4643
0
                             "Misplaced DOCTYPE declaration\n",
4644
0
                             BAD_CAST "DOCTYPE" , NULL);
4645
0
                htmlParseDocTypeDecl(ctxt);
4646
0
            }
4647
            /*
4648
             * First case :  a comment
4649
             */
4650
0
            else if ((NXT(2) == '-') && (NXT(3) == '-')) {
4651
0
                htmlParseComment(ctxt);
4652
0
            }
4653
0
            else {
4654
0
                htmlSkipBogusComment(ctxt);
4655
0
            }
4656
0
        }
4657
4658
        /*
4659
         * Second case : a Processing Instruction.
4660
         */
4661
0
        else if ((CUR == '<') && (NXT(1) == '?')) {
4662
0
            htmlParsePI(ctxt);
4663
0
        }
4664
4665
        /*
4666
         * Third case :  a sub-element.
4667
         */
4668
0
        else if ((CUR == '<') && IS_ASCII_LETTER(NXT(1))) {
4669
0
            htmlParseElementInternal(ctxt);
4670
0
            if (currentNode != NULL) xmlFree(currentNode);
4671
4672
0
            if (ctxt->name == NULL) {
4673
0
                currentNode = NULL;
4674
0
            } else {
4675
0
                currentNode = xmlStrdup(ctxt->name);
4676
0
                if (currentNode == NULL) {
4677
0
                    htmlErrMemory(ctxt);
4678
0
                    break;
4679
0
                }
4680
0
            }
4681
0
            depth = ctxt->nameNr;
4682
0
        }
4683
0
        else if (CUR == '<') {
4684
0
            if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
4685
0
                (ctxt->sax->characters != NULL))
4686
0
                ctxt->sax->characters(ctxt->userData, BAD_CAST "<", 1);
4687
0
            NEXT;
4688
0
        }
4689
4690
        /*
4691
         * Fourth case : a reference. If if has not been resolved,
4692
         *    parsing returns it's Name, create the node
4693
         */
4694
0
        else if (CUR == '&') {
4695
0
            htmlParseReference(ctxt);
4696
0
        }
4697
4698
        /*
4699
         * Fifth case : end of the resource
4700
         */
4701
0
        else if (CUR == 0) {
4702
0
            htmlAutoCloseOnEnd(ctxt);
4703
0
            break;
4704
0
        }
4705
4706
        /*
4707
         * Last case, text. Note that References are handled directly.
4708
         */
4709
0
        else {
4710
0
            htmlParseCharData(ctxt);
4711
0
        }
4712
4713
0
        SHRINK;
4714
0
        GROW;
4715
0
    }
4716
0
    if (currentNode != NULL) xmlFree(currentNode);
4717
0
}
4718
4719
/**
4720
 * htmlParseContent:
4721
 * @ctxt:  an HTML parser context
4722
 *
4723
 * Parse a content: comment, sub-element, reference or text.
4724
 * This is the entry point when called from parser.c
4725
 */
4726
4727
void
4728
0
__htmlParseContent(void *ctxt) {
4729
0
    if (ctxt != NULL)
4730
0
  htmlParseContentInternal((htmlParserCtxtPtr) ctxt);
4731
0
}
4732
4733
/**
4734
 * htmlParseDocument:
4735
 * @ctxt:  an HTML parser context
4736
 *
4737
 * Parse an HTML document and invoke the SAX handlers. This is useful
4738
 * if you're only interested in custom SAX callbacks. If you want a
4739
 * document tree, use htmlCtxtParseDocument.
4740
 *
4741
 * Returns 0, -1 in case of error.
4742
 */
4743
4744
int
4745
0
htmlParseDocument(htmlParserCtxtPtr ctxt) {
4746
0
    xmlDtdPtr dtd;
4747