Coverage Report

Created: 2026-11-20 06:20

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/libxml2/parser.c
Line
Count
Source
1
/*
2
 * parser.c : an XML 1.0 parser, namespaces and validity support are mostly
3
 *            implemented on top of the SAX interfaces
4
 *
5
 * References:
6
 *   The XML specification:
7
 *     http://www.w3.org/TR/REC-xml
8
 *   Original 1.0 version:
9
 *     http://www.w3.org/TR/1998/REC-xml-19980210
10
 *   XML second edition working draft
11
 *     http://www.w3.org/TR/2000/WD-xml-2e-20000814
12
 *
13
 * Okay this is a big file, the parser core is around 7000 lines, then it
14
 * is followed by the progressive parser top routines, then the various
15
 * high level APIs to call the parser and a few miscellaneous functions.
16
 * A number of helper functions and deprecated ones have been moved to
17
 * parserInternals.c to reduce this file size.
18
 * As much as possible the functions are associated with their relative
19
 * production in the XML specification. A few productions defining the
20
 * different ranges of character are actually implanted either in
21
 * parserInternals.h or parserInternals.c
22
 * The DOM tree build is realized from the default SAX callbacks in
23
 * the module SAX2.c.
24
 * The routines doing the validation checks are in valid.c and called either
25
 * from the SAX callbacks or as standalone functions using a preparsed
26
 * document.
27
 *
28
 * See Copyright for the status of this software.
29
 *
30
 * daniel@veillard.com
31
 */
32
33
/* To avoid EBCDIC trouble when parsing on zOS */
34
#if defined(__MVS__)
35
#pragma convert("ISO8859-1")
36
#endif
37
38
#define IN_LIBXML
39
#include "libxml.h"
40
41
#if defined(_WIN32)
42
#define XML_DIR_SEP '\\'
43
#else
44
#define XML_DIR_SEP '/'
45
#endif
46
47
#include <stdlib.h>
48
#include <limits.h>
49
#include <string.h>
50
#include <stdarg.h>
51
#include <stddef.h>
52
#include <ctype.h>
53
#include <stdlib.h>
54
#include <libxml/parser.h>
55
#include <libxml/xmlmemory.h>
56
#include <libxml/tree.h>
57
#include <libxml/parserInternals.h>
58
#include <libxml/valid.h>
59
#include <libxml/entities.h>
60
#include <libxml/xmlerror.h>
61
#include <libxml/encoding.h>
62
#include <libxml/xmlIO.h>
63
#include <libxml/uri.h>
64
#include <libxml/SAX2.h>
65
#include <libxml/HTMLparser.h>
66
#ifdef LIBXML_CATALOG_ENABLED
67
#include <libxml/catalog.h>
68
#endif
69
70
#include "private/buf.h"
71
#include "private/dict.h"
72
#include "private/entities.h"
73
#include "private/error.h"
74
#include "private/html.h"
75
#include "private/io.h"
76
#include "private/memory.h"
77
#include "private/parser.h"
78
79
2.40M
#define NS_INDEX_EMPTY  INT_MAX
80
150k
#define NS_INDEX_XML    (INT_MAX - 1)
81
1.32M
#define URI_HASH_EMPTY  0xD943A04E
82
107k
#define URI_HASH_XML    0xF0451F02
83
84
#ifndef STDIN_FILENO
85
0
  #define STDIN_FILENO 0
86
#endif
87
88
#ifndef SIZE_MAX
89
  #define SIZE_MAX ((size_t) -1)
90
#endif
91
92
1.50M
#define XML_MAX_ATTRS 100000000 /* 100 million */
93
94
struct _xmlStartTag {
95
    const xmlChar *prefix;
96
    const xmlChar *URI;
97
    int line;
98
    int nsNr;
99
};
100
101
typedef struct {
102
    void *saxData;
103
    unsigned prefixHashValue;
104
    unsigned uriHashValue;
105
    unsigned elementId;
106
    int oldIndex;
107
} xmlParserNsExtra;
108
109
typedef struct {
110
    unsigned hashValue;
111
    int index;
112
} xmlParserNsBucket;
113
114
struct _xmlParserNsData {
115
    xmlParserNsExtra *extra;
116
117
    unsigned hashSize;
118
    unsigned hashElems;
119
    xmlParserNsBucket *hash;
120
121
    unsigned elementId;
122
    int defaultNsIndex;
123
    int minNsIndex;
124
};
125
126
static int
127
xmlParseElementStart(xmlParserCtxtPtr ctxt);
128
129
static void
130
xmlParseElementEnd(xmlParserCtxtPtr ctxt);
131
132
static xmlEntityPtr
133
xmlLookupGeneralEntity(xmlParserCtxtPtr ctxt, const xmlChar *name, int inAttr);
134
135
static const xmlChar *
136
xmlParseEntityRefInternal(xmlParserCtxtPtr ctxt);
137
138
/************************************************************************
139
 *                  *
140
 *  Arbitrary limits set in the parser. See XML_PARSE_HUGE    *
141
 *                  *
142
 ************************************************************************/
143
144
#define XML_PARSER_BIG_ENTITY 1000
145
#define XML_PARSER_LOT_ENTITY 5000
146
147
/*
148
 * Constants for protection against abusive entity expansion
149
 * ("billion laughs").
150
 */
151
152
/*
153
 * A certain amount of entity expansion which is always allowed.
154
 */
155
2.62M
#define XML_PARSER_ALLOWED_EXPANSION 1000000
156
157
/*
158
 * Fixed cost for each entity reference. This crudely models processing time
159
 * as well to protect, for example, against exponential expansion of empty
160
 * or very short entities.
161
 */
162
2.63M
#define XML_ENT_FIXED_COST 20
163
164
199M
#define XML_PARSER_BIG_BUFFER_SIZE 300
165
414k
#define XML_PARSER_BUFFER_SIZE 100
166
283k
#define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document"
167
168
/**
169
 * XML_PARSER_CHUNK_SIZE
170
 *
171
 * When calling GROW that's the minimal amount of data
172
 * the parser expected to have received. It is not a hard
173
 * limit but an optimization when reading strings like Names
174
 * It is not strictly needed as long as inputs available characters
175
 * are followed by 0, which should be provided by the I/O level
176
 */
177
#define XML_PARSER_CHUNK_SIZE 100
178
179
/**
180
 * xmlParserVersion:
181
 *
182
 * Constant string describing the internal version of the library
183
 */
184
const char *const
185
xmlParserVersion = LIBXML_VERSION_STRING LIBXML_VERSION_EXTRA;
186
187
/*
188
 * List of XML prefixed PI allowed by W3C specs
189
 */
190
191
static const char* const xmlW3CPIs[] = {
192
    "xml-stylesheet",
193
    "xml-model",
194
    NULL
195
};
196
197
198
/* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
199
static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
200
                                              const xmlChar **str);
201
202
static void
203
xmlCtxtParseEntity(xmlParserCtxtPtr ctxt, xmlEntityPtr ent);
204
205
static int
206
xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity);
207
208
/************************************************************************
209
 *                  *
210
 *    Some factorized error routines        *
211
 *                  *
212
 ************************************************************************/
213
214
static void
215
1.06k
xmlErrMemory(xmlParserCtxtPtr ctxt) {
216
1.06k
    xmlCtxtErrMemory(ctxt);
217
1.06k
}
218
219
/**
220
 * xmlErrAttributeDup:
221
 * @ctxt:  an XML parser context
222
 * @prefix:  the attribute prefix
223
 * @localname:  the attribute localname
224
 *
225
 * Handle a redefinition of attribute error
226
 */
227
static void
228
xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
229
                   const xmlChar * localname)
230
6.43k
{
231
6.43k
    if (prefix == NULL)
232
2.29k
        xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, XML_ERR_ATTRIBUTE_REDEFINED,
233
2.29k
                   XML_ERR_FATAL, localname, NULL, NULL, 0,
234
2.29k
                   "Attribute %s redefined\n", localname);
235
4.13k
    else
236
4.13k
        xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, XML_ERR_ATTRIBUTE_REDEFINED,
237
4.13k
                   XML_ERR_FATAL, prefix, localname, NULL, 0,
238
4.13k
                   "Attribute %s:%s redefined\n", prefix, localname);
239
6.43k
}
240
241
/**
242
 * xmlFatalErrMsg:
243
 * @ctxt:  an XML parser context
244
 * @error:  the error number
245
 * @msg:  the error message
246
 *
247
 * Handle a fatal parser error, i.e. violating Well-Formedness constraints
248
 */
249
static void LIBXML_ATTR_FORMAT(3,0)
250
xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
251
               const char *msg)
252
138M
{
253
138M
    xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
254
138M
               NULL, NULL, NULL, 0, "%s", msg);
255
138M
}
256
257
/**
258
 * xmlWarningMsg:
259
 * @ctxt:  an XML parser context
260
 * @error:  the error number
261
 * @msg:  the error message
262
 * @str1:  extra data
263
 * @str2:  extra data
264
 *
265
 * Handle a warning.
266
 */
267
void LIBXML_ATTR_FORMAT(3,0)
268
xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
269
              const char *msg, const xmlChar *str1, const xmlChar *str2)
270
22.0k
{
271
22.0k
    xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_WARNING,
272
22.0k
               str1, str2, NULL, 0, msg, str1, str2);
273
22.0k
}
274
275
/**
276
 * xmlValidityError:
277
 * @ctxt:  an XML parser context
278
 * @error:  the error number
279
 * @msg:  the error message
280
 * @str1:  extra data
281
 *
282
 * Handle a validity error.
283
 */
284
static void LIBXML_ATTR_FORMAT(3,0)
285
xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
286
              const char *msg, const xmlChar *str1, const xmlChar *str2)
287
0
{
288
0
    ctxt->valid = 0;
289
290
0
    xmlCtxtErr(ctxt, NULL, XML_FROM_DTD, error, XML_ERR_ERROR,
291
0
               str1, str2, NULL, 0, msg, str1, str2);
292
0
}
293
294
/**
295
 * xmlFatalErrMsgInt:
296
 * @ctxt:  an XML parser context
297
 * @error:  the error number
298
 * @msg:  the error message
299
 * @val:  an integer value
300
 *
301
 * Handle a fatal parser error, i.e. violating Well-Formedness constraints
302
 */
303
static void LIBXML_ATTR_FORMAT(3,0)
304
xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
305
                  const char *msg, int val)
306
143M
{
307
143M
    xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
308
143M
               NULL, NULL, NULL, val, msg, val);
309
143M
}
310
311
/**
312
 * xmlFatalErrMsgStrIntStr:
313
 * @ctxt:  an XML parser context
314
 * @error:  the error number
315
 * @msg:  the error message
316
 * @str1:  an string info
317
 * @val:  an integer value
318
 * @str2:  an string info
319
 *
320
 * Handle a fatal parser error, i.e. violating Well-Formedness constraints
321
 */
322
static void LIBXML_ATTR_FORMAT(3,0)
323
xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
324
                  const char *msg, const xmlChar *str1, int val,
325
      const xmlChar *str2)
326
1.94M
{
327
1.94M
    xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
328
1.94M
               str1, str2, NULL, val, msg, str1, val, str2);
329
1.94M
}
330
331
/**
332
 * xmlFatalErrMsgStr:
333
 * @ctxt:  an XML parser context
334
 * @error:  the error number
335
 * @msg:  the error message
336
 * @val:  a string value
337
 *
338
 * Handle a fatal parser error, i.e. violating Well-Formedness constraints
339
 */
340
static void LIBXML_ATTR_FORMAT(3,0)
341
xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
342
                  const char *msg, const xmlChar * val)
343
284k
{
344
284k
    xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
345
284k
               val, NULL, NULL, 0, msg, val);
346
284k
}
347
348
/**
349
 * xmlErrMsgStr:
350
 * @ctxt:  an XML parser context
351
 * @error:  the error number
352
 * @msg:  the error message
353
 * @val:  a string value
354
 *
355
 * Handle a non fatal parser error
356
 */
357
static void LIBXML_ATTR_FORMAT(3,0)
358
xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
359
                  const char *msg, const xmlChar * val)
360
8.06k
{
361
8.06k
    xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_ERROR,
362
8.06k
               val, NULL, NULL, 0, msg, val);
363
8.06k
}
364
365
/**
366
 * xmlNsErr:
367
 * @ctxt:  an XML parser context
368
 * @error:  the error number
369
 * @msg:  the message
370
 * @info1:  extra information string
371
 * @info2:  extra information string
372
 *
373
 * Handle a fatal parser error, i.e. violating Well-Formedness constraints
374
 */
375
static void LIBXML_ATTR_FORMAT(3,0)
376
xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
377
         const char *msg,
378
         const xmlChar * info1, const xmlChar * info2,
379
         const xmlChar * info3)
380
762k
{
381
762k
    ctxt->nsWellFormed = 0;
382
383
762k
    xmlCtxtErr(ctxt, NULL, XML_FROM_NAMESPACE, error, XML_ERR_ERROR,
384
762k
               info1, info2, info3, 0, msg, info1, info2, info3);
385
762k
}
386
387
/**
388
 * xmlNsWarn
389
 * @ctxt:  an XML parser context
390
 * @error:  the error number
391
 * @msg:  the message
392
 * @info1:  extra information string
393
 * @info2:  extra information string
394
 *
395
 * Handle a namespace warning error
396
 */
397
static void LIBXML_ATTR_FORMAT(3,0)
398
xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error,
399
         const char *msg,
400
         const xmlChar * info1, const xmlChar * info2,
401
         const xmlChar * info3)
402
10.6k
{
403
10.6k
    xmlCtxtErr(ctxt, NULL, XML_FROM_NAMESPACE, error, XML_ERR_WARNING,
404
10.6k
               info1, info2, info3, 0, msg, info1, info2, info3);
405
10.6k
}
406
407
static void
408
7.92M
xmlSaturatedAdd(unsigned long *dst, unsigned long val) {
409
7.92M
    if (val > ULONG_MAX - *dst)
410
0
        *dst = ULONG_MAX;
411
7.92M
    else
412
7.92M
        *dst += val;
413
7.92M
}
414
415
static void
416
2.63M
xmlSaturatedAddSizeT(unsigned long *dst, unsigned long val) {
417
2.63M
    if (val > ULONG_MAX - *dst)
418
0
        *dst = ULONG_MAX;
419
2.63M
    else
420
2.63M
        *dst += val;
421
2.63M
}
422
423
/**
424
 * xmlParserEntityCheck:
425
 * @ctxt:  parser context
426
 * @extra:  sum of unexpanded entity sizes
427
 *
428
 * Check for non-linear entity expansion behaviour.
429
 *
430
 * In some cases like xmlExpandEntityInAttValue, this function is called
431
 * for each, possibly nested entity and its unexpanded content length.
432
 *
433
 * In other cases like xmlParseReference, it's only called for each
434
 * top-level entity with its unexpanded content length plus the sum of
435
 * the unexpanded content lengths (plus fixed cost) of all nested
436
 * entities.
437
 *
438
 * Summing the unexpanded lengths also adds the length of the reference.
439
 * This is by design. Taking the length of the entity name into account
440
 * discourages attacks that try to waste CPU time with abusively long
441
 * entity names. See test/recurse/lol6.xml for example. Each call also
442
 * adds some fixed cost XML_ENT_FIXED_COST to discourage attacks with
443
 * short entities.
444
 *
445
 * Returns 1 on error, 0 on success.
446
 */
447
static int
448
xmlParserEntityCheck(xmlParserCtxtPtr ctxt, unsigned long extra)
449
2.62M
{
450
2.62M
    unsigned long consumed;
451
2.62M
    unsigned long *expandedSize;
452
2.62M
    xmlParserInputPtr input = ctxt->input;
453
2.62M
    xmlEntityPtr entity = input->entity;
454
455
2.62M
    if ((entity) && (entity->flags & XML_ENT_CHECKED))
456
1.66k
        return(0);
457
458
    /*
459
     * Compute total consumed bytes so far, including input streams of
460
     * external entities.
461
     */
462
2.62M
    consumed = input->consumed;
463
2.62M
    xmlSaturatedAddSizeT(&consumed, input->cur - input->base);
464
2.62M
    xmlSaturatedAdd(&consumed, ctxt->sizeentities);
465
466
2.62M
    if (entity)
467
836k
        expandedSize = &entity->expandedSize;
468
1.78M
    else
469
1.78M
        expandedSize = &ctxt->sizeentcopy;
470
471
    /*
472
     * Add extra cost and some fixed cost.
473
     */
474
2.62M
    xmlSaturatedAdd(expandedSize, extra);
475
2.62M
    xmlSaturatedAdd(expandedSize, XML_ENT_FIXED_COST);
476
477
    /*
478
     * It's important to always use saturation arithmetic when tracking
479
     * entity sizes to make the size checks reliable. If "sizeentcopy"
480
     * overflows, we have to abort.
481
     */
482
2.62M
    if ((*expandedSize > XML_PARSER_ALLOWED_EXPANSION) &&
483
463k
        ((*expandedSize >= ULONG_MAX) ||
484
463k
         (*expandedSize / ctxt->maxAmpl > consumed))) {
485
1.23k
        xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT,
486
1.23k
                       "Maximum entity amplification factor exceeded, see "
487
1.23k
                       "xmlCtxtSetMaxAmplification.\n");
488
1.23k
        xmlHaltParser(ctxt);
489
1.23k
        return(1);
490
1.23k
    }
491
492
2.62M
    return(0);
493
2.62M
}
494
495
/************************************************************************
496
 *                  *
497
 *    Library wide options          *
498
 *                  *
499
 ************************************************************************/
500
501
/**
502
  * xmlHasFeature:
503
  * @feature: the feature to be examined
504
  *
505
  * Examines if the library has been compiled with a given feature.
506
  *
507
  * Returns a non-zero value if the feature exist, otherwise zero.
508
  * Returns zero (0) if the feature does not exist or an unknown
509
  * unknown feature is requested, non-zero otherwise.
510
  */
511
int
512
xmlHasFeature(xmlFeature feature)
513
0
{
514
0
    switch (feature) {
515
0
  case XML_WITH_THREAD:
516
0
#ifdef LIBXML_THREAD_ENABLED
517
0
      return(1);
518
#else
519
      return(0);
520
#endif
521
0
        case XML_WITH_TREE:
522
0
            return(1);
523
0
        case XML_WITH_OUTPUT:
524
0
#ifdef LIBXML_OUTPUT_ENABLED
525
0
            return(1);
526
#else
527
            return(0);
528
#endif
529
0
        case XML_WITH_PUSH:
530
#ifdef LIBXML_PUSH_ENABLED
531
            return(1);
532
#else
533
0
            return(0);
534
0
#endif
535
0
        case XML_WITH_READER:
536
#ifdef LIBXML_READER_ENABLED
537
            return(1);
538
#else
539
0
            return(0);
540
0
#endif
541
0
        case XML_WITH_PATTERN:
542
0
#ifdef LIBXML_PATTERN_ENABLED
543
0
            return(1);
544
#else
545
            return(0);
546
#endif
547
0
        case XML_WITH_WRITER:
548
#ifdef LIBXML_WRITER_ENABLED
549
            return(1);
550
#else
551
0
            return(0);
552
0
#endif
553
0
        case XML_WITH_SAX1:
554
#ifdef LIBXML_SAX1_ENABLED
555
            return(1);
556
#else
557
0
            return(0);
558
0
#endif
559
0
        case XML_WITH_HTTP:
560
#ifdef LIBXML_HTTP_ENABLED
561
            return(1);
562
#else
563
0
            return(0);
564
0
#endif
565
0
        case XML_WITH_VALID:
566
#ifdef LIBXML_VALID_ENABLED
567
            return(1);
568
#else
569
0
            return(0);
570
0
#endif
571
0
        case XML_WITH_HTML:
572
0
#ifdef LIBXML_HTML_ENABLED
573
0
            return(1);
574
#else
575
            return(0);
576
#endif
577
0
        case XML_WITH_LEGACY:
578
0
            return(0);
579
0
        case XML_WITH_C14N:
580
#ifdef LIBXML_C14N_ENABLED
581
            return(1);
582
#else
583
0
            return(0);
584
0
#endif
585
0
        case XML_WITH_CATALOG:
586
0
#ifdef LIBXML_CATALOG_ENABLED
587
0
            return(1);
588
#else
589
            return(0);
590
#endif
591
0
        case XML_WITH_XPATH:
592
0
#ifdef LIBXML_XPATH_ENABLED
593
0
            return(1);
594
#else
595
            return(0);
596
#endif
597
0
        case XML_WITH_XPTR:
598
0
#ifdef LIBXML_XPTR_ENABLED
599
0
            return(1);
600
#else
601
            return(0);
602
#endif
603
0
        case XML_WITH_XINCLUDE:
604
0
#ifdef LIBXML_XINCLUDE_ENABLED
605
0
            return(1);
606
#else
607
            return(0);
608
#endif
609
0
        case XML_WITH_ICONV:
610
0
#ifdef LIBXML_ICONV_ENABLED
611
0
            return(1);
612
#else
613
            return(0);
614
#endif
615
0
        case XML_WITH_ISO8859X:
616
0
#ifdef LIBXML_ISO8859X_ENABLED
617
0
            return(1);
618
#else
619
            return(0);
620
#endif
621
0
        case XML_WITH_UNICODE:
622
0
            return(0);
623
0
        case XML_WITH_REGEXP:
624
#ifdef LIBXML_REGEXP_ENABLED
625
            return(1);
626
#else
627
0
            return(0);
628
0
#endif
629
0
        case XML_WITH_AUTOMATA:
630
#ifdef LIBXML_REGEXP_ENABLED
631
            return(1);
632
#else
633
0
            return(0);
634
0
#endif
635
0
        case XML_WITH_EXPR:
636
#ifdef LIBXML_EXPR_ENABLED
637
            return(1);
638
#else
639
0
            return(0);
640
0
#endif
641
0
        case XML_WITH_RELAXNG:
642
#ifdef LIBXML_RELAXNG_ENABLED
643
            return(1);
644
#else
645
0
            return(0);
646
0
#endif
647
0
        case XML_WITH_SCHEMAS:
648
#ifdef LIBXML_SCHEMAS_ENABLED
649
            return(1);
650
#else
651
0
            return(0);
652
0
#endif
653
0
        case XML_WITH_SCHEMATRON:
654
#ifdef LIBXML_SCHEMATRON_ENABLED
655
            return(1);
656
#else
657
0
            return(0);
658
0
#endif
659
0
        case XML_WITH_MODULES:
660
0
#ifdef LIBXML_MODULES_ENABLED
661
0
            return(1);
662
#else
663
            return(0);
664
#endif
665
0
        case XML_WITH_DEBUG:
666
0
#ifdef LIBXML_DEBUG_ENABLED
667
0
            return(1);
668
#else
669
            return(0);
670
#endif
671
0
        case XML_WITH_DEBUG_MEM:
672
0
            return(0);
673
0
        case XML_WITH_ZLIB:
674
#ifdef LIBXML_ZLIB_ENABLED
675
            return(1);
676
#else
677
0
            return(0);
678
0
#endif
679
0
        case XML_WITH_LZMA:
680
#ifdef LIBXML_LZMA_ENABLED
681
            return(1);
682
#else
683
0
            return(0);
684
0
#endif
685
0
        case XML_WITH_ICU:
686
#ifdef LIBXML_ICU_ENABLED
687
            return(1);
688
#else
689
0
            return(0);
690
0
#endif
691
0
        default:
692
0
      break;
693
0
     }
694
0
     return(0);
695
0
}
696
697
/************************************************************************
698
 *                  *
699
 *      Simple string buffer        *
700
 *                  *
701
 ************************************************************************/
702
703
typedef struct {
704
    xmlChar *mem;
705
    unsigned size;
706
    unsigned cap; /* size < cap */
707
    unsigned max; /* size <= max */
708
    xmlParserErrors code;
709
} xmlSBuf;
710
711
static void
712
1.38M
xmlSBufInit(xmlSBuf *buf, unsigned max) {
713
1.38M
    buf->mem = NULL;
714
1.38M
    buf->size = 0;
715
1.38M
    buf->cap = 0;
716
1.38M
    buf->max = max;
717
1.38M
    buf->code = XML_ERR_OK;
718
1.38M
}
719
720
static int
721
215k
xmlSBufGrow(xmlSBuf *buf, unsigned len) {
722
215k
    xmlChar *mem;
723
215k
    unsigned cap;
724
725
215k
    if (len >= UINT_MAX / 2 - buf->size) {
726
0
        if (buf->code == XML_ERR_OK)
727
0
            buf->code = XML_ERR_RESOURCE_LIMIT;
728
0
        return(-1);
729
0
    }
730
731
215k
    cap = (buf->size + len) * 2;
732
215k
    if (cap < 240)
733
136k
        cap = 240;
734
735
215k
    mem = xmlRealloc(buf->mem, cap);
736
215k
    if (mem == NULL) {
737
48.3k
        buf->code = XML_ERR_NO_MEMORY;
738
48.3k
        return(-1);
739
48.3k
    }
740
741
167k
    buf->mem = mem;
742
167k
    buf->cap = cap;
743
744
167k
    return(0);
745
215k
}
746
747
static void
748
196M
xmlSBufAddString(xmlSBuf *buf, const xmlChar *str, unsigned len) {
749
196M
    if (buf->max - buf->size < len) {
750
389k
        if (buf->code == XML_ERR_OK)
751
69
            buf->code = XML_ERR_RESOURCE_LIMIT;
752
389k
        return;
753
389k
    }
754
755
196M
    if (buf->cap - buf->size <= len) {
756
208k
        if (xmlSBufGrow(buf, len) < 0)
757
48.1k
            return;
758
208k
    }
759
760
196M
    if (len > 0)
761
196M
        memcpy(buf->mem + buf->size, str, len);
762
196M
    buf->size += len;
763
196M
}
764
765
static void
766
193M
xmlSBufAddCString(xmlSBuf *buf, const char *str, unsigned len) {
767
193M
    xmlSBufAddString(buf, (const xmlChar *) str, len);
768
193M
}
769
770
static void
771
148k
xmlSBufAddChar(xmlSBuf *buf, int c) {
772
148k
    xmlChar *end;
773
774
148k
    if (buf->max - buf->size < 4) {
775
147
        if (buf->code == XML_ERR_OK)
776
0
            buf->code = XML_ERR_RESOURCE_LIMIT;
777
147
        return;
778
147
    }
779
780
148k
    if (buf->cap - buf->size <= 4) {
781
6.82k
        if (xmlSBufGrow(buf, 4) < 0)
782
211
            return;
783
6.82k
    }
784
785
148k
    end = buf->mem + buf->size;
786
787
148k
    if (c < 0x80) {
788
85.3k
        *end = (xmlChar) c;
789
85.3k
        buf->size += 1;
790
85.3k
    } else {
791
63.1k
        buf->size += xmlCopyCharMultiByte(end, c);
792
63.1k
    }
793
148k
}
794
795
static void
796
177M
xmlSBufAddReplChar(xmlSBuf *buf) {
797
177M
    xmlSBufAddCString(buf, "\xEF\xBF\xBD", 3);
798
177M
}
799
800
static void
801
135
xmlSBufReportError(xmlSBuf *buf, xmlParserCtxtPtr ctxt, const char *errMsg) {
802
135
    if (buf->code == XML_ERR_NO_MEMORY)
803
66
        xmlCtxtErrMemory(ctxt);
804
69
    else
805
69
        xmlFatalErr(ctxt, buf->code, errMsg);
806
135
}
807
808
static xmlChar *
809
xmlSBufFinish(xmlSBuf *buf, int *sizeOut, xmlParserCtxtPtr ctxt,
810
157k
              const char *errMsg) {
811
157k
    if (buf->mem == NULL) {
812
28.4k
        buf->mem = xmlMalloc(1);
813
28.4k
        if (buf->mem == NULL) {
814
20
            buf->code = XML_ERR_NO_MEMORY;
815
28.4k
        } else {
816
28.4k
            buf->mem[0] = 0;
817
28.4k
        }
818
129k
    } else {
819
129k
        buf->mem[buf->size] = 0;
820
129k
    }
821
822
157k
    if (buf->code == XML_ERR_OK) {
823
157k
        if (sizeOut != NULL)
824
80.0k
            *sizeOut = buf->size;
825
157k
        return(buf->mem);
826
157k
    }
827
828
42
    xmlSBufReportError(buf, ctxt, errMsg);
829
830
42
    xmlFree(buf->mem);
831
832
42
    if (sizeOut != NULL)
833
17
        *sizeOut = 0;
834
42
    return(NULL);
835
157k
}
836
837
static void
838
1.21M
xmlSBufCleanup(xmlSBuf *buf, xmlParserCtxtPtr ctxt, const char *errMsg) {
839
1.21M
    if (buf->code != XML_ERR_OK)
840
93
        xmlSBufReportError(buf, ctxt, errMsg);
841
842
1.21M
    xmlFree(buf->mem);
843
1.21M
}
844
845
static int
846
xmlUTF8MultibyteLen(xmlParserCtxtPtr ctxt, const xmlChar *str,
847
213M
                    const char *errMsg) {
848
213M
    int c = str[0];
849
213M
    int c1 = str[1];
850
851
213M
    if ((c1 & 0xC0) != 0x80)
852
24.8M
        goto encoding_error;
853
854
188M
    if (c < 0xE0) {
855
        /* 2-byte sequence */
856
29.4M
        if (c < 0xC2)
857
19.4M
            goto encoding_error;
858
859
9.94M
        return(2);
860
159M
    } else {
861
159M
        int c2 = str[2];
862
863
159M
        if ((c2 & 0xC0) != 0x80)
864
8.67k
            goto encoding_error;
865
866
159M
        if (c < 0xF0) {
867
            /* 3-byte sequence */
868
158M
            if (c == 0xE0) {
869
                /* overlong */
870
11.9M
                if (c1 < 0xA0)
871
237
                    goto encoding_error;
872
147M
            } else if (c == 0xED) {
873
                /* surrogate */
874
45.1k
                if (c1 >= 0xA0)
875
12.8k
                    goto encoding_error;
876
147M
            } else if (c == 0xEF) {
877
                /* U+FFFE and U+FFFF are invalid Chars */
878
690k
                if ((c1 == 0xBF) && (c2 >= 0xBE))
879
1.02k
                    xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR, errMsg);
880
690k
            }
881
882
158M
            return(3);
883
158M
        } else {
884
            /* 4-byte sequence */
885
50.5k
            if ((str[3] & 0xC0) != 0x80)
886
2.78k
                goto encoding_error;
887
47.7k
            if (c == 0xF0) {
888
                /* overlong */
889
19.8k
                if (c1 < 0x90)
890
201
                    goto encoding_error;
891
27.8k
            } else if (c >= 0xF4) {
892
                /* greater than 0x10FFFF */
893
12.0k
                if ((c > 0xF4) || (c1 >= 0x90))
894
11.6k
                    goto encoding_error;
895
12.0k
            }
896
897
35.8k
            return(4);
898
47.7k
        }
899
159M
    }
900
901
44.3M
encoding_error:
902
    /* Only report the first error */
903
44.3M
    if ((ctxt->input->flags & XML_INPUT_ENCODING_ERROR) == 0) {
904
8.45k
        xmlCtxtErrIO(ctxt, XML_ERR_INVALID_ENCODING, NULL);
905
8.45k
        ctxt->input->flags |= XML_INPUT_ENCODING_ERROR;
906
8.45k
    }
907
908
44.3M
    return(0);
909
188M
}
910
911
/************************************************************************
912
 *                  *
913
 *    SAX2 defaulted attributes handling      *
914
 *                  *
915
 ************************************************************************/
916
917
/**
918
 * xmlCtxtInitializeLate:
919
 * @ctxt:  an XML parser context
920
 *
921
 * Final initialization of the parser context before starting to parse.
922
 *
923
 * This accounts for users modifying struct members of parser context
924
 * directly.
925
 */
926
static void
927
273k
xmlCtxtInitializeLate(xmlParserCtxtPtr ctxt) {
928
273k
    xmlSAXHandlerPtr sax;
929
930
    /* Avoid unused variable warning if features are disabled. */
931
273k
    (void) sax;
932
933
    /*
934
     * Changing the SAX struct directly is still widespread practice
935
     * in internal and external code.
936
     */
937
273k
    if (ctxt == NULL) return;
938
273k
    sax = ctxt->sax;
939
#ifdef LIBXML_SAX1_ENABLED
940
    /*
941
     * Only enable SAX2 if there SAX2 element handlers, except when there
942
     * are no element handlers at all.
943
     */
944
    if (((ctxt->options & XML_PARSE_SAX1) == 0) &&
945
        (sax) &&
946
        (sax->initialized == XML_SAX2_MAGIC) &&
947
        ((sax->startElementNs != NULL) ||
948
         (sax->endElementNs != NULL) ||
949
         ((sax->startElement == NULL) && (sax->endElement == NULL))))
950
        ctxt->sax2 = 1;
951
#else
952
273k
    ctxt->sax2 = 1;
953
273k
#endif /* LIBXML_SAX1_ENABLED */
954
955
    /*
956
     * Some users replace the dictionary directly in the context struct.
957
     * We really need an API function to do that cleanly.
958
     */
959
273k
    ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
960
273k
    ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
961
273k
    ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
962
273k
    if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) ||
963
273k
    (ctxt->str_xml_ns == NULL)) {
964
0
        xmlErrMemory(ctxt);
965
0
    }
966
967
273k
    xmlDictSetLimit(ctxt->dict,
968
273k
                    (ctxt->options & XML_PARSE_HUGE) ?
969
0
                        0 :
970
273k
                        XML_MAX_DICTIONARY_LIMIT);
971
273k
}
972
973
typedef struct {
974
    xmlHashedString prefix;
975
    xmlHashedString name;
976
    xmlHashedString value;
977
    const xmlChar *valueEnd;
978
    int external;
979
    int expandedSize;
980
} xmlDefAttr;
981
982
typedef struct _xmlDefAttrs xmlDefAttrs;
983
typedef xmlDefAttrs *xmlDefAttrsPtr;
984
struct _xmlDefAttrs {
985
    int nbAttrs;  /* number of defaulted attributes on that element */
986
    int maxAttrs;       /* the size of the array */
987
#if __STDC_VERSION__ >= 199901L
988
    /* Using a C99 flexible array member avoids UBSan errors. */
989
    xmlDefAttr attrs[] ATTRIBUTE_COUNTED_BY(maxAttrs);
990
#else
991
    xmlDefAttr attrs[1];
992
#endif
993
};
994
995
/**
996
 * xmlAttrNormalizeSpace:
997
 * @src: the source string
998
 * @dst: the target string
999
 *
1000
 * Normalize the space in non CDATA attribute values:
1001
 * If the attribute type is not CDATA, then the XML processor MUST further
1002
 * process the normalized attribute value by discarding any leading and
1003
 * trailing space (#x20) characters, and by replacing sequences of space
1004
 * (#x20) characters by a single space (#x20) character.
1005
 * Note that the size of dst need to be at least src, and if one doesn't need
1006
 * to preserve dst (and it doesn't come from a dictionary or read-only) then
1007
 * passing src as dst is just fine.
1008
 *
1009
 * Returns a pointer to the normalized value (dst) or NULL if no conversion
1010
 *         is needed.
1011
 */
1012
static xmlChar *
1013
xmlAttrNormalizeSpace(const xmlChar *src, xmlChar *dst)
1014
40.5k
{
1015
40.5k
    if ((src == NULL) || (dst == NULL))
1016
0
        return(NULL);
1017
1018
40.6k
    while (*src == 0x20) src++;
1019
7.67M
    while (*src != 0) {
1020
7.63M
  if (*src == 0x20) {
1021
5.22M
      while (*src == 0x20) src++;
1022
13.9k
      if (*src != 0)
1023
9.30k
    *dst++ = 0x20;
1024
7.62M
  } else {
1025
7.62M
      *dst++ = *src++;
1026
7.62M
  }
1027
7.63M
    }
1028
40.5k
    *dst = 0;
1029
40.5k
    if (dst == src)
1030
35.4k
       return(NULL);
1031
5.15k
    return(dst);
1032
40.5k
}
1033
1034
/**
1035
 * xmlAddDefAttrs:
1036
 * @ctxt:  an XML parser context
1037
 * @fullname:  the element fullname
1038
 * @fullattr:  the attribute fullname
1039
 * @value:  the attribute value
1040
 *
1041
 * Add a defaulted attribute for an element
1042
 */
1043
static void
1044
xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
1045
               const xmlChar *fullname,
1046
               const xmlChar *fullattr,
1047
41.7k
               const xmlChar *value) {
1048
41.7k
    xmlDefAttrsPtr defaults;
1049
41.7k
    xmlDefAttr *attr;
1050
41.7k
    int len, expandedSize;
1051
41.7k
    xmlHashedString name;
1052
41.7k
    xmlHashedString prefix;
1053
41.7k
    xmlHashedString hvalue;
1054
41.7k
    const xmlChar *localname;
1055
1056
    /*
1057
     * Allows to detect attribute redefinitions
1058
     */
1059
41.7k
    if (ctxt->attsSpecial != NULL) {
1060
34.3k
        if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1061
9.67k
      return;
1062
34.3k
    }
1063
1064
32.0k
    if (ctxt->attsDefault == NULL) {
1065
7.43k
        ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
1066
7.43k
  if (ctxt->attsDefault == NULL)
1067
12
      goto mem_error;
1068
7.43k
    }
1069
1070
    /*
1071
     * split the element name into prefix:localname , the string found
1072
     * are within the DTD and then not associated to namespace names.
1073
     */
1074
32.0k
    localname = xmlSplitQName3(fullname, &len);
1075
32.0k
    if (localname == NULL) {
1076
31.1k
        name = xmlDictLookupHashed(ctxt->dict, fullname, -1);
1077
31.1k
  prefix.name = NULL;
1078
31.1k
    } else {
1079
924
        name = xmlDictLookupHashed(ctxt->dict, localname, -1);
1080
924
  prefix = xmlDictLookupHashed(ctxt->dict, fullname, len);
1081
924
        if (prefix.name == NULL)
1082
0
            goto mem_error;
1083
924
    }
1084
32.0k
    if (name.name == NULL)
1085
1
        goto mem_error;
1086
1087
    /*
1088
     * make sure there is some storage
1089
     */
1090
32.0k
    defaults = xmlHashLookup2(ctxt->attsDefault, name.name, prefix.name);
1091
32.0k
    if ((defaults == NULL) ||
1092
24.2k
        (defaults->nbAttrs >= defaults->maxAttrs)) {
1093
11.6k
        xmlDefAttrsPtr temp;
1094
11.6k
        int newSize;
1095
1096
11.6k
        if (defaults == NULL) {
1097
7.77k
            newSize = 4;
1098
7.77k
        } else {
1099
3.92k
            if ((defaults->maxAttrs >= XML_MAX_ATTRS) ||
1100
3.92k
                ((size_t) defaults->maxAttrs >
1101
3.92k
                     SIZE_MAX / 2 / sizeof(temp[0]) - sizeof(*defaults)))
1102
0
                goto mem_error;
1103
1104
3.92k
            if (defaults->maxAttrs > XML_MAX_ATTRS / 2)
1105
0
                newSize = XML_MAX_ATTRS;
1106
3.92k
            else
1107
3.92k
                newSize = defaults->maxAttrs * 2;
1108
3.92k
        }
1109
11.6k
        temp = xmlRealloc(defaults,
1110
11.6k
                          sizeof(*defaults) + newSize * sizeof(xmlDefAttr));
1111
11.6k
  if (temp == NULL)
1112
3
      goto mem_error;
1113
11.6k
        if (defaults == NULL)
1114
7.77k
            temp->nbAttrs = 0;
1115
11.6k
  temp->maxAttrs = newSize;
1116
11.6k
        defaults = temp;
1117
11.6k
  if (xmlHashUpdateEntry2(ctxt->attsDefault, name.name, prefix.name,
1118
11.6k
                          defaults, NULL) < 0) {
1119
0
      xmlFree(defaults);
1120
0
      goto mem_error;
1121
0
  }
1122
11.6k
    }
1123
1124
    /*
1125
     * Split the attribute name into prefix:localname , the string found
1126
     * are within the DTD and hen not associated to namespace names.
1127
     */
1128
32.0k
    localname = xmlSplitQName3(fullattr, &len);
1129
32.0k
    if (localname == NULL) {
1130
9.13k
        name = xmlDictLookupHashed(ctxt->dict, fullattr, -1);
1131
9.13k
  prefix.name = NULL;
1132
22.8k
    } else {
1133
22.8k
        name = xmlDictLookupHashed(ctxt->dict, localname, -1);
1134
22.8k
  prefix = xmlDictLookupHashed(ctxt->dict, fullattr, len);
1135
22.8k
        if (prefix.name == NULL)
1136
2
            goto mem_error;
1137
22.8k
    }
1138
32.0k
    if (name.name == NULL)
1139
1
        goto mem_error;
1140
1141
    /* intern the string and precompute the end */
1142
32.0k
    len = strlen((const char *) value);
1143
32.0k
    hvalue = xmlDictLookupHashed(ctxt->dict, value, len);
1144
32.0k
    if (hvalue.name == NULL)
1145
2
        goto mem_error;
1146
1147
32.0k
    expandedSize = strlen((const char *) name.name);
1148
32.0k
    if (prefix.name != NULL)
1149
22.8k
        expandedSize += strlen((const char *) prefix.name);
1150
32.0k
    expandedSize += len;
1151
1152
32.0k
    attr = &defaults->attrs[defaults->nbAttrs++];
1153
32.0k
    attr->name = name;
1154
32.0k
    attr->prefix = prefix;
1155
32.0k
    attr->value = hvalue;
1156
32.0k
    attr->valueEnd = hvalue.name + len;
1157
32.0k
    attr->external = PARSER_EXTERNAL(ctxt);
1158
32.0k
    attr->expandedSize = expandedSize;
1159
1160
32.0k
    return;
1161
1162
21
mem_error:
1163
21
    xmlErrMemory(ctxt);
1164
21
}
1165
1166
/**
1167
 * xmlAddSpecialAttr:
1168
 * @ctxt:  an XML parser context
1169
 * @fullname:  the element fullname
1170
 * @fullattr:  the attribute fullname
1171
 * @type:  the attribute type
1172
 *
1173
 * Register this attribute type
1174
 */
1175
static void
1176
xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
1177
      const xmlChar *fullname,
1178
      const xmlChar *fullattr,
1179
      int type)
1180
52.0k
{
1181
52.0k
    if (ctxt->attsSpecial == NULL) {
1182
11.2k
        ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
1183
11.2k
  if (ctxt->attsSpecial == NULL)
1184
21
      goto mem_error;
1185
11.2k
    }
1186
1187
51.9k
    if (xmlHashAdd2(ctxt->attsSpecial, fullname, fullattr,
1188
51.9k
                    XML_INT_TO_PTR(type)) < 0)
1189
1
        goto mem_error;
1190
51.9k
    return;
1191
1192
51.9k
mem_error:
1193
22
    xmlErrMemory(ctxt);
1194
22
}
1195
1196
/**
1197
 * xmlCleanSpecialAttrCallback:
1198
 *
1199
 * Removes CDATA attributes from the special attribute table
1200
 */
1201
static void
1202
xmlCleanSpecialAttrCallback(void *payload, void *data,
1203
                            const xmlChar *fullname, const xmlChar *fullattr,
1204
39.7k
                            const xmlChar *unused ATTRIBUTE_UNUSED) {
1205
39.7k
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data;
1206
1207
39.7k
    if (XML_PTR_TO_INT(payload) == XML_ATTRIBUTE_CDATA) {
1208
5.39k
        xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL);
1209
5.39k
    }
1210
39.7k
}
1211
1212
/**
1213
 * xmlCleanSpecialAttr:
1214
 * @ctxt:  an XML parser context
1215
 *
1216
 * Trim the list of attributes defined to remove all those of type
1217
 * CDATA as they are not special. This call should be done when finishing
1218
 * to parse the DTD and before starting to parse the document root.
1219
 */
1220
static void
1221
xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt)
1222
57.1k
{
1223
57.1k
    if (ctxt->attsSpecial == NULL)
1224
45.9k
        return;
1225
1226
11.2k
    xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt);
1227
1228
11.2k
    if (xmlHashSize(ctxt->attsSpecial) == 0) {
1229
1.71k
        xmlHashFree(ctxt->attsSpecial, NULL);
1230
1.71k
        ctxt->attsSpecial = NULL;
1231
1.71k
    }
1232
11.2k
}
1233
1234
/**
1235
 * xmlCheckLanguageID:
1236
 * @lang:  pointer to the string value
1237
 *
1238
 * DEPRECATED: Internal function, do not use.
1239
 *
1240
 * Checks that the value conforms to the LanguageID production:
1241
 *
1242
 * NOTE: this is somewhat deprecated, those productions were removed from
1243
 *       the XML Second edition.
1244
 *
1245
 * [33] LanguageID ::= Langcode ('-' Subcode)*
1246
 * [34] Langcode ::= ISO639Code |  IanaCode |  UserCode
1247
 * [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z])
1248
 * [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+
1249
 * [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+
1250
 * [38] Subcode ::= ([a-z] | [A-Z])+
1251
 *
1252
 * The current REC reference the successors of RFC 1766, currently 5646
1253
 *
1254
 * http://www.rfc-editor.org/rfc/rfc5646.txt
1255
 * langtag       = language
1256
 *                 ["-" script]
1257
 *                 ["-" region]
1258
 *                 *("-" variant)
1259
 *                 *("-" extension)
1260
 *                 ["-" privateuse]
1261
 * language      = 2*3ALPHA            ; shortest ISO 639 code
1262
 *                 ["-" extlang]       ; sometimes followed by
1263
 *                                     ; extended language subtags
1264
 *               / 4ALPHA              ; or reserved for future use
1265
 *               / 5*8ALPHA            ; or registered language subtag
1266
 *
1267
 * extlang       = 3ALPHA              ; selected ISO 639 codes
1268
 *                 *2("-" 3ALPHA)      ; permanently reserved
1269
 *
1270
 * script        = 4ALPHA              ; ISO 15924 code
1271
 *
1272
 * region        = 2ALPHA              ; ISO 3166-1 code
1273
 *               / 3DIGIT              ; UN M.49 code
1274
 *
1275
 * variant       = 5*8alphanum         ; registered variants
1276
 *               / (DIGIT 3alphanum)
1277
 *
1278
 * extension     = singleton 1*("-" (2*8alphanum))
1279
 *
1280
 *                                     ; Single alphanumerics
1281
 *                                     ; "x" reserved for private use
1282
 * singleton     = DIGIT               ; 0 - 9
1283
 *               / %x41-57             ; A - W
1284
 *               / %x59-5A             ; Y - Z
1285
 *               / %x61-77             ; a - w
1286
 *               / %x79-7A             ; y - z
1287
 *
1288
 * it sounds right to still allow Irregular i-xxx IANA and user codes too
1289
 * The parser below doesn't try to cope with extension or privateuse
1290
 * that could be added but that's not interoperable anyway
1291
 *
1292
 * Returns 1 if correct 0 otherwise
1293
 **/
1294
int
1295
xmlCheckLanguageID(const xmlChar * lang)
1296
0
{
1297
0
    const xmlChar *cur = lang, *nxt;
1298
1299
0
    if (cur == NULL)
1300
0
        return (0);
1301
0
    if (((cur[0] == 'i') && (cur[1] == '-')) ||
1302
0
        ((cur[0] == 'I') && (cur[1] == '-')) ||
1303
0
        ((cur[0] == 'x') && (cur[1] == '-')) ||
1304
0
        ((cur[0] == 'X') && (cur[1] == '-'))) {
1305
        /*
1306
         * Still allow IANA code and user code which were coming
1307
         * from the previous version of the XML-1.0 specification
1308
         * it's deprecated but we should not fail
1309
         */
1310
0
        cur += 2;
1311
0
        while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||
1312
0
               ((cur[0] >= 'a') && (cur[0] <= 'z')))
1313
0
            cur++;
1314
0
        return(cur[0] == 0);
1315
0
    }
1316
0
    nxt = cur;
1317
0
    while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1318
0
           ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1319
0
           nxt++;
1320
0
    if (nxt - cur >= 4) {
1321
        /*
1322
         * Reserved
1323
         */
1324
0
        if ((nxt - cur > 8) || (nxt[0] != 0))
1325
0
            return(0);
1326
0
        return(1);
1327
0
    }
1328
0
    if (nxt - cur < 2)
1329
0
        return(0);
1330
    /* we got an ISO 639 code */
1331
0
    if (nxt[0] == 0)
1332
0
        return(1);
1333
0
    if (nxt[0] != '-')
1334
0
        return(0);
1335
1336
0
    nxt++;
1337
0
    cur = nxt;
1338
    /* now we can have extlang or script or region or variant */
1339
0
    if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1340
0
        goto region_m49;
1341
1342
0
    while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1343
0
           ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1344
0
           nxt++;
1345
0
    if (nxt - cur == 4)
1346
0
        goto script;
1347
0
    if (nxt - cur == 2)
1348
0
        goto region;
1349
0
    if ((nxt - cur >= 5) && (nxt - cur <= 8))
1350
0
        goto variant;
1351
0
    if (nxt - cur != 3)
1352
0
        return(0);
1353
    /* we parsed an extlang */
1354
0
    if (nxt[0] == 0)
1355
0
        return(1);
1356
0
    if (nxt[0] != '-')
1357
0
        return(0);
1358
1359
0
    nxt++;
1360
0
    cur = nxt;
1361
    /* now we can have script or region or variant */
1362
0
    if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1363
0
        goto region_m49;
1364
1365
0
    while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1366
0
           ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1367
0
           nxt++;
1368
0
    if (nxt - cur == 2)
1369
0
        goto region;
1370
0
    if ((nxt - cur >= 5) && (nxt - cur <= 8))
1371
0
        goto variant;
1372
0
    if (nxt - cur != 4)
1373
0
        return(0);
1374
    /* we parsed a script */
1375
0
script:
1376
0
    if (nxt[0] == 0)
1377
0
        return(1);
1378
0
    if (nxt[0] != '-')
1379
0
        return(0);
1380
1381
0
    nxt++;
1382
0
    cur = nxt;
1383
    /* now we can have region or variant */
1384
0
    if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1385
0
        goto region_m49;
1386
1387
0
    while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1388
0
           ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1389
0
           nxt++;
1390
1391
0
    if ((nxt - cur >= 5) && (nxt - cur <= 8))
1392
0
        goto variant;
1393
0
    if (nxt - cur != 2)
1394
0
        return(0);
1395
    /* we parsed a region */
1396
0
region:
1397
0
    if (nxt[0] == 0)
1398
0
        return(1);
1399
0
    if (nxt[0] != '-')
1400
0
        return(0);
1401
1402
0
    nxt++;
1403
0
    cur = nxt;
1404
    /* now we can just have a variant */
1405
0
    while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1406
0
           ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1407
0
           nxt++;
1408
1409
0
    if ((nxt - cur < 5) || (nxt - cur > 8))
1410
0
        return(0);
1411
1412
    /* we parsed a variant */
1413
0
variant:
1414
0
    if (nxt[0] == 0)
1415
0
        return(1);
1416
0
    if (nxt[0] != '-')
1417
0
        return(0);
1418
    /* extensions and private use subtags not checked */
1419
0
    return (1);
1420
1421
0
region_m49:
1422
0
    if (((nxt[1] >= '0') && (nxt[1] <= '9')) &&
1423
0
        ((nxt[2] >= '0') && (nxt[2] <= '9'))) {
1424
0
        nxt += 3;
1425
0
        goto region;
1426
0
    }
1427
0
    return(0);
1428
0
}
1429
1430
/************************************************************************
1431
 *                  *
1432
 *    Parser stacks related functions and macros    *
1433
 *                  *
1434
 ************************************************************************/
1435
1436
static xmlChar *
1437
xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar **str);
1438
1439
/**
1440
 * xmlParserNsCreate:
1441
 *
1442
 * Create a new namespace database.
1443
 *
1444
 * Returns the new obejct.
1445
 */
1446
xmlParserNsData *
1447
312k
xmlParserNsCreate(void) {
1448
312k
    xmlParserNsData *nsdb = xmlMalloc(sizeof(*nsdb));
1449
1450
312k
    if (nsdb == NULL)
1451
25
        return(NULL);
1452
312k
    memset(nsdb, 0, sizeof(*nsdb));
1453
312k
    nsdb->defaultNsIndex = INT_MAX;
1454
1455
312k
    return(nsdb);
1456
312k
}
1457
1458
/**
1459
 * xmlParserNsFree:
1460
 * @nsdb: namespace database
1461
 *
1462
 * Free a namespace database.
1463
 */
1464
void
1465
312k
xmlParserNsFree(xmlParserNsData *nsdb) {
1466
312k
    if (nsdb == NULL)
1467
0
        return;
1468
1469
312k
    xmlFree(nsdb->extra);
1470
312k
    xmlFree(nsdb->hash);
1471
312k
    xmlFree(nsdb);
1472
312k
}
1473
1474
/**
1475
 * xmlParserNsReset:
1476
 * @nsdb: namespace database
1477
 *
1478
 * Reset a namespace database.
1479
 */
1480
static void
1481
0
xmlParserNsReset(xmlParserNsData *nsdb) {
1482
0
    if (nsdb == NULL)
1483
0
        return;
1484
1485
0
    nsdb->hashElems = 0;
1486
0
    nsdb->elementId = 0;
1487
0
    nsdb->defaultNsIndex = INT_MAX;
1488
1489
0
    if (nsdb->hash)
1490
0
        memset(nsdb->hash, 0, nsdb->hashSize * sizeof(nsdb->hash[0]));
1491
0
}
1492
1493
/**
1494
 * xmlParserStartElement:
1495
 * @nsdb: namespace database
1496
 *
1497
 * Signal that a new element has started.
1498
 *
1499
 * Returns 0 on success, -1 if the element counter overflowed.
1500
 */
1501
static int
1502
6.23M
xmlParserNsStartElement(xmlParserNsData *nsdb) {
1503
6.23M
    if (nsdb->elementId == UINT_MAX)
1504
0
        return(-1);
1505
6.23M
    nsdb->elementId++;
1506
1507
6.23M
    return(0);
1508
6.23M
}
1509
1510
/**
1511
 * xmlParserNsLookup:
1512
 * @ctxt: parser context
1513
 * @prefix: namespace prefix
1514
 * @bucketPtr: optional bucket (return value)
1515
 *
1516
 * Lookup namespace with given prefix. If @bucketPtr is non-NULL, it will
1517
 * be set to the matching bucket, or the first empty bucket if no match
1518
 * was found.
1519
 *
1520
 * Returns the namespace index on success, INT_MAX if no namespace was
1521
 * found.
1522
 */
1523
static int
1524
xmlParserNsLookup(xmlParserCtxtPtr ctxt, const xmlHashedString *prefix,
1525
6.93M
                  xmlParserNsBucket **bucketPtr) {
1526
6.93M
    xmlParserNsBucket *bucket, *tombstone;
1527
6.93M
    unsigned index, hashValue;
1528
1529
6.93M
    if (prefix->name == NULL)
1530
2.34M
        return(ctxt->nsdb->defaultNsIndex);
1531
1532
4.59M
    if (ctxt->nsdb->hashSize == 0)
1533
276k
        return(INT_MAX);
1534
1535
4.32M
    hashValue = prefix->hashValue;
1536
4.32M
    index = hashValue & (ctxt->nsdb->hashSize - 1);
1537
4.32M
    bucket = &ctxt->nsdb->hash[index];
1538
4.32M
    tombstone = NULL;
1539
1540
4.70M
    while (bucket->hashValue) {
1541
3.99M
        if (bucket->index == INT_MAX) {
1542
153k
            if (tombstone == NULL)
1543
138k
                tombstone = bucket;
1544
3.84M
        } else if (bucket->hashValue == hashValue) {
1545
3.61M
            if (ctxt->nsTab[bucket->index * 2] == prefix->name) {
1546
3.61M
                if (bucketPtr != NULL)
1547
1.95M
                    *bucketPtr = bucket;
1548
3.61M
                return(bucket->index);
1549
3.61M
            }
1550
3.61M
        }
1551
1552
386k
        index++;
1553
386k
        bucket++;
1554
386k
        if (index == ctxt->nsdb->hashSize) {
1555
42.6k
            index = 0;
1556
42.6k
            bucket = ctxt->nsdb->hash;
1557
42.6k
        }
1558
386k
    }
1559
1560
710k
    if (bucketPtr != NULL)
1561
136k
        *bucketPtr = tombstone ? tombstone : bucket;
1562
710k
    return(INT_MAX);
1563
4.32M
}
1564
1565
/**
1566
 * xmlParserNsLookupUri:
1567
 * @ctxt: parser context
1568
 * @prefix: namespace prefix
1569
 *
1570
 * Lookup namespace URI with given prefix.
1571
 *
1572
 * Returns the namespace URI on success, NULL if no namespace was found.
1573
 */
1574
static const xmlChar *
1575
3.24M
xmlParserNsLookupUri(xmlParserCtxtPtr ctxt, const xmlHashedString *prefix) {
1576
3.24M
    const xmlChar *ret;
1577
3.24M
    int nsIndex;
1578
1579
3.24M
    if (prefix->name == ctxt->str_xml)
1580
845
        return(ctxt->str_xml_ns);
1581
1582
    /*
1583
     * minNsIndex is used when building an entity tree. We must
1584
     * ignore namespaces declared outside the entity.
1585
     */
1586
3.24M
    nsIndex = xmlParserNsLookup(ctxt, prefix, NULL);
1587
3.24M
    if ((nsIndex == INT_MAX) || (nsIndex < ctxt->nsdb->minNsIndex))
1588
1.86M
        return(NULL);
1589
1590
1.37M
    ret = ctxt->nsTab[nsIndex * 2 + 1];
1591
1.37M
    if (ret[0] == 0)
1592
152k
        ret = NULL;
1593
1.37M
    return(ret);
1594
3.24M
}
1595
1596
/**
1597
 * xmlParserNsLookupSax:
1598
 * @ctxt: parser context
1599
 * @prefix: namespace prefix
1600
 *
1601
 * Lookup extra data for the given prefix. This returns data stored
1602
 * with xmlParserNsUdpateSax.
1603
 *
1604
 * Returns the data on success, NULL if no namespace was found.
1605
 */
1606
void *
1607
699k
xmlParserNsLookupSax(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
1608
699k
    xmlHashedString hprefix;
1609
699k
    int nsIndex;
1610
1611
699k
    if (prefix == ctxt->str_xml)
1612
40.5k
        return(NULL);
1613
1614
659k
    hprefix.name = prefix;
1615
659k
    if (prefix != NULL)
1616
607k
        hprefix.hashValue = xmlDictComputeHash(ctxt->dict, prefix);
1617
51.7k
    else
1618
51.7k
        hprefix.hashValue = 0;
1619
659k
    nsIndex = xmlParserNsLookup(ctxt, &hprefix, NULL);
1620
659k
    if ((nsIndex == INT_MAX) || (nsIndex < ctxt->nsdb->minNsIndex))
1621
0
        return(NULL);
1622
1623
659k
    return(ctxt->nsdb->extra[nsIndex].saxData);
1624
659k
}
1625
1626
/**
1627
 * xmlParserNsUpdateSax:
1628
 * @ctxt: parser context
1629
 * @prefix: namespace prefix
1630
 * @saxData: extra data for SAX handler
1631
 *
1632
 * Sets or updates extra data for the given prefix. This value will be
1633
 * returned by xmlParserNsLookupSax as long as the namespace with the
1634
 * given prefix is in scope.
1635
 *
1636
 * Returns the data on success, NULL if no namespace was found.
1637
 */
1638
int
1639
xmlParserNsUpdateSax(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
1640
211k
                     void *saxData) {
1641
211k
    xmlHashedString hprefix;
1642
211k
    int nsIndex;
1643
1644
211k
    if (prefix == ctxt->str_xml)
1645
0
        return(-1);
1646
1647
211k
    hprefix.name = prefix;
1648
211k
    if (prefix != NULL)
1649
201k
        hprefix.hashValue = xmlDictComputeHash(ctxt->dict, prefix);
1650
10.5k
    else
1651
10.5k
        hprefix.hashValue = 0;
1652
211k
    nsIndex = xmlParserNsLookup(ctxt, &hprefix, NULL);
1653
211k
    if ((nsIndex == INT_MAX) || (nsIndex < ctxt->nsdb->minNsIndex))
1654
0
        return(-1);
1655
1656
211k
    ctxt->nsdb->extra[nsIndex].saxData = saxData;
1657
211k
    return(0);
1658
211k
}
1659
1660
/**
1661
 * xmlParserNsGrow:
1662
 * @ctxt: parser context
1663
 *
1664
 * Grows the namespace tables.
1665
 *
1666
 * Returns 0 on success, -1 if a memory allocation failed.
1667
 */
1668
static int
1669
212k
xmlParserNsGrow(xmlParserCtxtPtr ctxt) {
1670
212k
    const xmlChar **table;
1671
212k
    xmlParserNsExtra *extra;
1672
212k
    int newSize;
1673
1674
212k
    newSize = xmlGrowCapacity(ctxt->nsMax,
1675
212k
                              sizeof(table[0]) + sizeof(extra[0]),
1676
212k
                              16, XML_MAX_ITEMS);
1677
212k
    if (newSize < 0)
1678
0
        goto error;
1679
1680
212k
    table = xmlRealloc(ctxt->nsTab, 2 * newSize * sizeof(table[0]));
1681
212k
    if (table == NULL)
1682
27
        goto error;
1683
212k
    ctxt->nsTab = table;
1684
1685
212k
    extra = xmlRealloc(ctxt->nsdb->extra, newSize * sizeof(extra[0]));
1686
212k
    if (extra == NULL)
1687
21
        goto error;
1688
212k
    ctxt->nsdb->extra = extra;
1689
1690
212k
    ctxt->nsMax = newSize;
1691
212k
    return(0);
1692
1693
48
error:
1694
48
    xmlErrMemory(ctxt);
1695
48
    return(-1);
1696
212k
}
1697
1698
/**
1699
 * xmlParserNsPush:
1700
 * @ctxt: parser context
1701
 * @prefix: prefix with hash value
1702
 * @uri: uri with hash value
1703
 * @saxData: extra data for SAX handler
1704
 * @defAttr: whether the namespace comes from a default attribute
1705
 *
1706
 * Push a new namespace on the table.
1707
 *
1708
 * Returns 1 if the namespace was pushed, 0 if the namespace was ignored,
1709
 * -1 if a memory allocation failed.
1710
 */
1711
static int
1712
xmlParserNsPush(xmlParserCtxtPtr ctxt, const xmlHashedString *prefix,
1713
1.31M
                const xmlHashedString *uri, void *saxData, int defAttr) {
1714
1.31M
    xmlParserNsBucket *bucket = NULL;
1715
1.31M
    xmlParserNsExtra *extra;
1716
1.31M
    const xmlChar **ns;
1717
1.31M
    unsigned hashValue, nsIndex, oldIndex;
1718
1719
1.31M
    if ((prefix != NULL) && (prefix->name == ctxt->str_xml))
1720
29
        return(0);
1721
1722
1.31M
    if ((ctxt->nsNr >= ctxt->nsMax) && (xmlParserNsGrow(ctxt) < 0)) {
1723
48
        xmlErrMemory(ctxt);
1724
48
        return(-1);
1725
48
    }
1726
1727
    /*
1728
     * Default namespace and 'xml' namespace
1729
     */
1730
1.31M
    if ((prefix == NULL) || (prefix->name == NULL)) {
1731
173k
        oldIndex = ctxt->nsdb->defaultNsIndex;
1732
1733
173k
        if (oldIndex != INT_MAX) {
1734
150k
            extra = &ctxt->nsdb->extra[oldIndex];
1735
1736
150k
            if (extra->elementId == ctxt->nsdb->elementId) {
1737
3.28k
                if (defAttr == 0)
1738
561
                    xmlErrAttributeDup(ctxt, NULL, BAD_CAST "xmlns");
1739
3.28k
                return(0);
1740
3.28k
            }
1741
1742
147k
            if ((ctxt->options & XML_PARSE_NSCLEAN) &&
1743
0
                (uri->name == ctxt->nsTab[oldIndex * 2 + 1]))
1744
0
                return(0);
1745
147k
        }
1746
1747
170k
        ctxt->nsdb->defaultNsIndex = ctxt->nsNr;
1748
170k
        goto populate_entry;
1749
173k
    }
1750
1751
    /*
1752
     * Hash table lookup
1753
     */
1754
1.13M
    oldIndex = xmlParserNsLookup(ctxt, prefix, &bucket);
1755
1.13M
    if (oldIndex != INT_MAX) {
1756
825k
        extra = &ctxt->nsdb->extra[oldIndex];
1757
1758
        /*
1759
         * Check for duplicate definitions on the same element.
1760
         */
1761
825k
        if (extra->elementId == ctxt->nsdb->elementId) {
1762
130
            if (defAttr == 0)
1763
105
                xmlErrAttributeDup(ctxt, BAD_CAST "xmlns", prefix->name);
1764
130
            return(0);
1765
130
        }
1766
1767
825k
        if ((ctxt->options & XML_PARSE_NSCLEAN) &&
1768
0
            (uri->name == ctxt->nsTab[bucket->index * 2 + 1]))
1769
0
            return(0);
1770
1771
825k
        bucket->index = ctxt->nsNr;
1772
825k
        goto populate_entry;
1773
825k
    }
1774
1775
    /*
1776
     * Insert new bucket
1777
     */
1778
1779
312k
    hashValue = prefix->hashValue;
1780
1781
    /*
1782
     * Grow hash table, 50% fill factor
1783
     */
1784
312k
    if (ctxt->nsdb->hashElems + 1 > ctxt->nsdb->hashSize / 2) {
1785
178k
        xmlParserNsBucket *newHash;
1786
178k
        unsigned newSize, i, index;
1787
1788
178k
        if (ctxt->nsdb->hashSize > UINT_MAX / 2) {
1789
0
            xmlErrMemory(ctxt);
1790
0
            return(-1);
1791
0
        }
1792
178k
        newSize = ctxt->nsdb->hashSize ? ctxt->nsdb->hashSize * 2 : 16;
1793
178k
        newHash = xmlMalloc(newSize * sizeof(newHash[0]));
1794
178k
        if (newHash == NULL) {
1795
30
            xmlErrMemory(ctxt);
1796
30
            return(-1);
1797
30
        }
1798
178k
        memset(newHash, 0, newSize * sizeof(newHash[0]));
1799
1800
571k
        for (i = 0; i < ctxt->nsdb->hashSize; i++) {
1801
392k
            unsigned hv = ctxt->nsdb->hash[i].hashValue;
1802
392k
            unsigned newIndex;
1803
1804
392k
            if ((hv == 0) || (ctxt->nsdb->hash[i].index == INT_MAX))
1805
385k
                continue;
1806
7.17k
            newIndex = hv & (newSize - 1);
1807
1808
10.9k
            while (newHash[newIndex].hashValue != 0) {
1809
3.82k
                newIndex++;
1810
3.82k
                if (newIndex == newSize)
1811
902
                    newIndex = 0;
1812
3.82k
            }
1813
1814
7.17k
            newHash[newIndex] = ctxt->nsdb->hash[i];
1815
7.17k
        }
1816
1817
178k
        xmlFree(ctxt->nsdb->hash);
1818
178k
        ctxt->nsdb->hash = newHash;
1819
178k
        ctxt->nsdb->hashSize = newSize;
1820
1821
        /*
1822
         * Relookup
1823
         */
1824
178k
        index = hashValue & (newSize - 1);
1825
1826
179k
        while (newHash[index].hashValue != 0) {
1827
836
            index++;
1828
836
            if (index == newSize)
1829
231
                index = 0;
1830
836
        }
1831
1832
178k
        bucket = &newHash[index];
1833
178k
    }
1834
1835
312k
    bucket->hashValue = hashValue;
1836
312k
    bucket->index = ctxt->nsNr;
1837
312k
    ctxt->nsdb->hashElems++;
1838
312k
    oldIndex = INT_MAX;
1839
1840
1.30M
populate_entry:
1841
1.30M
    nsIndex = ctxt->nsNr;
1842
1843
1.30M
    ns = &ctxt->nsTab[nsIndex * 2];
1844
1.30M
    ns[0] = prefix ? prefix->name : NULL;
1845
1.30M
    ns[1] = uri->name;
1846
1847
1.30M
    extra = &ctxt->nsdb->extra[nsIndex];
1848
1.30M
    extra->saxData = saxData;
1849
1.30M
    extra->prefixHashValue = prefix ? prefix->hashValue : 0;
1850
1.30M
    extra->uriHashValue = uri->hashValue;
1851
1.30M
    extra->elementId = ctxt->nsdb->elementId;
1852
1.30M
    extra->oldIndex = oldIndex;
1853
1854
1.30M
    ctxt->nsNr++;
1855
1856
1.30M
    return(1);
1857
312k
}
1858
1859
/**
1860
 * xmlParserNsPop:
1861
 * @ctxt: an XML parser context
1862
 * @nr:  the number to pop
1863
 *
1864
 * Pops the top @nr namespaces and restores the hash table.
1865
 *
1866
 * Returns the number of namespaces popped.
1867
 */
1868
static int
1869
xmlParserNsPop(xmlParserCtxtPtr ctxt, int nr)
1870
452k
{
1871
452k
    int i;
1872
1873
    /* assert(nr <= ctxt->nsNr); */
1874
1875
1.75M
    for (i = ctxt->nsNr - 1; i >= ctxt->nsNr - nr; i--) {
1876
1.30M
        const xmlChar *prefix = ctxt->nsTab[i * 2];
1877
1.30M
        xmlParserNsExtra *extra = &ctxt->nsdb->extra[i];
1878
1879
1.30M
        if (prefix == NULL) {
1880
169k
            ctxt->nsdb->defaultNsIndex = extra->oldIndex;
1881
1.13M
        } else {
1882
1.13M
            xmlHashedString hprefix;
1883
1.13M
            xmlParserNsBucket *bucket = NULL;
1884
1885
1.13M
            hprefix.name = prefix;
1886
1.13M
            hprefix.hashValue = extra->prefixHashValue;
1887
1.13M
            xmlParserNsLookup(ctxt, &hprefix, &bucket);
1888
            /* assert(bucket && bucket->hashValue); */
1889
1.13M
            bucket->index = extra->oldIndex;
1890
1.13M
        }
1891
1.30M
    }
1892
1893
452k
    ctxt->nsNr -= nr;
1894
452k
    return(nr);
1895
452k
}
1896
1897
static int
1898
260k
xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt) {
1899
260k
    const xmlChar **atts;
1900
260k
    unsigned *attallocs;
1901
260k
    int newSize;
1902
1903
260k
    newSize = xmlGrowCapacity(ctxt->maxatts / 5,
1904
260k
                              sizeof(atts[0]) * 5 + sizeof(attallocs[0]),
1905
260k
                              10, XML_MAX_ATTRS);
1906
260k
    if (newSize < 0) {
1907
0
        xmlFatalErr(ctxt, XML_ERR_RESOURCE_LIMIT,
1908
0
                    "Maximum number of attributes exceeded");
1909
0
        return(-1);
1910
0
    }
1911
1912
260k
    atts = xmlRealloc(ctxt->atts, newSize * sizeof(atts[0]) * 5);
1913
260k
    if (atts == NULL)
1914
27
        goto mem_error;
1915
260k
    ctxt->atts = atts;
1916
1917
260k
    attallocs = xmlRealloc(ctxt->attallocs,
1918
260k
                           newSize * sizeof(attallocs[0]));
1919
260k
    if (attallocs == NULL)
1920
20
        goto mem_error;
1921
260k
    ctxt->attallocs = attallocs;
1922
1923
260k
    ctxt->maxatts = newSize * 5;
1924
1925
260k
    return(0);
1926
1927
47
mem_error:
1928
47
    xmlErrMemory(ctxt);
1929
47
    return(-1);
1930
260k
}
1931
1932
/**
1933
 * xmlCtxtPushInput:
1934
 * @ctxt:  an XML parser context
1935
 * @value:  the parser input
1936
 *
1937
 * Pushes a new parser input on top of the input stack
1938
 *
1939
 * Returns -1 in case of error, the index in the stack otherwise
1940
 */
1941
int
1942
xmlCtxtPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
1943
297k
{
1944
297k
    char *directory = NULL;
1945
297k
    int maxDepth;
1946
1947
297k
    if ((ctxt == NULL) || (value == NULL))
1948
1.20k
        return(-1);
1949
1950
296k
    maxDepth = (ctxt->options & XML_PARSE_HUGE) ? 40 : 20;
1951
1952
296k
    if (ctxt->inputNr >= ctxt->inputMax) {
1953
10.0k
        xmlParserInputPtr *tmp;
1954
10.0k
        int newSize;
1955
1956
10.0k
        newSize = xmlGrowCapacity(ctxt->inputMax, sizeof(tmp[0]),
1957
10.0k
                                  5, maxDepth);
1958
10.0k
        if (newSize < 0) {
1959
0
            xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT,
1960
0
                           "Maximum entity nesting depth exceeded");
1961
0
            xmlHaltParser(ctxt);
1962
0
            return(-1);
1963
0
        }
1964
10.0k
        tmp = xmlRealloc(ctxt->inputTab, newSize * sizeof(tmp[0]));
1965
10.0k
        if (tmp == NULL) {
1966
3
            xmlErrMemory(ctxt);
1967
3
            return(-1);
1968
3
        }
1969
10.0k
        ctxt->inputTab = tmp;
1970
10.0k
        ctxt->inputMax = newSize;
1971
10.0k
    }
1972
1973
296k
    if ((ctxt->inputNr == 0) && (value->filename != NULL)) {
1974
34.4k
        directory = xmlParserGetDirectory(value->filename);
1975
34.4k
        if (directory == NULL) {
1976
0
            xmlErrMemory(ctxt);
1977
0
            return(-1);
1978
0
        }
1979
34.4k
    }
1980
1981
296k
    if (ctxt->input_id >= INT_MAX) {
1982
0
        xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT, "Input ID overflow\n");
1983
0
        return(-1);
1984
0
    }
1985
1986
296k
    ctxt->inputTab[ctxt->inputNr] = value;
1987
296k
    ctxt->input = value;
1988
1989
296k
    if (ctxt->inputNr == 0) {
1990
278k
        xmlFree(ctxt->directory);
1991
278k
        ctxt->directory = directory;
1992
278k
    }
1993
1994
    /*
1995
     * Internally, the input ID is only used to detect parameter entity
1996
     * boundaries. But there are entity loaders in downstream code that
1997
     * detect the main document by checking for "input_id == 1".
1998
     */
1999
296k
    value->id = ctxt->input_id++;
2000
2001
296k
    return(ctxt->inputNr++);
2002
296k
}
2003
2004
/**
2005
 * xmlCtxtPopInput:
2006
 * @ctxt: an XML parser context
2007
 *
2008
 * Pops the top parser input from the input stack
2009
 *
2010
 * Returns the input just removed
2011
 */
2012
xmlParserInputPtr
2013
xmlCtxtPopInput(xmlParserCtxtPtr ctxt)
2014
914k
{
2015
914k
    xmlParserInputPtr ret;
2016
2017
914k
    if (ctxt == NULL)
2018
0
        return(NULL);
2019
914k
    if (ctxt->inputNr <= 0)
2020
624k
        return (NULL);
2021
290k
    ctxt->inputNr--;
2022
290k
    if (ctxt->inputNr > 0)
2023
17.9k
        ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
2024
272k
    else
2025
272k
        ctxt->input = NULL;
2026
290k
    ret = ctxt->inputTab[ctxt->inputNr];
2027
290k
    ctxt->inputTab[ctxt->inputNr] = NULL;
2028
290k
    return (ret);
2029
914k
}
2030
2031
/**
2032
 * nodePush:
2033
 * @ctxt:  an XML parser context
2034
 * @value:  the element node
2035
 *
2036
 * DEPRECATED: Internal function, do not use.
2037
 *
2038
 * Pushes a new element node on top of the node stack
2039
 *
2040
 * Returns -1 in case of error, the index in the stack otherwise
2041
 */
2042
int
2043
nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
2044
2.59M
{
2045
2.59M
    if (ctxt == NULL)
2046
0
        return(0);
2047
2048
2.59M
    if (ctxt->nodeNr >= ctxt->nodeMax) {
2049
243k
        int maxDepth = (ctxt->options & XML_PARSE_HUGE) ? 2048 : 256;
2050
243k
        xmlNodePtr *tmp;
2051
243k
        int newSize;
2052
2053
243k
        newSize = xmlGrowCapacity(ctxt->nodeMax, sizeof(tmp[0]),
2054
243k
                                  10, maxDepth);
2055
243k
        if (newSize < 0) {
2056
71
            xmlFatalErrMsgInt(ctxt, XML_ERR_RESOURCE_LIMIT,
2057
71
                    "Excessive depth in document: %d,"
2058
71
                    " use XML_PARSE_HUGE option\n",
2059
71
                    ctxt->nodeNr);
2060
71
            xmlHaltParser(ctxt);
2061
71
            return(-1);
2062
71
        }
2063
2064
243k
  tmp = xmlRealloc(ctxt->nodeTab, newSize * sizeof(tmp[0]));
2065
243k
        if (tmp == NULL) {
2066
20
            xmlErrMemory(ctxt);
2067
20
            return (-1);
2068
20
        }
2069
243k
        ctxt->nodeTab = tmp;
2070
243k
  ctxt->nodeMax = newSize;
2071
243k
    }
2072
2073
2.59M
    ctxt->nodeTab[ctxt->nodeNr] = value;
2074
2.59M
    ctxt->node = value;
2075
2.59M
    return (ctxt->nodeNr++);
2076
2.59M
}
2077
2078
/**
2079
 * nodePop:
2080
 * @ctxt: an XML parser context
2081
 *
2082
 * DEPRECATED: Internal function, do not use.
2083
 *
2084
 * Pops the top element node from the node stack
2085
 *
2086
 * Returns the node just removed
2087
 */
2088
xmlNodePtr
2089
nodePop(xmlParserCtxtPtr ctxt)
2090
2.94M
{
2091
2.94M
    xmlNodePtr ret;
2092
2093
2.94M
    if (ctxt == NULL) return(NULL);
2094
2.94M
    if (ctxt->nodeNr <= 0)
2095
353k
        return (NULL);
2096
2.59M
    ctxt->nodeNr--;
2097
2.59M
    if (ctxt->nodeNr > 0)
2098
2.40M
        ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
2099
184k
    else
2100
184k
        ctxt->node = NULL;
2101
2.59M
    ret = ctxt->nodeTab[ctxt->nodeNr];
2102
2.59M
    ctxt->nodeTab[ctxt->nodeNr] = NULL;
2103
2.59M
    return (ret);
2104
2.94M
}
2105
2106
/**
2107
 * nameNsPush:
2108
 * @ctxt:  an XML parser context
2109
 * @value:  the element name
2110
 * @prefix:  the element prefix
2111
 * @URI:  the element namespace name
2112
 * @line:  the current line number for error messages
2113
 * @nsNr:  the number of namespaces pushed on the namespace table
2114
 *
2115
 * Pushes a new element name/prefix/URL on top of the name stack
2116
 *
2117
 * Returns -1 in case of error, the index in the stack otherwise
2118
 */
2119
static int
2120
nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
2121
           const xmlChar *prefix, const xmlChar *URI, int line, int nsNr)
2122
3.24M
{
2123
3.24M
    xmlStartTag *tag;
2124
2125
3.24M
    if (ctxt->nameNr >= ctxt->nameMax) {
2126
275k
        const xmlChar **tmp;
2127
275k
        xmlStartTag *tmp2;
2128
275k
        int newSize;
2129
2130
275k
        newSize = xmlGrowCapacity(ctxt->nameMax,
2131
275k
                                  sizeof(tmp[0]) + sizeof(tmp2[0]),
2132
275k
                                  10, XML_MAX_ITEMS);
2133
275k
        if (newSize < 0)
2134
0
            goto mem_error;
2135
2136
275k
        tmp = xmlRealloc(ctxt->nameTab, newSize * sizeof(tmp[0]));
2137
275k
        if (tmp == NULL)
2138
143
      goto mem_error;
2139
275k
  ctxt->nameTab = tmp;
2140
2141
275k
        tmp2 = xmlRealloc(ctxt->pushTab, newSize * sizeof(tmp2[0]));
2142
275k
        if (tmp2 == NULL)
2143
14
      goto mem_error;
2144
275k
  ctxt->pushTab = tmp2;
2145
2146
275k
        ctxt->nameMax = newSize;
2147
2.97M
    } else if (ctxt->pushTab == NULL) {
2148
208k
        ctxt->pushTab = xmlMalloc(ctxt->nameMax * sizeof(ctxt->pushTab[0]));
2149
208k
        if (ctxt->pushTab == NULL)
2150
351
            goto mem_error;
2151
208k
    }
2152
3.24M
    ctxt->nameTab[ctxt->nameNr] = value;
2153
3.24M
    ctxt->name = value;
2154
3.24M
    tag = &ctxt->pushTab[ctxt->nameNr];
2155
3.24M
    tag->prefix = prefix;
2156
3.24M
    tag->URI = URI;
2157
3.24M
    tag->line = line;
2158
3.24M
    tag->nsNr = nsNr;
2159
3.24M
    return (ctxt->nameNr++);
2160
508
mem_error:
2161
508
    xmlErrMemory(ctxt);
2162
508
    return (-1);
2163
3.24M
}
2164
#ifdef LIBXML_PUSH_ENABLED
2165
/**
2166
 * nameNsPop:
2167
 * @ctxt: an XML parser context
2168
 *
2169
 * Pops the top element/prefix/URI name from the name stack
2170
 *
2171
 * Returns the name just removed
2172
 */
2173
static const xmlChar *
2174
nameNsPop(xmlParserCtxtPtr ctxt)
2175
{
2176
    const xmlChar *ret;
2177
2178
    if (ctxt->nameNr <= 0)
2179
        return (NULL);
2180
    ctxt->nameNr--;
2181
    if (ctxt->nameNr > 0)
2182
        ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
2183
    else
2184
        ctxt->name = NULL;
2185
    ret = ctxt->nameTab[ctxt->nameNr];
2186
    ctxt->nameTab[ctxt->nameNr] = NULL;
2187
    return (ret);
2188
}
2189
#endif /* LIBXML_PUSH_ENABLED */
2190
2191
/**
2192
 * namePop:
2193
 * @ctxt: an XML parser context
2194
 *
2195
 * DEPRECATED: Internal function, do not use.
2196
 *
2197
 * Pops the top element name from the name stack
2198
 *
2199
 * Returns the name just removed
2200
 */
2201
static const xmlChar *
2202
namePop(xmlParserCtxtPtr ctxt)
2203
3.23M
{
2204
3.23M
    const xmlChar *ret;
2205
2206
3.23M
    if ((ctxt == NULL) || (ctxt->nameNr <= 0))
2207
120
        return (NULL);
2208
3.23M
    ctxt->nameNr--;
2209
3.23M
    if (ctxt->nameNr > 0)
2210
3.03M
        ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
2211
193k
    else
2212
193k
        ctxt->name = NULL;
2213
3.23M
    ret = ctxt->nameTab[ctxt->nameNr];
2214
3.23M
    ctxt->nameTab[ctxt->nameNr] = NULL;
2215
3.23M
    return (ret);
2216
3.23M
}
2217
2218
6.23M
static int spacePush(xmlParserCtxtPtr ctxt, int val) {
2219
6.23M
    if (ctxt->spaceNr >= ctxt->spaceMax) {
2220
472k
        int *tmp;
2221
472k
        int newSize;
2222
2223
472k
        newSize = xmlGrowCapacity(ctxt->spaceMax, sizeof(tmp[0]),
2224
472k
                                  10, XML_MAX_ITEMS);
2225
472k
        if (newSize < 0) {
2226
0
      xmlErrMemory(ctxt);
2227
0
      return(-1);
2228
0
        }
2229
2230
472k
        tmp = xmlRealloc(ctxt->spaceTab, newSize * sizeof(tmp[0]));
2231
472k
        if (tmp == NULL) {
2232
88
      xmlErrMemory(ctxt);
2233
88
      return(-1);
2234
88
  }
2235
472k
  ctxt->spaceTab = tmp;
2236
2237
472k
        ctxt->spaceMax = newSize;
2238
472k
    }
2239
6.23M
    ctxt->spaceTab[ctxt->spaceNr] = val;
2240
6.23M
    ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
2241
6.23M
    return(ctxt->spaceNr++);
2242
6.23M
}
2243
2244
6.22M
static int spacePop(xmlParserCtxtPtr ctxt) {
2245
6.22M
    int ret;
2246
6.22M
    if (ctxt->spaceNr <= 0) return(0);
2247
6.22M
    ctxt->spaceNr--;
2248
6.22M
    if (ctxt->spaceNr > 0)
2249
6.22M
  ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
2250
63
    else
2251
63
        ctxt->space = &ctxt->spaceTab[0];
2252
6.22M
    ret = ctxt->spaceTab[ctxt->spaceNr];
2253
6.22M
    ctxt->spaceTab[ctxt->spaceNr] = -1;
2254
6.22M
    return(ret);
2255
6.22M
}
2256
2257
/*
2258
 * Macros for accessing the content. Those should be used only by the parser,
2259
 * and not exported.
2260
 *
2261
 * Dirty macros, i.e. one often need to make assumption on the context to
2262
 * use them
2263
 *
2264
 *   CUR_PTR return the current pointer to the xmlChar to be parsed.
2265
 *           To be used with extreme caution since operations consuming
2266
 *           characters may move the input buffer to a different location !
2267
 *   CUR     returns the current xmlChar value, i.e. a 8 bit value if compiled
2268
 *           This should be used internally by the parser
2269
 *           only to compare to ASCII values otherwise it would break when
2270
 *           running with UTF-8 encoding.
2271
 *   RAW     same as CUR but in the input buffer, bypass any token
2272
 *           extraction that may have been done
2273
 *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
2274
 *           to compare on ASCII based substring.
2275
 *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
2276
 *           strings without newlines within the parser.
2277
 *   NEXT1(l) Skip 1 xmlChar, and must also be used only to skip 1 non-newline ASCII
2278
 *           defined char within the parser.
2279
 * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
2280
 *
2281
 *   NEXT    Skip to the next character, this does the proper decoding
2282
 *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
2283
 *   NEXTL(l) Skip the current unicode character of l xmlChars long.
2284
 *   CUR_SCHAR  same but operate on a string instead of the context
2285
 *   COPY_BUF  copy the current unicode char to the target buffer, increment
2286
 *            the index
2287
 *   GROW, SHRINK  handling of input buffers
2288
 */
2289
2290
31.8M
#define RAW (*ctxt->input->cur)
2291
717M
#define CUR (*ctxt->input->cur)
2292
18.7M
#define NXT(val) ctxt->input->cur[(val)]
2293
1.09G
#define CUR_PTR ctxt->input->cur
2294
18.3M
#define BASE_PTR ctxt->input->base
2295
2296
#define CMP4( s, c1, c2, c3, c4 ) \
2297
308M
  ( ((unsigned char *) s)[ 0 ] == c1 && ((unsigned char *) s)[ 1 ] == c2 && \
2298
154M
    ((unsigned char *) s)[ 2 ] == c3 && ((unsigned char *) s)[ 3 ] == c4 )
2299
#define CMP5( s, c1, c2, c3, c4, c5 ) \
2300
307M
  ( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 )
2301
#define CMP6( s, c1, c2, c3, c4, c5, c6 ) \
2302
306M
  ( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 )
2303
#define CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) \
2304
305M
  ( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 )
2305
#define CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) \
2306
305M
  ( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 )
2307
#define CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) \
2308
152M
  ( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \
2309
152M
    ((unsigned char *) s)[ 8 ] == c9 )
2310
#define CMP10( s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ) \
2311
17.0k
  ( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \
2312
17.0k
    ((unsigned char *) s)[ 9 ] == c10 )
2313
2314
2.78M
#define SKIP(val) do {             \
2315
2.78M
    ctxt->input->cur += (val),ctxt->input->col+=(val);      \
2316
2.78M
    if (*ctxt->input->cur == 0)           \
2317
2.78M
        xmlParserGrow(ctxt);           \
2318
2.78M
  } while (0)
2319
2320
#define SKIPL(val) do {             \
2321
    int skipl;                \
2322
    for(skipl=0; skipl<val; skipl++) {          \
2323
  if (*(ctxt->input->cur) == '\n') {        \
2324
  ctxt->input->line++; ctxt->input->col = 1;      \
2325
  } else ctxt->input->col++;          \
2326
  ctxt->input->cur++;           \
2327
    }                 \
2328
    if (*ctxt->input->cur == 0)           \
2329
        xmlParserGrow(ctxt);            \
2330
  } while (0)
2331
2332
#define SHRINK \
2333
298M
    if (!PARSER_PROGRESSIVE(ctxt)) \
2334
298M
  xmlParserShrink(ctxt);
2335
2336
#define GROW \
2337
467M
    if ((!PARSER_PROGRESSIVE(ctxt)) && \
2338
467M
        (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \
2339
10.9M
  xmlParserGrow(ctxt);
2340
2341
8.22M
#define SKIP_BLANKS xmlSkipBlankChars(ctxt)
2342
2343
1.42M
#define SKIP_BLANKS_PE xmlSkipBlankCharsPE(ctxt)
2344
2345
42.7M
#define NEXT xmlNextChar(ctxt)
2346
2347
7.38M
#define NEXT1 {               \
2348
7.38M
  ctxt->input->col++;           \
2349
7.38M
  ctxt->input->cur++;           \
2350
7.38M
  if (*ctxt->input->cur == 0)         \
2351
7.38M
      xmlParserGrow(ctxt);           \
2352
7.38M
    }
2353
2354
981M
#define NEXTL(l) do {             \
2355
981M
    if (*(ctxt->input->cur) == '\n') {         \
2356
87.3M
  ctxt->input->line++; ctxt->input->col = 1;      \
2357
893M
    } else ctxt->input->col++;           \
2358
981M
    ctxt->input->cur += l;        \
2359
981M
  } while (0)
2360
2361
5.02M
#define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
2362
2363
#define COPY_BUF(b, i, v)           \
2364
288M
    if (v < 0x80) b[i++] = v;           \
2365
288M
    else i += xmlCopyCharMultiByte(&b[i],v)
2366
2367
static int
2368
421M
xmlCurrentCharRecover(xmlParserCtxtPtr ctxt, int *len) {
2369
421M
    int c = xmlCurrentChar(ctxt, len);
2370
2371
421M
    if (c == XML_INVALID_CHAR)
2372
71.6M
        c = 0xFFFD; /* replacement character */
2373
2374
421M
    return(c);
2375
421M
}
2376
2377
/**
2378
 * xmlSkipBlankChars:
2379
 * @ctxt:  the XML parser context
2380
 *
2381
 * DEPRECATED: Internal function, do not use.
2382
 *
2383
 * Skip whitespace in the input stream.
2384
 *
2385
 * Returns the number of space chars skipped
2386
 */
2387
int
2388
8.92M
xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
2389
8.92M
    const xmlChar *cur;
2390
8.92M
    int res = 0;
2391
2392
8.92M
    cur = ctxt->input->cur;
2393
8.92M
    while (IS_BLANK_CH(*cur)) {
2394
4.08M
        if (*cur == '\n') {
2395
1.19M
            ctxt->input->line++; ctxt->input->col = 1;
2396
2.89M
        } else {
2397
2.89M
            ctxt->input->col++;
2398
2.89M
        }
2399
4.08M
        cur++;
2400
4.08M
        if (res < INT_MAX)
2401
4.08M
            res++;
2402
4.08M
        if (*cur == 0) {
2403
153k
            ctxt->input->cur = cur;
2404
153k
            xmlParserGrow(ctxt);
2405
153k
            cur = ctxt->input->cur;
2406
153k
        }
2407
4.08M
    }
2408
8.92M
    ctxt->input->cur = cur;
2409
2410
8.92M
    if (res > 4)
2411
62.8k
        GROW;
2412
2413
8.92M
    return(res);
2414
8.92M
}
2415
2416
static void
2417
14.7k
xmlPopPE(xmlParserCtxtPtr ctxt) {
2418
14.7k
    unsigned long consumed;
2419
14.7k
    xmlEntityPtr ent;
2420
2421
14.7k
    ent = ctxt->input->entity;
2422
2423
14.7k
    ent->flags &= ~XML_ENT_EXPANDING;
2424
2425
14.7k
    if ((ent->flags & XML_ENT_CHECKED) == 0) {
2426
6.90k
        int result;
2427
2428
        /*
2429
         * Read the rest of the stream in case of errors. We want
2430
         * to account for the whole entity size.
2431
         */
2432
12.0k
        do {
2433
12.0k
            ctxt->input->cur = ctxt->input->end;
2434
12.0k
            xmlParserShrink(ctxt);
2435
12.0k
            result = xmlParserGrow(ctxt);
2436
12.0k
        } while (result > 0);
2437
2438
6.90k
        consumed = ctxt->input->consumed;
2439
6.90k
        xmlSaturatedAddSizeT(&consumed,
2440
6.90k
                             ctxt->input->end - ctxt->input->base);
2441
2442
6.90k
        xmlSaturatedAdd(&ent->expandedSize, consumed);
2443
2444
        /*
2445
         * Add to sizeentities when parsing an external entity
2446
         * for the first time.
2447
         */
2448
6.90k
        if (ent->etype == XML_EXTERNAL_PARAMETER_ENTITY) {
2449
6.23k
            xmlSaturatedAdd(&ctxt->sizeentities, consumed);
2450
6.23k
        }
2451
2452
6.90k
        ent->flags |= XML_ENT_CHECKED;
2453
6.90k
    }
2454
2455
14.7k
    xmlFreeInputStream(xmlCtxtPopInput(ctxt));
2456
2457
14.7k
    xmlParserEntityCheck(ctxt, ent->expandedSize);
2458
2459
14.7k
    GROW;
2460
14.7k
}
2461
2462
/**
2463
 * xmlSkipBlankCharsPE:
2464
 * @ctxt:  the XML parser context
2465
 *
2466
 * Skip whitespace in the input stream, also handling parameter
2467
 * entities.
2468
 *
2469
 * Returns the number of space chars skipped
2470
 */
2471
static int
2472
1.42M
xmlSkipBlankCharsPE(xmlParserCtxtPtr ctxt) {
2473
1.42M
    int res = 0;
2474
1.42M
    int inParam;
2475
1.42M
    int expandParam;
2476
2477
1.42M
    inParam = PARSER_IN_PE(ctxt);
2478
1.42M
    expandParam = PARSER_EXTERNAL(ctxt);
2479
2480
1.42M
    if (!inParam && !expandParam)
2481
698k
        return(xmlSkipBlankChars(ctxt));
2482
2483
    /*
2484
     * It's Okay to use CUR/NEXT here since all the blanks are on
2485
     * the ASCII range.
2486
     */
2487
1.34M
    while (PARSER_STOPPED(ctxt) == 0) {
2488
1.34M
        if (IS_BLANK_CH(CUR)) { /* CHECKED tstblanks.xml */
2489
591k
            NEXT;
2490
748k
        } else if (CUR == '%') {
2491
36.7k
            if ((expandParam == 0) ||
2492
30.4k
                (IS_BLANK_CH(NXT(1))) || (NXT(1) == 0))
2493
15.6k
                break;
2494
2495
            /*
2496
             * Expand parameter entity. We continue to consume
2497
             * whitespace at the start of the entity and possible
2498
             * even consume the whole entity and pop it. We might
2499
             * even pop multiple PEs in this loop.
2500
             */
2501
21.1k
            xmlParsePEReference(ctxt);
2502
2503
21.1k
            inParam = PARSER_IN_PE(ctxt);
2504
21.1k
            expandParam = PARSER_EXTERNAL(ctxt);
2505
711k
        } else if (CUR == 0) {
2506
12.4k
            if (inParam == 0)
2507
2.13k
                break;
2508
2509
10.3k
            xmlPopPE(ctxt);
2510
2511
10.3k
            inParam = PARSER_IN_PE(ctxt);
2512
10.3k
            expandParam = PARSER_EXTERNAL(ctxt);
2513
699k
        } else {
2514
699k
            break;
2515
699k
        }
2516
2517
        /*
2518
         * Also increase the counter when entering or exiting a PERef.
2519
         * The spec says: "When a parameter-entity reference is recognized
2520
         * in the DTD and included, its replacement text MUST be enlarged
2521
         * by the attachment of one leading and one following space (#x20)
2522
         * character."
2523
         */
2524
622k
        if (res < INT_MAX)
2525
622k
            res++;
2526
622k
    }
2527
2528
724k
    return(res);
2529
1.42M
}
2530
2531
/************************************************************************
2532
 *                  *
2533
 *    Commodity functions to handle entities      *
2534
 *                  *
2535
 ************************************************************************/
2536
2537
/**
2538
 * xmlPopInput:
2539
 * @ctxt:  an XML parser context
2540
 *
2541
 * DEPRECATED: Internal function, don't use.
2542
 *
2543
 * Returns the current xmlChar in the parser context
2544
 */
2545
xmlChar
2546
0
xmlPopInput(xmlParserCtxtPtr ctxt) {
2547
0
    xmlParserInputPtr input;
2548
2549
0
    if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0);
2550
0
    input = xmlCtxtPopInput(ctxt);
2551
0
    xmlFreeInputStream(input);
2552
0
    if (*ctxt->input->cur == 0)
2553
0
        xmlParserGrow(ctxt);
2554
0
    return(CUR);
2555
0
}
2556
2557
/**
2558
 * xmlPushInput:
2559
 * @ctxt:  an XML parser context
2560
 * @input:  an XML parser input fragment (entity, XML fragment ...).
2561
 *
2562
 * DEPRECATED: Internal function, don't use.
2563
 *
2564
 * Push an input stream onto the stack.
2565
 *
2566
 * Returns -1 in case of error or the index in the input stack
2567
 */
2568
int
2569
0
xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
2570
0
    int ret;
2571
2572
0
    if ((ctxt == NULL) || (input == NULL))
2573
0
        return(-1);
2574
2575
0
    ret = xmlCtxtPushInput(ctxt, input);
2576
0
    if (ret >= 0)
2577
0
        GROW;
2578
0
    return(ret);
2579
0
}
2580
2581
/**
2582
 * xmlParseCharRef:
2583
 * @ctxt:  an XML parser context
2584
 *
2585
 * DEPRECATED: Internal function, don't use.
2586
 *
2587
 * Parse a numeric character reference. Always consumes '&'.
2588
 *
2589
 * [66] CharRef ::= '&#' [0-9]+ ';' |
2590
 *                  '&#x' [0-9a-fA-F]+ ';'
2591
 *
2592
 * [ WFC: Legal Character ]
2593
 * Characters referred to using character references must match the
2594
 * production for Char.
2595
 *
2596
 * Returns the value parsed (as an int), 0 in case of error
2597
 */
2598
int
2599
116k
xmlParseCharRef(xmlParserCtxtPtr ctxt) {
2600
116k
    int val = 0;
2601
116k
    int count = 0;
2602
2603
    /*
2604
     * Using RAW/CUR/NEXT is okay since we are working on ASCII range here
2605
     */
2606
116k
    if ((RAW == '&') && (NXT(1) == '#') &&
2607
116k
        (NXT(2) == 'x')) {
2608
16.8k
  SKIP(3);
2609
16.8k
  GROW;
2610
57.8k
  while ((RAW != ';') && (PARSER_STOPPED(ctxt) == 0)) {
2611
44.2k
      if (count++ > 20) {
2612
256
    count = 0;
2613
256
    GROW;
2614
256
      }
2615
44.2k
      if ((RAW >= '0') && (RAW <= '9'))
2616
29.3k
          val = val * 16 + (CUR - '0');
2617
14.9k
      else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20))
2618
6.24k
          val = val * 16 + (CUR - 'a') + 10;
2619
8.68k
      else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20))
2620
5.41k
          val = val * 16 + (CUR - 'A') + 10;
2621
3.27k
      else {
2622
3.27k
    xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2623
3.27k
    val = 0;
2624
3.27k
    break;
2625
3.27k
      }
2626
40.9k
      if (val > 0x110000)
2627
4.49k
          val = 0x110000;
2628
2629
40.9k
      NEXT;
2630
40.9k
      count++;
2631
40.9k
  }
2632
16.8k
  if (RAW == ';') {
2633
      /* on purpose to avoid reentrancy problems with NEXT and SKIP */
2634
13.5k
      ctxt->input->col++;
2635
13.5k
      ctxt->input->cur++;
2636
13.5k
  }
2637
99.5k
    } else if  ((RAW == '&') && (NXT(1) == '#')) {
2638
99.5k
  SKIP(2);
2639
99.5k
  GROW;
2640
295k
  while (RAW != ';') { /* loop blocked by count */
2641
198k
      if (count++ > 20) {
2642
1.89k
    count = 0;
2643
1.89k
    GROW;
2644
1.89k
      }
2645
198k
      if ((RAW >= '0') && (RAW <= '9'))
2646
196k
          val = val * 10 + (CUR - '0');
2647
2.46k
      else {
2648
2.46k
    xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2649
2.46k
    val = 0;
2650
2.46k
    break;
2651
2.46k
      }
2652
196k
      if (val > 0x110000)
2653
19.4k
          val = 0x110000;
2654
2655
196k
      NEXT;
2656
196k
      count++;
2657
196k
  }
2658
99.5k
  if (RAW == ';') {
2659
      /* on purpose to avoid reentrancy problems with NEXT and SKIP */
2660
97.0k
      ctxt->input->col++;
2661
97.0k
      ctxt->input->cur++;
2662
97.0k
  }
2663
99.5k
    } else {
2664
0
        if (RAW == '&')
2665
0
            SKIP(1);
2666
0
        xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2667
0
    }
2668
2669
    /*
2670
     * [ WFC: Legal Character ]
2671
     * Characters referred to using character references must match the
2672
     * production for Char.
2673
     */
2674
116k
    if (val >= 0x110000) {
2675
281
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2676
281
                "xmlParseCharRef: character reference out of bounds\n",
2677
281
          val);
2678
116k
    } else if (IS_CHAR(val)) {
2679
103k
        return(val);
2680
103k
    } else {
2681
12.8k
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2682
12.8k
                          "xmlParseCharRef: invalid xmlChar value %d\n",
2683
12.8k
                    val);
2684
12.8k
    }
2685
13.1k
    return(0);
2686
116k
}
2687
2688
/**
2689
 * xmlParseStringCharRef:
2690
 * @ctxt:  an XML parser context
2691
 * @str:  a pointer to an index in the string
2692
 *
2693
 * parse Reference declarations, variant parsing from a string rather
2694
 * than an an input flow.
2695
 *
2696
 * [66] CharRef ::= '&#' [0-9]+ ';' |
2697
 *                  '&#x' [0-9a-fA-F]+ ';'
2698
 *
2699
 * [ WFC: Legal Character ]
2700
 * Characters referred to using character references must match the
2701
 * production for Char.
2702
 *
2703
 * Returns the value parsed (as an int), 0 in case of error, str will be
2704
 *         updated to the current value of the index
2705
 */
2706
static int
2707
77.5k
xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
2708
77.5k
    const xmlChar *ptr;
2709
77.5k
    xmlChar cur;
2710
77.5k
    int val = 0;
2711
2712
77.5k
    if ((str == NULL) || (*str == NULL)) return(0);
2713
77.5k
    ptr = *str;
2714
77.5k
    cur = *ptr;
2715
77.5k
    if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) {
2716
66.8k
  ptr += 3;
2717
66.8k
  cur = *ptr;
2718
302k
  while (cur != ';') { /* Non input consuming loop */
2719
237k
      if ((cur >= '0') && (cur <= '9'))
2720
180k
          val = val * 16 + (cur - '0');
2721
56.5k
      else if ((cur >= 'a') && (cur <= 'f'))
2722
2.08k
          val = val * 16 + (cur - 'a') + 10;
2723
54.4k
      else if ((cur >= 'A') && (cur <= 'F'))
2724
52.7k
          val = val * 16 + (cur - 'A') + 10;
2725
1.67k
      else {
2726
1.67k
    xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2727
1.67k
    val = 0;
2728
1.67k
    break;
2729
1.67k
      }
2730
235k
      if (val > 0x110000)
2731
125
          val = 0x110000;
2732
2733
235k
      ptr++;
2734
235k
      cur = *ptr;
2735
235k
  }
2736
66.8k
  if (cur == ';')
2737
65.2k
      ptr++;
2738
66.8k
    } else if  ((cur == '&') && (ptr[1] == '#')){
2739
10.6k
  ptr += 2;
2740
10.6k
  cur = *ptr;
2741
35.8k
  while (cur != ';') { /* Non input consuming loops */
2742
25.9k
      if ((cur >= '0') && (cur <= '9'))
2743
25.2k
          val = val * 10 + (cur - '0');
2744
653
      else {
2745
653
    xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2746
653
    val = 0;
2747
653
    break;
2748
653
      }
2749
25.2k
      if (val > 0x110000)
2750
271
          val = 0x110000;
2751
2752
25.2k
      ptr++;
2753
25.2k
      cur = *ptr;
2754
25.2k
  }
2755
10.6k
  if (cur == ';')
2756
9.96k
      ptr++;
2757
10.6k
    } else {
2758
0
  xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2759
0
  return(0);
2760
0
    }
2761
77.5k
    *str = ptr;
2762
2763
    /*
2764
     * [ WFC: Legal Character ]
2765
     * Characters referred to using character references must match the
2766
     * production for Char.
2767
     */
2768
77.5k
    if (val >= 0x110000) {
2769
21
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2770
21
                "xmlParseStringCharRef: character reference out of bounds\n",
2771
21
                val);
2772
77.4k
    } else if (IS_CHAR(val)) {
2773
74.3k
        return(val);
2774
74.3k
    } else {
2775
3.09k
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2776
3.09k
        "xmlParseStringCharRef: invalid xmlChar value %d\n",
2777
3.09k
        val);
2778
3.09k
    }
2779
3.11k
    return(0);
2780
77.5k
}
2781
2782
/**
2783
 * xmlParserHandlePEReference:
2784
 * @ctxt:  the parser context
2785
 *
2786
 * DEPRECATED: Internal function, do not use.
2787
 *
2788
 * [69] PEReference ::= '%' Name ';'
2789
 *
2790
 * [ WFC: No Recursion ]
2791
 * A parsed entity must not contain a recursive
2792
 * reference to itself, either directly or indirectly.
2793
 *
2794
 * [ WFC: Entity Declared ]
2795
 * In a document without any DTD, a document with only an internal DTD
2796
 * subset which contains no parameter entity references, or a document
2797
 * with "standalone='yes'", ...  ... The declaration of a parameter
2798
 * entity must precede any reference to it...
2799
 *
2800
 * [ VC: Entity Declared ]
2801
 * In a document with an external subset or external parameter entities
2802
 * with "standalone='no'", ...  ... The declaration of a parameter entity
2803
 * must precede any reference to it...
2804
 *
2805
 * [ WFC: In DTD ]
2806
 * Parameter-entity references may only appear in the DTD.
2807
 * NOTE: misleading but this is handled.
2808
 *
2809
 * A PEReference may have been detected in the current input stream
2810
 * the handling is done accordingly to
2811
 *      http://www.w3.org/TR/REC-xml#entproc
2812
 * i.e.
2813
 *   - Included in literal in entity values
2814
 *   - Included as Parameter Entity reference within DTDs
2815
 */
2816
void
2817
0
xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
2818
0
    xmlParsePEReference(ctxt);
2819
0
}
2820
2821
/**
2822
 * xmlStringLenDecodeEntities:
2823
 * @ctxt:  the parser context
2824
 * @str:  the input string
2825
 * @len: the string length
2826
 * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2827
 * @end:  an end marker xmlChar, 0 if none
2828
 * @end2:  an end marker xmlChar, 0 if none
2829
 * @end3:  an end marker xmlChar, 0 if none
2830
 *
2831
 * DEPRECATED: Internal function, don't use.
2832
 *
2833
 * Returns A newly allocated string with the substitution done. The caller
2834
 *      must deallocate it !
2835
 */
2836
xmlChar *
2837
xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2838
                           int what ATTRIBUTE_UNUSED,
2839
0
                           xmlChar end, xmlChar end2, xmlChar end3) {
2840
0
    if ((ctxt == NULL) || (str == NULL) || (len < 0))
2841
0
        return(NULL);
2842
2843
0
    if ((str[len] != 0) ||
2844
0
        (end != 0) || (end2 != 0) || (end3 != 0))
2845
0
        return(NULL);
2846
2847
0
    return(xmlExpandEntitiesInAttValue(ctxt, str, 0));
2848
0
}
2849
2850
/**
2851
 * xmlStringDecodeEntities:
2852
 * @ctxt:  the parser context
2853
 * @str:  the input string
2854
 * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2855
 * @end:  an end marker xmlChar, 0 if none
2856
 * @end2:  an end marker xmlChar, 0 if none
2857
 * @end3:  an end marker xmlChar, 0 if none
2858
 *
2859
 * DEPRECATED: Internal function, don't use.
2860
 *
2861
 * Returns A newly allocated string with the substitution done. The caller
2862
 *      must deallocate it !
2863
 */
2864
xmlChar *
2865
xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str,
2866
                        int what ATTRIBUTE_UNUSED,
2867
0
            xmlChar end, xmlChar  end2, xmlChar end3) {
2868
0
    if ((ctxt == NULL) || (str == NULL))
2869
0
        return(NULL);
2870
2871
0
    if ((end != 0) || (end2 != 0) || (end3 != 0))
2872
0
        return(NULL);
2873
2874
0
    return(xmlExpandEntitiesInAttValue(ctxt, str, 0));
2875
0
}
2876
2877
/************************************************************************
2878
 *                  *
2879
 *    Commodity functions, cleanup needed ?     *
2880
 *                  *
2881
 ************************************************************************/
2882
2883
/**
2884
 * areBlanks:
2885
 * @ctxt:  an XML parser context
2886
 * @str:  a xmlChar *
2887
 * @len:  the size of @str
2888
 * @blank_chars: we know the chars are blanks
2889
 *
2890
 * Is this a sequence of blank chars that one can ignore ?
2891
 *
2892
 * Returns 1 if ignorable 0 otherwise.
2893
 */
2894
2895
static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2896
0
                     int blank_chars) {
2897
0
    int i;
2898
0
    xmlNodePtr lastChild;
2899
2900
    /*
2901
     * Check for xml:space value.
2902
     */
2903
0
    if ((ctxt->space == NULL) || (*(ctxt->space) == 1) ||
2904
0
        (*(ctxt->space) == -2))
2905
0
  return(0);
2906
2907
    /*
2908
     * Check that the string is made of blanks
2909
     */
2910
0
    if (blank_chars == 0) {
2911
0
  for (i = 0;i < len;i++)
2912
0
      if (!(IS_BLANK_CH(str[i]))) return(0);
2913
0
    }
2914
2915
    /*
2916
     * Look if the element is mixed content in the DTD if available
2917
     */
2918
0
    if (ctxt->node == NULL) return(0);
2919
0
    if (ctxt->myDoc != NULL) {
2920
0
        xmlElementPtr elemDecl = NULL;
2921
0
        xmlDocPtr doc = ctxt->myDoc;
2922
0
        const xmlChar *prefix = NULL;
2923
2924
0
        if (ctxt->node->ns)
2925
0
            prefix = ctxt->node->ns->prefix;
2926
0
        if (doc->intSubset != NULL)
2927
0
            elemDecl = xmlHashLookup2(doc->intSubset->elements, ctxt->node->name,
2928
0
                                      prefix);
2929
0
        if ((elemDecl == NULL) && (doc->extSubset != NULL))
2930
0
            elemDecl = xmlHashLookup2(doc->extSubset->elements, ctxt->node->name,
2931
0
                                      prefix);
2932
0
        if (elemDecl != NULL) {
2933
0
            if (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT)
2934
0
                return(1);
2935
0
            if ((elemDecl->etype == XML_ELEMENT_TYPE_ANY) ||
2936
0
                (elemDecl->etype == XML_ELEMENT_TYPE_MIXED))
2937
0
                return(0);
2938
0
        }
2939
0
    }
2940
2941
    /*
2942
     * Otherwise, heuristic :-\
2943
     *
2944
     * When push parsing, we could be at the end of a chunk.
2945
     * This makes the look-ahead and consequently the NOBLANKS
2946
     * option unreliable.
2947
     */
2948
0
    if ((RAW != '<') && (RAW != 0xD)) return(0);
2949
0
    if ((ctxt->node->children == NULL) &&
2950
0
  (RAW == '<') && (NXT(1) == '/')) return(0);
2951
2952
0
    lastChild = xmlGetLastChild(ctxt->node);
2953
0
    if (lastChild == NULL) {
2954
0
        if ((ctxt->node->type != XML_ELEMENT_NODE) &&
2955
0
            (ctxt->node->content != NULL)) return(0);
2956
0
    } else if (xmlNodeIsText(lastChild))
2957
0
        return(0);
2958
0
    else if ((ctxt->node->children != NULL) &&
2959
0
             (xmlNodeIsText(ctxt->node->children)))
2960
0
        return(0);
2961
0
    return(1);
2962
0
}
2963
2964
/************************************************************************
2965
 *                  *
2966
 *    Extra stuff for namespace support     *
2967
 *  Relates to http://www.w3.org/TR/WD-xml-names      *
2968
 *                  *
2969
 ************************************************************************/
2970
2971
/**
2972
 * xmlSplitQName:
2973
 * @ctxt:  an XML parser context
2974
 * @name:  an XML parser context
2975
 * @prefixOut:  a xmlChar **
2976
 *
2977
 * DEPRECATED: Don't use.
2978
 *
2979
 * parse an UTF8 encoded XML qualified name string
2980
 *
2981
 * [NS 5] QName ::= (Prefix ':')? LocalPart
2982
 *
2983
 * [NS 6] Prefix ::= NCName
2984
 *
2985
 * [NS 7] LocalPart ::= NCName
2986
 *
2987
 * Returns the local part, and prefix is updated
2988
 *   to get the Prefix if any.
2989
 */
2990
2991
xmlChar *
2992
0
xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefixOut) {
2993
0
    xmlChar buf[XML_MAX_NAMELEN + 5];
2994
0
    xmlChar *buffer = NULL;
2995
0
    int len = 0;
2996
0
    int max = XML_MAX_NAMELEN;
2997
0
    xmlChar *ret = NULL;
2998
0
    xmlChar *prefix;
2999
0
    const xmlChar *cur = name;
3000
0
    int c;
3001
3002
0
    if (prefixOut == NULL) return(NULL);
3003
0
    *prefixOut = NULL;
3004
3005
0
    if (cur == NULL) return(NULL);
3006
3007
    /* nasty but well=formed */
3008
0
    if (cur[0] == ':')
3009
0
  return(xmlStrdup(name));
3010
3011
0
    c = *cur++;
3012
0
    while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */
3013
0
  buf[len++] = c;
3014
0
  c = *cur++;
3015
0
    }
3016
0
    if (len >= max) {
3017
  /*
3018
   * Okay someone managed to make a huge name, so he's ready to pay
3019
   * for the processing speed.
3020
   */
3021
0
  max = len * 2;
3022
3023
0
  buffer = xmlMalloc(max);
3024
0
  if (buffer == NULL) {
3025
0
      xmlErrMemory(ctxt);
3026
0
      return(NULL);
3027
0
  }
3028
0
  memcpy(buffer, buf, len);
3029
0
  while ((c != 0) && (c != ':')) { /* tested bigname.xml */
3030
0
      if (len + 10 > max) {
3031
0
          xmlChar *tmp;
3032
0
                int newSize;
3033
3034
0
                newSize = xmlGrowCapacity(max, 1, 1, XML_MAX_ITEMS);
3035
0
                if (newSize < 0) {
3036
0
        xmlErrMemory(ctxt);
3037
0
        xmlFree(buffer);
3038
0
        return(NULL);
3039
0
                }
3040
0
    tmp = xmlRealloc(buffer, newSize);
3041
0
    if (tmp == NULL) {
3042
0
        xmlErrMemory(ctxt);
3043
0
        xmlFree(buffer);
3044
0
        return(NULL);
3045
0
    }
3046
0
    buffer = tmp;
3047
0
    max = newSize;
3048
0
      }
3049
0
      buffer[len++] = c;
3050
0
      c = *cur++;
3051
0
  }
3052
0
  buffer[len] = 0;
3053
0
    }
3054
3055
0
    if ((c == ':') && (*cur == 0)) {
3056
0
        if (buffer != NULL)
3057
0
      xmlFree(buffer);
3058
0
  return(xmlStrdup(name));
3059
0
    }
3060
3061
0
    if (buffer == NULL) {
3062
0
  ret = xmlStrndup(buf, len);
3063
0
        if (ret == NULL) {
3064
0
      xmlErrMemory(ctxt);
3065
0
      return(NULL);
3066
0
        }
3067
0
    } else {
3068
0
  ret = buffer;
3069
0
  buffer = NULL;
3070
0
  max = XML_MAX_NAMELEN;
3071
0
    }
3072
3073
3074
0
    if (c == ':') {
3075
0
  c = *cur;
3076
0
        prefix = ret;
3077
0
  if (c == 0) {
3078
0
      ret = xmlStrndup(BAD_CAST "", 0);
3079
0
            if (ret == NULL) {
3080
0
                xmlFree(prefix);
3081
0
                return(NULL);
3082
0
            }
3083
0
            *prefixOut = prefix;
3084
0
            return(ret);
3085
0
  }
3086
0
  len = 0;
3087
3088
  /*
3089
   * Check that the first character is proper to start
3090
   * a new name
3091
   */
3092
0
  if (!(((c >= 0x61) && (c <= 0x7A)) ||
3093
0
        ((c >= 0x41) && (c <= 0x5A)) ||
3094
0
        (c == '_') || (c == ':'))) {
3095
0
      int l;
3096
0
      int first = CUR_SCHAR(cur, l);
3097
3098
0
      if (!IS_LETTER(first) && (first != '_')) {
3099
0
    xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
3100
0
          "Name %s is not XML Namespace compliant\n",
3101
0
          name);
3102
0
      }
3103
0
  }
3104
0
  cur++;
3105
3106
0
  while ((c != 0) && (len < max)) { /* tested bigname2.xml */
3107
0
      buf[len++] = c;
3108
0
      c = *cur++;
3109
0
  }
3110
0
  if (len >= max) {
3111
      /*
3112
       * Okay someone managed to make a huge name, so he's ready to pay
3113
       * for the processing speed.
3114
       */
3115
0
      max = len * 2;
3116
3117
0
      buffer = xmlMalloc(max);
3118
0
      if (buffer == NULL) {
3119
0
          xmlErrMemory(ctxt);
3120
0
                xmlFree(prefix);
3121
0
    return(NULL);
3122
0
      }
3123
0
      memcpy(buffer, buf, len);
3124
0
      while (c != 0) { /* tested bigname2.xml */
3125
0
    if (len + 10 > max) {
3126
0
        xmlChar *tmp;
3127
0
                    int newSize;
3128
3129
0
                    newSize = xmlGrowCapacity(max, 1, 1, XML_MAX_ITEMS);
3130
0
                    if (newSize < 0) {
3131
0
                        xmlErrMemory(ctxt);
3132
0
                        xmlFree(buffer);
3133
0
                        return(NULL);
3134
0
                    }
3135
0
        tmp = xmlRealloc(buffer, newSize);
3136
0
        if (tmp == NULL) {
3137
0
      xmlErrMemory(ctxt);
3138
0
                        xmlFree(prefix);
3139
0
      xmlFree(buffer);
3140
0
      return(NULL);
3141
0
        }
3142
0
        buffer = tmp;
3143
0
                    max = newSize;
3144
0
    }
3145
0
    buffer[len++] = c;
3146
0
    c = *cur++;
3147
0
      }
3148
0
      buffer[len] = 0;
3149
0
  }
3150
3151
0
  if (buffer == NULL) {
3152
0
      ret = xmlStrndup(buf, len);
3153
0
            if (ret == NULL) {
3154
0
                xmlFree(prefix);
3155
0
                return(NULL);
3156
0
            }
3157
0
  } else {
3158
0
      ret = buffer;
3159
0
  }
3160
3161
0
        *prefixOut = prefix;
3162
0
    }
3163
3164
0
    return(ret);
3165
0
}
3166
3167
/************************************************************************
3168
 *                  *
3169
 *      The parser itself       *
3170
 *  Relates to http://www.w3.org/TR/REC-xml       *
3171
 *                  *
3172
 ************************************************************************/
3173
3174
/************************************************************************
3175
 *                  *
3176
 *  Routines to parse Name, NCName and NmToken      *
3177
 *                  *
3178
 ************************************************************************/
3179
3180
/*
3181
 * The two following functions are related to the change of accepted
3182
 * characters for Name and NmToken in the Revision 5 of XML-1.0
3183
 * They correspond to the modified production [4] and the new production [4a]
3184
 * changes in that revision. Also note that the macros used for the
3185
 * productions Letter, Digit, CombiningChar and Extender are not needed
3186
 * anymore.
3187
 * We still keep compatibility to pre-revision5 parsing semantic if the
3188
 * new XML_PARSE_OLD10 option is given to the parser.
3189
 */
3190
static int
3191
5.05M
xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) {
3192
5.05M
    if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3193
        /*
3194
   * Use the new checks of production [4] [4a] amd [5] of the
3195
   * Update 5 of XML-1.0
3196
   */
3197
5.05M
  if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3198
5.05M
      (((c >= 'a') && (c <= 'z')) ||
3199
4.75M
       ((c >= 'A') && (c <= 'Z')) ||
3200
4.74M
       (c == '_') || (c == ':') ||
3201
4.73M
       ((c >= 0xC0) && (c <= 0xD6)) ||
3202
4.73M
       ((c >= 0xD8) && (c <= 0xF6)) ||
3203
4.72M
       ((c >= 0xF8) && (c <= 0x2FF)) ||
3204
4.72M
       ((c >= 0x370) && (c <= 0x37D)) ||
3205
4.72M
       ((c >= 0x37F) && (c <= 0x1FFF)) ||
3206
4.72M
       ((c >= 0x200C) && (c <= 0x200D)) ||
3207
4.72M
       ((c >= 0x2070) && (c <= 0x218F)) ||
3208
4.72M
       ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3209
4.72M
       ((c >= 0x3001) && (c <= 0xD7FF)) ||
3210
4.71M
       ((c >= 0xF900) && (c <= 0xFDCF)) ||
3211
4.71M
       ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3212
4.71M
       ((c >= 0x10000) && (c <= 0xEFFFF))))
3213
340k
      return(1);
3214
5.05M
    } else {
3215
0
        if (IS_LETTER(c) || (c == '_') || (c == ':'))
3216
0
      return(1);
3217
0
    }
3218
4.71M
    return(0);
3219
5.05M
}
3220
3221
static int
3222
24.4M
xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) {
3223
24.4M
    if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3224
        /*
3225
   * Use the new checks of production [4] [4a] amd [5] of the
3226
   * Update 5 of XML-1.0
3227
   */
3228
24.4M
  if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3229
24.4M
      (((c >= 'a') && (c <= 'z')) ||
3230
11.1M
       ((c >= 'A') && (c <= 'Z')) ||
3231
10.8M
       ((c >= '0') && (c <= '9')) || /* !start */
3232
10.7M
       (c == '_') || (c == ':') ||
3233
10.6M
       (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
3234
10.6M
       ((c >= 0xC0) && (c <= 0xD6)) ||
3235
10.5M
       ((c >= 0xD8) && (c <= 0xF6)) ||
3236
10.4M
       ((c >= 0xF8) && (c <= 0x2FF)) ||
3237
10.4M
       ((c >= 0x300) && (c <= 0x36F)) || /* !start */
3238
10.4M
       ((c >= 0x370) && (c <= 0x37D)) ||
3239
10.4M
       ((c >= 0x37F) && (c <= 0x1FFF)) ||
3240
9.94M
       ((c >= 0x200C) && (c <= 0x200D)) ||
3241
9.94M
       ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
3242
9.94M
       ((c >= 0x2070) && (c <= 0x218F)) ||
3243
7.66M
       ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3244
7.66M
       ((c >= 0x3001) && (c <= 0xD7FF)) ||
3245
7.10M
       ((c >= 0xF900) && (c <= 0xFDCF)) ||
3246
7.10M
       ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3247
347k
       ((c >= 0x10000) && (c <= 0xEFFFF))))
3248
24.1M
       return(1);
3249
24.4M
    } else {
3250
0
        if ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
3251
0
            (c == '.') || (c == '-') ||
3252
0
      (c == '_') || (c == ':') ||
3253
0
      (IS_COMBINING(c)) ||
3254
0
      (IS_EXTENDER(c)))
3255
0
      return(1);
3256
0
    }
3257
346k
    return(0);
3258
24.4M
}
3259
3260
static const xmlChar *
3261
279k
xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
3262
279k
    const xmlChar *ret;
3263
279k
    int len = 0, l;
3264
279k
    int c;
3265
279k
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
3266
0
                    XML_MAX_TEXT_LENGTH :
3267
279k
                    XML_MAX_NAME_LENGTH;
3268
3269
    /*
3270
     * Handler for more complex cases
3271
     */
3272
279k
    c = xmlCurrentChar(ctxt, &l);
3273
279k
    if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3274
        /*
3275
   * Use the new checks of production [4] [4a] amd [5] of the
3276
   * Update 5 of XML-1.0
3277
   */
3278
279k
  if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
3279
227k
      (!(((c >= 'a') && (c <= 'z')) ||
3280
181k
         ((c >= 'A') && (c <= 'Z')) ||
3281
178k
         (c == '_') || (c == ':') ||
3282
169k
         ((c >= 0xC0) && (c <= 0xD6)) ||
3283
167k
         ((c >= 0xD8) && (c <= 0xF6)) ||
3284
164k
         ((c >= 0xF8) && (c <= 0x2FF)) ||
3285
163k
         ((c >= 0x370) && (c <= 0x37D)) ||
3286
163k
         ((c >= 0x37F) && (c <= 0x1FFF)) ||
3287
162k
         ((c >= 0x200C) && (c <= 0x200D)) ||
3288
160k
         ((c >= 0x2070) && (c <= 0x218F)) ||
3289
160k
         ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3290
159k
         ((c >= 0x3001) && (c <= 0xD7FF)) ||
3291
159k
         ((c >= 0xF900) && (c <= 0xFDCF)) ||
3292
159k
         ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3293
198k
         ((c >= 0x10000) && (c <= 0xEFFFF))))) {
3294
198k
      return(NULL);
3295
198k
  }
3296
81.5k
  len += l;
3297
81.5k
  NEXTL(l);
3298
81.5k
  c = xmlCurrentChar(ctxt, &l);
3299
17.5M
  while ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3300
17.5M
         (((c >= 'a') && (c <= 'z')) ||
3301
6.65M
          ((c >= 'A') && (c <= 'Z')) ||
3302
5.43M
          ((c >= '0') && (c <= '9')) || /* !start */
3303
5.32M
          (c == '_') || (c == ':') ||
3304
5.18M
          (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
3305
5.16M
          ((c >= 0xC0) && (c <= 0xD6)) ||
3306
5.16M
          ((c >= 0xD8) && (c <= 0xF6)) ||
3307
5.16M
          ((c >= 0xF8) && (c <= 0x2FF)) ||
3308
5.13M
          ((c >= 0x300) && (c <= 0x36F)) || /* !start */
3309
5.13M
          ((c >= 0x370) && (c <= 0x37D)) ||
3310
5.13M
          ((c >= 0x37F) && (c <= 0x1FFF)) ||
3311
1.66M
          ((c >= 0x200C) && (c <= 0x200D)) ||
3312
1.66M
          ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
3313
1.66M
          ((c >= 0x2070) && (c <= 0x218F)) ||
3314
1.55M
          ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3315
1.55M
          ((c >= 0x3001) && (c <= 0xD7FF)) ||
3316
740k
          ((c >= 0xF900) && (c <= 0xFDCF)) ||
3317
738k
          ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3318
72.7k
          ((c >= 0x10000) && (c <= 0xEFFFF))
3319
17.5M
    )) {
3320
17.5M
            if (len <= INT_MAX - l)
3321
17.5M
          len += l;
3322
17.5M
      NEXTL(l);
3323
17.5M
      c = xmlCurrentChar(ctxt, &l);
3324
17.5M
  }
3325
81.5k
    } else {
3326
0
  if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
3327
0
      (!IS_LETTER(c) && (c != '_') &&
3328
0
       (c != ':'))) {
3329
0
      return(NULL);
3330
0
  }
3331
0
  len += l;
3332
0
  NEXTL(l);
3333
0
  c = xmlCurrentChar(ctxt, &l);
3334
3335
0
  while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
3336
0
         ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
3337
0
    (c == '.') || (c == '-') ||
3338
0
    (c == '_') || (c == ':') ||
3339
0
    (IS_COMBINING(c)) ||
3340
0
    (IS_EXTENDER(c)))) {
3341
0
            if (len <= INT_MAX - l)
3342
0
          len += l;
3343
0
      NEXTL(l);
3344
0
      c = xmlCurrentChar(ctxt, &l);
3345
0
  }
3346
0
    }
3347
81.5k
    if (len > maxLength) {
3348
336
        xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
3349
336
        return(NULL);
3350
336
    }
3351
81.1k
    if (ctxt->input->cur - ctxt->input->base < len) {
3352
        /*
3353
         * There were a couple of bugs where PERefs lead to to a change
3354
         * of the buffer. Check the buffer size to avoid passing an invalid
3355
         * pointer to xmlDictLookup.
3356
         */
3357
0
        xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
3358
0
                    "unexpected change of input buffer");
3359
0
        return (NULL);
3360
0
    }
3361
81.1k
    if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
3362
254
        ret = xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len);
3363
80.9k
    else
3364
80.9k
        ret = xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len);
3365
81.1k
    if (ret == NULL)
3366
3
        xmlErrMemory(ctxt);
3367
81.1k
    return(ret);
3368
81.1k
}
3369
3370
/**
3371
 * xmlParseName:
3372
 * @ctxt:  an XML parser context
3373
 *
3374
 * DEPRECATED: Internal function, don't use.
3375
 *
3376
 * parse an XML name.
3377
 *
3378
 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
3379
 *                  CombiningChar | Extender
3380
 *
3381
 * [5] Name ::= (Letter | '_' | ':') (NameChar)*
3382
 *
3383
 * [6] Names ::= Name (#x20 Name)*
3384
 *
3385
 * Returns the Name parsed or NULL
3386
 */
3387
3388
const xmlChar *
3389
982k
xmlParseName(xmlParserCtxtPtr ctxt) {
3390
982k
    const xmlChar *in;
3391
982k
    const xmlChar *ret;
3392
982k
    size_t count = 0;
3393
982k
    size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ?
3394
0
                       XML_MAX_TEXT_LENGTH :
3395
982k
                       XML_MAX_NAME_LENGTH;
3396
3397
982k
    GROW;
3398
3399
    /*
3400
     * Accelerator for simple ASCII names
3401
     */
3402
982k
    in = ctxt->input->cur;
3403
982k
    if (((*in >= 0x61) && (*in <= 0x7A)) ||
3404
315k
  ((*in >= 0x41) && (*in <= 0x5A)) ||
3405
760k
  (*in == '_') || (*in == ':')) {
3406
760k
  in++;
3407
33.6M
  while (((*in >= 0x61) && (*in <= 0x7A)) ||
3408
4.37M
         ((*in >= 0x41) && (*in <= 0x5A)) ||
3409
1.05M
         ((*in >= 0x30) && (*in <= 0x39)) ||
3410
887k
         (*in == '_') || (*in == '-') ||
3411
853k
         (*in == ':') || (*in == '.'))
3412
32.8M
      in++;
3413
760k
  if ((*in > 0) && (*in < 0x80)) {
3414
702k
      count = in - ctxt->input->cur;
3415
702k
            if (count > maxLength) {
3416
272
                xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
3417
272
                return(NULL);
3418
272
            }
3419
702k
      ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3420
702k
      ctxt->input->cur = in;
3421
702k
      ctxt->input->col += count;
3422
702k
      if (ret == NULL)
3423
3
          xmlErrMemory(ctxt);
3424
702k
      return(ret);
3425
702k
  }
3426
760k
    }
3427
    /* accelerator for special cases */
3428
279k
    return(xmlParseNameComplex(ctxt));
3429
982k
}
3430
3431
static xmlHashedString
3432
4.86M
xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
3433
4.86M
    xmlHashedString ret;
3434
4.86M
    int len = 0, l;
3435
4.86M
    int c;
3436
4.86M
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
3437
0
                    XML_MAX_TEXT_LENGTH :
3438
4.86M
                    XML_MAX_NAME_LENGTH;
3439
4.86M
    size_t startPosition = 0;
3440
3441
4.86M
    ret.name = NULL;
3442
4.86M
    ret.hashValue = 0;
3443
3444
    /*
3445
     * Handler for more complex cases
3446
     */
3447
4.86M
    startPosition = CUR_PTR - BASE_PTR;
3448
4.86M
    c = xmlCurrentChar(ctxt, &l);
3449
4.86M
    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
3450
4.84M
  (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) {
3451
4.75M
  return(ret);
3452
4.75M
    }
3453
3454
12.9M
    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
3455
12.9M
     (xmlIsNameChar(ctxt, c) && (c != ':'))) {
3456
12.8M
        if (len <= INT_MAX - l)
3457
12.8M
      len += l;
3458
12.8M
  NEXTL(l);
3459
12.8M
  c = xmlCurrentChar(ctxt, &l);
3460
12.8M
    }
3461
115k
    if (len > maxLength) {
3462
294
        xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3463
294
        return(ret);
3464
294
    }
3465
115k
    ret = xmlDictLookupHashed(ctxt->dict, (BASE_PTR + startPosition), len);
3466
115k
    if (ret.name == NULL)
3467
2
        xmlErrMemory(ctxt);
3468
115k
    return(ret);
3469
115k
}
3470
3471
/**
3472
 * xmlParseNCName:
3473
 * @ctxt:  an XML parser context
3474
 * @len:  length of the string parsed
3475
 *
3476
 * parse an XML name.
3477
 *
3478
 * [4NS] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
3479
 *                      CombiningChar | Extender
3480
 *
3481
 * [5NS] NCName ::= (Letter | '_') (NCNameChar)*
3482
 *
3483
 * Returns the Name parsed or NULL
3484
 */
3485
3486
static xmlHashedString
3487
10.5M
xmlParseNCName(xmlParserCtxtPtr ctxt) {
3488
10.5M
    const xmlChar *in, *e;
3489
10.5M
    xmlHashedString ret;
3490
10.5M
    size_t count = 0;
3491
10.5M
    size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ?
3492
0
                       XML_MAX_TEXT_LENGTH :
3493
10.5M
                       XML_MAX_NAME_LENGTH;
3494
3495
10.5M
    ret.name = NULL;
3496
3497
    /*
3498
     * Accelerator for simple ASCII names
3499
     */
3500
10.5M
    in = ctxt->input->cur;
3501
10.5M
    e = ctxt->input->end;
3502
10.5M
    if ((((*in >= 0x61) && (*in <= 0x7A)) ||
3503
5.10M
   ((*in >= 0x41) && (*in <= 0x5A)) ||
3504
5.82M
   (*in == '_')) && (in < e)) {
3505
5.82M
  in++;
3506
28.3M
  while ((((*in >= 0x61) && (*in <= 0x7A)) ||
3507
6.55M
          ((*in >= 0x41) && (*in <= 0x5A)) ||
3508
6.17M
          ((*in >= 0x30) && (*in <= 0x39)) ||
3509
6.01M
          (*in == '_') || (*in == '-') ||
3510
22.5M
          (*in == '.')) && (in < e))
3511
22.5M
      in++;
3512
5.82M
  if (in >= e)
3513
1.21k
      goto complex;
3514
5.82M
  if ((*in > 0) && (*in < 0x80)) {
3515
5.72M
      count = in - ctxt->input->cur;
3516
5.72M
            if (count > maxLength) {
3517
101
                xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3518
101
                return(ret);
3519
101
            }
3520
5.72M
      ret = xmlDictLookupHashed(ctxt->dict, ctxt->input->cur, count);
3521
5.72M
      ctxt->input->cur = in;
3522
5.72M
      ctxt->input->col += count;
3523
5.72M
      if (ret.name == NULL) {
3524
6
          xmlErrMemory(ctxt);
3525
6
      }
3526
5.72M
      return(ret);
3527
5.72M
  }
3528
5.82M
    }
3529
4.86M
complex:
3530
4.86M
    return(xmlParseNCNameComplex(ctxt));
3531
10.5M
}
3532
3533
/**
3534
 * xmlParseNameAndCompare:
3535
 * @ctxt:  an XML parser context
3536
 *
3537
 * parse an XML name and compares for match
3538
 * (specialized for endtag parsing)
3539
 *
3540
 * Returns NULL for an illegal name, (xmlChar*) 1 for success
3541
 * and the name for mismatch
3542
 */
3543
3544
static const xmlChar *
3545
183k
xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
3546
183k
    register const xmlChar *cmp = other;
3547
183k
    register const xmlChar *in;
3548
183k
    const xmlChar *ret;
3549
3550
183k
    GROW;
3551
3552
183k
    in = ctxt->input->cur;
3553
488k
    while (*in != 0 && *in == *cmp) {
3554
304k
  ++in;
3555
304k
  ++cmp;
3556
304k
    }
3557
183k
    if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
3558
  /* success */
3559
104k
  ctxt->input->col += in - ctxt->input->cur;
3560
104k
  ctxt->input->cur = in;
3561
104k
  return (const xmlChar*) 1;
3562
104k
    }
3563
    /* failure (or end of input buffer), check with full function */
3564
79.5k
    ret = xmlParseName (ctxt);
3565
    /* strings coming from the dictionary direct compare possible */
3566
79.5k
    if (ret == other) {
3567
865
  return (const xmlChar*) 1;
3568
865
    }
3569
78.6k
    return ret;
3570
79.5k
}
3571
3572
/**
3573
 * xmlParseStringName:
3574
 * @ctxt:  an XML parser context
3575
 * @str:  a pointer to the string pointer (IN/OUT)
3576
 *
3577
 * parse an XML name.
3578
 *
3579
 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
3580
 *                  CombiningChar | Extender
3581
 *
3582
 * [5] Name ::= (Letter | '_' | ':') (NameChar)*
3583
 *
3584
 * [6] Names ::= Name (#x20 Name)*
3585
 *
3586
 * Returns the Name parsed or NULL. The @str pointer
3587
 * is updated to the current location in the string.
3588
 */
3589
3590
static xmlChar *
3591
214k
xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
3592
214k
    xmlChar buf[XML_MAX_NAMELEN + 5];
3593
214k
    xmlChar *ret;
3594
214k
    const xmlChar *cur = *str;
3595
214k
    int len = 0, l;
3596
214k
    int c;
3597
214k
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
3598
0
                    XML_MAX_TEXT_LENGTH :
3599
214k
                    XML_MAX_NAME_LENGTH;
3600
3601
214k
    c = CUR_SCHAR(cur, l);
3602
214k
    if (!xmlIsNameStartChar(ctxt, c)) {
3603
3.54k
  return(NULL);
3604
3.54k
    }
3605
3606
210k
    COPY_BUF(buf, len, c);
3607
210k
    cur += l;
3608
210k
    c = CUR_SCHAR(cur, l);
3609
394k
    while (xmlIsNameChar(ctxt, c)) {
3610
184k
  COPY_BUF(buf, len, c);
3611
184k
  cur += l;
3612
184k
  c = CUR_SCHAR(cur, l);
3613
184k
  if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */
3614
      /*
3615
       * Okay someone managed to make a huge name, so he's ready to pay
3616
       * for the processing speed.
3617
       */
3618
824
      xmlChar *buffer;
3619
824
      int max = len * 2;
3620
3621
824
      buffer = xmlMalloc(max);
3622
824
      if (buffer == NULL) {
3623
1
          xmlErrMemory(ctxt);
3624
1
    return(NULL);
3625
1
      }
3626
823
      memcpy(buffer, buf, len);
3627
4.41M
      while (xmlIsNameChar(ctxt, c)) {
3628
4.41M
    if (len + 10 > max) {
3629
4.79k
        xmlChar *tmp;
3630
4.79k
                    int newSize;
3631
3632
4.79k
                    newSize = xmlGrowCapacity(max, 1, 1, maxLength);
3633
4.79k
                    if (newSize < 0) {
3634
220
                        xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3635
220
                        xmlFree(buffer);
3636
220
                        return(NULL);
3637
220
                    }
3638
4.57k
        tmp = xmlRealloc(buffer, newSize);
3639
4.57k
        if (tmp == NULL) {
3640
0
      xmlErrMemory(ctxt);
3641
0
      xmlFree(buffer);
3642
0
      return(NULL);
3643
0
        }
3644
4.57k
        buffer = tmp;
3645
4.57k
                    max = newSize;
3646
4.57k
    }
3647
4.41M
    COPY_BUF(buffer, len, c);
3648
4.41M
    cur += l;
3649
4.41M
    c = CUR_SCHAR(cur, l);
3650
4.41M
      }
3651
603
      buffer[len] = 0;
3652
603
      *str = cur;
3653
603
      return(buffer);
3654
823
  }
3655
184k
    }
3656
209k
    if (len > maxLength) {
3657
0
        xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3658
0
        return(NULL);
3659
0
    }
3660
209k
    *str = cur;
3661
209k
    ret = xmlStrndup(buf, len);
3662
209k
    if (ret == NULL)
3663
6
        xmlErrMemory(ctxt);
3664
209k
    return(ret);
3665
209k
}
3666
3667
/**
3668
 * xmlParseNmtoken:
3669
 * @ctxt:  an XML parser context
3670
 *
3671
 * DEPRECATED: Internal function, don't use.
3672
 *
3673
 * parse an XML Nmtoken.
3674
 *
3675
 * [7] Nmtoken ::= (NameChar)+
3676
 *
3677
 * [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*
3678
 *
3679
 * Returns the Nmtoken parsed or NULL
3680
 */
3681
3682
xmlChar *
3683
30.1k
xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
3684
30.1k
    xmlChar buf[XML_MAX_NAMELEN + 5];
3685
30.1k
    xmlChar *ret;
3686
30.1k
    int len = 0, l;
3687
30.1k
    int c;
3688
30.1k
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
3689
0
                    XML_MAX_TEXT_LENGTH :
3690
30.1k
                    XML_MAX_NAME_LENGTH;
3691
3692
30.1k
    c = xmlCurrentChar(ctxt, &l);
3693
3694
179k
    while (xmlIsNameChar(ctxt, c)) {
3695
150k
  COPY_BUF(buf, len, c);
3696
150k
  NEXTL(l);
3697
150k
  c = xmlCurrentChar(ctxt, &l);
3698
150k
  if (len >= XML_MAX_NAMELEN) {
3699
      /*
3700
       * Okay someone managed to make a huge token, so he's ready to pay
3701
       * for the processing speed.
3702
       */
3703
661
      xmlChar *buffer;
3704
661
      int max = len * 2;
3705
3706
661
      buffer = xmlMalloc(max);
3707
661
      if (buffer == NULL) {
3708
1
          xmlErrMemory(ctxt);
3709
1
    return(NULL);
3710
1
      }
3711
660
      memcpy(buffer, buf, len);
3712
6.54M
      while (xmlIsNameChar(ctxt, c)) {
3713
6.54M
    if (len + 10 > max) {
3714
3.25k
        xmlChar *tmp;
3715
3.25k
                    int newSize;
3716
3717
3.25k
                    newSize = xmlGrowCapacity(max, 1, 1, maxLength);
3718
3.25k
                    if (newSize < 0) {
3719
186
                        xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
3720
186
                        xmlFree(buffer);
3721
186
                        return(NULL);
3722
186
                    }
3723
3.07k
        tmp = xmlRealloc(buffer, newSize);
3724
3.07k
        if (tmp == NULL) {
3725
0
      xmlErrMemory(ctxt);
3726
0
      xmlFree(buffer);
3727
0
      return(NULL);
3728
0
        }
3729
3.07k
        buffer = tmp;
3730
3.07k
                    max = newSize;
3731
3.07k
    }
3732
6.54M
    COPY_BUF(buffer, len, c);
3733
6.54M
    NEXTL(l);
3734
6.54M
    c = xmlCurrentChar(ctxt, &l);
3735
6.54M
      }
3736
474
      buffer[len] = 0;
3737
474
      return(buffer);
3738
660
  }
3739
150k
    }
3740
29.4k
    if (len == 0)
3741
10.3k
        return(NULL);
3742
19.1k
    if (len > maxLength) {
3743
0
        xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
3744
0
        return(NULL);
3745
0
    }
3746
19.1k
    ret = xmlStrndup(buf, len);
3747
19.1k
    if (ret == NULL)
3748
9
        xmlErrMemory(ctxt);
3749
19.1k
    return(ret);
3750
19.1k
}
3751
3752
/**
3753
 * xmlExpandPEsInEntityValue:
3754
 * @ctxt:  parser context
3755
 * @buf:  string buffer
3756
 * @str:  entity value
3757
 * @length:  size of entity value
3758
 * @depth:  nesting depth
3759
 *
3760
 * Validate an entity value and expand parameter entities.
3761
 */
3762
static void
3763
xmlExpandPEsInEntityValue(xmlParserCtxtPtr ctxt, xmlSBuf *buf,
3764
49.8k
                          const xmlChar *str, int length, int depth) {
3765
49.8k
    int maxDepth = (ctxt->options & XML_PARSE_HUGE) ? 40 : 20;
3766
49.8k
    const xmlChar *end, *chunk;
3767
49.8k
    int c, l;
3768
3769
49.8k
    if (str == NULL)
3770
3.78k
        return;
3771
3772
46.0k
    depth += 1;
3773
46.0k
    if (depth > maxDepth) {
3774
0
  xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT,
3775
0
                       "Maximum entity nesting depth exceeded");
3776
0
  return;
3777
0
    }
3778
3779
46.0k
    end = str + length;
3780
46.0k
    chunk = str;
3781
3782
186M
    while ((str < end) && (!PARSER_STOPPED(ctxt))) {
3783
186M
        c = *str;
3784
3785
186M
        if (c >= 0x80) {
3786
176M
            l = xmlUTF8MultibyteLen(ctxt, str,
3787
176M
                    "invalid character in entity value\n");
3788
176M
            if (l == 0) {
3789
24.5M
                if (chunk < str)
3790
124k
                    xmlSBufAddString(buf, chunk, str - chunk);
3791
24.5M
                xmlSBufAddReplChar(buf);
3792
24.5M
                str += 1;
3793
24.5M
                chunk = str;
3794
151M
            } else {
3795
151M
                str += l;
3796
151M
            }
3797
176M
        } else if (c == '&') {
3798
47.4k
            if (str[1] == '#') {
3799
13.7k
                if (chunk < str)
3800
5.76k
                    xmlSBufAddString(buf, chunk, str - chunk);
3801
3802
13.7k
                c = xmlParseStringCharRef(ctxt, &str);
3803
13.7k
                if (c == 0)
3804
2.82k
                    return;
3805
3806
10.8k
                xmlSBufAddChar(buf, c);
3807
3808
10.8k
                chunk = str;
3809
33.7k
            } else {
3810
33.7k
                xmlChar *name;
3811
3812
                /*
3813
                 * General entity references are checked for
3814
                 * syntactic validity.
3815
                 */
3816
33.7k
                str++;
3817
33.7k
                name = xmlParseStringName(ctxt, &str);
3818
3819
33.7k
                if ((name == NULL) || (*str++ != ';')) {
3820
2.17k
                    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
3821
2.17k
                            "EntityValue: '&' forbidden except for entities "
3822
2.17k
                            "references\n");
3823
2.17k
                    xmlFree(name);
3824
2.17k
                    return;
3825
2.17k
                }
3826
3827
31.5k
                xmlFree(name);
3828
31.5k
            }
3829
9.84M
        } else if (c == '%') {
3830
22.0k
            xmlEntityPtr ent;
3831
3832
22.0k
            if (chunk < str)
3833
8.37k
                xmlSBufAddString(buf, chunk, str - chunk);
3834
3835
22.0k
            ent = xmlParseStringPEReference(ctxt, &str);
3836
22.0k
            if (ent == NULL)
3837
6.07k
                return;
3838
3839
16.0k
            if (!PARSER_EXTERNAL(ctxt)) {
3840
476
                xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
3841
476
                return;
3842
476
            }
3843
3844
15.5k
            if (ent->content == NULL) {
3845
                /*
3846
                 * Note: external parsed entities will not be loaded,
3847
                 * it is not required for a non-validating parser to
3848
                 * complete external PEReferences coming from the
3849
                 * internal subset
3850
                 */
3851
5.29k
                if (((ctxt->options & XML_PARSE_NO_XXE) == 0) &&
3852
5.29k
                    ((ctxt->replaceEntities) ||
3853
5.29k
                     (ctxt->validate))) {
3854
5.29k
                    xmlLoadEntityContent(ctxt, ent);
3855
5.29k
                } else {
3856
0
                    xmlWarningMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
3857
0
                                  "not validating will not read content for "
3858
0
                                  "PE entity %s\n", ent->name, NULL);
3859
0
                }
3860
5.29k
            }
3861
3862
            /*
3863
             * TODO: Skip if ent->content is still NULL.
3864
             */
3865
3866
15.5k
            if (xmlParserEntityCheck(ctxt, ent->length))
3867
197
                return;
3868
3869
15.3k
            if (ent->flags & XML_ENT_EXPANDING) {
3870
794
                xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
3871
794
                xmlHaltParser(ctxt);
3872
794
                return;
3873
794
            }
3874
3875
14.5k
            ent->flags |= XML_ENT_EXPANDING;
3876
14.5k
            xmlExpandPEsInEntityValue(ctxt, buf, ent->content, ent->length,
3877
14.5k
                                      depth);
3878
14.5k
            ent->flags &= ~XML_ENT_EXPANDING;
3879
3880
14.5k
            chunk = str;
3881
9.81M
        } else {
3882
            /* Normal ASCII char */
3883
9.81M
            if (!IS_BYTE_CHAR(c)) {
3884
1.94M
                xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
3885
1.94M
                        "invalid character in entity value\n");
3886
1.94M
                if (chunk < str)
3887
12.4k
                    xmlSBufAddString(buf, chunk, str - chunk);
3888
1.94M
                xmlSBufAddReplChar(buf);
3889
1.94M
                str += 1;
3890
1.94M
                chunk = str;
3891
7.87M
            } else {
3892
7.87M
                str += 1;
3893
7.87M
            }
3894
9.81M
        }
3895
186M
    }
3896
3897
33.4k
    if (chunk < str)
3898
29.8k
        xmlSBufAddString(buf, chunk, str - chunk);
3899
33.4k
}
3900
3901
/**
3902
 * xmlParseEntityValue:
3903
 * @ctxt:  an XML parser context
3904
 * @orig:  if non-NULL store a copy of the original entity value
3905
 *
3906
 * DEPRECATED: Internal function, don't use.
3907
 *
3908
 * parse a value for ENTITY declarations
3909
 *
3910
 * [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' |
3911
 *                 "'" ([^%&'] | PEReference | Reference)* "'"
3912
 *
3913
 * Returns the EntityValue parsed with reference substituted or NULL
3914
 */
3915
xmlChar *
3916
36.3k
xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
3917
36.3k
    unsigned maxLength = (ctxt->options & XML_PARSE_HUGE) ?
3918
0
                         XML_MAX_HUGE_LENGTH :
3919
36.3k
                         XML_MAX_TEXT_LENGTH;
3920
36.3k
    xmlSBuf buf;
3921
36.3k
    const xmlChar *start;
3922
36.3k
    int quote, length;
3923
3924
36.3k
    xmlSBufInit(&buf, maxLength);
3925
3926
36.3k
    GROW;
3927
3928
36.3k
    quote = CUR;
3929
36.3k
    if ((quote != '"') && (quote != '\'')) {
3930
0
  xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
3931
0
  return(NULL);
3932
0
    }
3933
36.3k
    CUR_PTR++;
3934
3935
36.3k
    length = 0;
3936
3937
    /*
3938
     * Copy raw content of the entity into a buffer
3939
     */
3940
315M
    while (1) {
3941
315M
        int c;
3942
3943
315M
        if (PARSER_STOPPED(ctxt))
3944
47
            goto error;
3945
3946
315M
        if (CUR_PTR >= ctxt->input->end) {
3947
623
            xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
3948
623
            goto error;
3949
623
        }
3950
3951
315M
        c = CUR;
3952
3953
315M
        if (c == 0) {
3954
387
            xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
3955
387
                    "invalid character in entity value\n");
3956
387
            goto error;
3957
387
        }
3958
315M
        if (c == quote)
3959
35.2k
            break;
3960
315M
        NEXTL(1);
3961
315M
        length += 1;
3962
3963
        /*
3964
         * TODO: Check growth threshold
3965
         */
3966
315M
        if (ctxt->input->end - CUR_PTR < 10)
3967
40.2k
            GROW;
3968
315M
    }
3969
3970
35.2k
    start = CUR_PTR - length;
3971
3972
35.2k
    if (orig != NULL) {
3973
35.2k
        *orig = xmlStrndup(start, length);
3974
35.2k
        if (*orig == NULL)
3975
2
            xmlErrMemory(ctxt);
3976
35.2k
    }
3977
3978
35.2k
    xmlExpandPEsInEntityValue(ctxt, &buf, start, length, ctxt->inputNr);
3979
3980
35.2k
    NEXTL(1);
3981
3982
35.2k
    return(xmlSBufFinish(&buf, NULL, ctxt, "entity length too long"));
3983
3984
1.05k
error:
3985
1.05k
    xmlSBufCleanup(&buf, ctxt, "entity length too long");
3986
1.05k
    return(NULL);
3987
36.3k
}
3988
3989
/**
3990
 * xmlCheckEntityInAttValue:
3991
 * @ctxt:  parser context
3992
 * @pent:  entity
3993
 * @depth:  nesting depth
3994
 *
3995
 * Check an entity reference in an attribute value for validity
3996
 * without expanding it.
3997
 */
3998
static void
3999
105
xmlCheckEntityInAttValue(xmlParserCtxtPtr ctxt, xmlEntityPtr pent, int depth) {
4000
105
    int maxDepth = (ctxt->options & XML_PARSE_HUGE) ? 40 : 20;
4001
105
    const xmlChar *str;
4002
105
    unsigned long expandedSize = pent->length;
4003
105
    int c, flags;
4004
4005
105
    depth += 1;
4006
105
    if (depth > maxDepth) {
4007
0
  xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT,
4008
0
                       "Maximum entity nesting depth exceeded");
4009
0
  return;
4010
0
    }
4011
4012
105
    if (pent->flags & XML_ENT_EXPANDING) {
4013
0
        xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
4014
0
        xmlHaltParser(ctxt);
4015
0
        return;
4016
0
    }
4017
4018
    /*
4019
     * If we're parsing a default attribute value in DTD content,
4020
     * the entity might reference other entities which weren't
4021
     * defined yet, so the check isn't reliable.
4022
     */
4023
105
    if (ctxt->inSubset == 0)
4024
104
        flags = XML_ENT_CHECKED | XML_ENT_VALIDATED;
4025
1
    else
4026
1
        flags = XML_ENT_VALIDATED;
4027
4028
105
    str = pent->content;
4029
105
    if (str == NULL)
4030
0
        goto done;
4031
4032
    /*
4033
     * Note that entity values are already validated. We only check
4034
     * for illegal less-than signs and compute the expanded size
4035
     * of the entity. No special handling for multi-byte characters
4036
     * is needed.
4037
     */
4038
14.9M
    while (!PARSER_STOPPED(ctxt)) {
4039
14.9M
        c = *str;
4040
4041
14.9M
  if (c != '&') {
4042
14.9M
            if (c == 0)
4043
103
                break;
4044
4045
14.9M
            if (c == '<')
4046
34.1k
                xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
4047
34.1k
                        "'<' in entity '%s' is not allowed in attributes "
4048
34.1k
                        "values\n", pent->name);
4049
4050
14.9M
            str += 1;
4051
14.9M
        } else if (str[1] == '#') {
4052
207
            int val;
4053
4054
207
      val = xmlParseStringCharRef(ctxt, &str);
4055
207
      if (val == 0) {
4056
2
                pent->content[0] = 0;
4057
2
                break;
4058
2
            }
4059
18.5k
  } else {
4060
18.5k
            xmlChar *name;
4061
18.5k
            xmlEntityPtr ent;
4062
4063
18.5k
      name = xmlParseStringEntityRef(ctxt, &str);
4064
18.5k
      if (name == NULL) {
4065
0
                pent->content[0] = 0;
4066
0
                break;
4067
0
            }
4068
4069
18.5k
            ent = xmlLookupGeneralEntity(ctxt, name, /* inAttr */ 1);
4070
18.5k
            xmlFree(name);
4071
4072
18.5k
            if ((ent != NULL) &&
4073
18.4k
                (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY)) {
4074
11.9k
                if ((ent->flags & flags) != flags) {
4075
55
                    pent->flags |= XML_ENT_EXPANDING;
4076
55
                    xmlCheckEntityInAttValue(ctxt, ent, depth);
4077
55
                    pent->flags &= ~XML_ENT_EXPANDING;
4078
55
                }
4079
4080
11.9k
                xmlSaturatedAdd(&expandedSize, ent->expandedSize);
4081
11.9k
                xmlSaturatedAdd(&expandedSize, XML_ENT_FIXED_COST);
4082
11.9k
            }
4083
18.5k
        }
4084
14.9M
    }
4085
4086
105
done:
4087
105
    if (ctxt->inSubset == 0)
4088
104
        pent->expandedSize = expandedSize;
4089
4090
105
    pent->flags |= flags;
4091
105
}
4092
4093
/**
4094
 * xmlExpandEntityInAttValue:
4095
 * @ctxt:  parser context
4096
 * @buf:  string buffer
4097
 * @str:  entity or attribute value
4098
 * @pent:  entity for entity value, NULL for attribute values
4099
 * @normalize:  whether to collapse whitespace
4100
 * @inSpace:  whitespace state
4101
 * @depth:  nesting depth
4102
 * @check:  whether to check for amplification
4103
 *
4104
 * Expand general entity references in an entity or attribute value.
4105
 * Perform attribute value normalization.
4106
 */
4107
static void
4108
xmlExpandEntityInAttValue(xmlParserCtxtPtr ctxt, xmlSBuf *buf,
4109
                          const xmlChar *str, xmlEntityPtr pent, int normalize,
4110
267k
                          int *inSpace, int depth, int check) {
4111
267k
    int maxDepth = (ctxt->options & XML_PARSE_HUGE) ? 40 : 20;
4112
267k
    int c, chunkSize;
4113
4114
267k
    if (str == NULL)
4115
0
        return;
4116
4117
267k
    depth += 1;
4118
267k
    if (depth > maxDepth) {
4119
0
  xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT,
4120
0
                       "Maximum entity nesting depth exceeded");
4121
0
  return;
4122
0
    }
4123
4124
267k
    if (pent != NULL) {
4125
267k
        if (pent->flags & XML_ENT_EXPANDING) {
4126
357
            xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
4127
357
            xmlHaltParser(ctxt);
4128
357
            return;
4129
357
        }
4130
4131
267k
        if (check) {
4132
267k
            if (xmlParserEntityCheck(ctxt, pent->length))
4133
240
                return;
4134
267k
        }
4135
267k
    }
4136
4137
267k
    chunkSize = 0;
4138
4139
    /*
4140
     * Note that entity values are already validated. No special
4141
     * handling for multi-byte characters is needed.
4142
     */
4143
1.17G
    while (!PARSER_STOPPED(ctxt)) {
4144
1.17G
        c = *str;
4145
4146
1.17G
  if (c != '&') {
4147
1.17G
            if (c == 0)
4148
249k
                break;
4149
4150
            /*
4151
             * If this function is called without an entity, it is used to
4152
             * expand entities in an attribute content where less-than was
4153
             * already unscaped and is allowed.
4154
             */
4155
1.17G
            if ((pent != NULL) && (c == '<')) {
4156
16.3k
                xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
4157
16.3k
                        "'<' in entity '%s' is not allowed in attributes "
4158
16.3k
                        "values\n", pent->name);
4159
16.3k
                break;
4160
16.3k
            }
4161
4162
1.17G
            if (c <= 0x20) {
4163
15.9M
                if ((normalize) && (*inSpace)) {
4164
                    /* Skip char */
4165
5.17M
                    if (chunkSize > 0) {
4166
1.11M
                        xmlSBufAddString(buf, str - chunkSize, chunkSize);
4167
1.11M
                        chunkSize = 0;
4168
1.11M
                    }
4169
10.7M
                } else if (c < 0x20) {
4170
9.35M
                    if (chunkSize > 0) {
4171
289k
                        xmlSBufAddString(buf, str - chunkSize, chunkSize);
4172
289k
                        chunkSize = 0;
4173
289k
                    }
4174
4175
9.35M
                    xmlSBufAddCString(buf, " ", 1);
4176
9.35M
                } else {
4177
1.38M
                    chunkSize += 1;
4178
1.38M
                }
4179
4180
15.9M
                *inSpace = 1;
4181
1.16G
            } else {
4182
1.16G
                chunkSize += 1;
4183
1.16G
                *inSpace = 0;
4184
1.16G
            }
4185
4186
1.17G
            str += 1;
4187
1.17G
        } else if (str[1] == '#') {
4188
63.5k
            int val;
4189
4190
63.5k
            if (chunkSize > 0) {
4191
62.4k
                xmlSBufAddString(buf, str - chunkSize, chunkSize);
4192
62.4k
                chunkSize = 0;
4193
62.4k
            }
4194
4195
63.5k
      val = xmlParseStringCharRef(ctxt, &str);
4196
63.5k
      if (val == 0) {
4197
282
                if (pent != NULL)
4198
282
                    pent->content[0] = 0;
4199
282
                break;
4200
282
            }
4201
4202
63.3k
            if (val == ' ') {
4203
6.48k
                if ((!normalize) || (!*inSpace))
4204
6.40k
                    xmlSBufAddCString(buf, " ", 1);
4205
6.48k
                *inSpace = 1;
4206
56.8k
            } else {
4207
56.8k
                xmlSBufAddChar(buf, val);
4208
56.8k
                *inSpace = 0;
4209
56.8k
            }
4210
139k
  } else {
4211
139k
            xmlChar *name;
4212
139k
            xmlEntityPtr ent;
4213
4214
139k
            if (chunkSize > 0) {
4215
87.2k
                xmlSBufAddString(buf, str - chunkSize, chunkSize);
4216
87.2k
                chunkSize = 0;
4217
87.2k
            }
4218
4219
139k
      name = xmlParseStringEntityRef(ctxt, &str);
4220
139k
            if (name == NULL) {
4221
631
                if (pent != NULL)
4222
631
                    pent->content[0] = 0;
4223
631
                break;
4224
631
            }
4225
4226
139k
            ent = xmlLookupGeneralEntity(ctxt, name, /* inAttr */ 1);
4227
139k
            xmlFree(name);
4228
4229
139k
      if ((ent != NULL) &&
4230
114k
    (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
4231
33.9k
    if (ent->content == NULL) {
4232
0
        xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
4233
0
          "predefined entity has no content\n");
4234
0
                    break;
4235
0
                }
4236
4237
33.9k
                xmlSBufAddString(buf, ent->content, ent->length);
4238
4239
33.9k
                *inSpace = 0;
4240
105k
      } else if ((ent != NULL) && (ent->content != NULL)) {
4241
80.8k
                if (pent != NULL)
4242
80.8k
                    pent->flags |= XML_ENT_EXPANDING;
4243
80.8k
    xmlExpandEntityInAttValue(ctxt, buf, ent->content, ent,
4244
80.8k
                                          normalize, inSpace, depth, check);
4245
80.8k
                if (pent != NULL)
4246
80.8k
                    pent->flags &= ~XML_ENT_EXPANDING;
4247
80.8k
      }
4248
139k
        }
4249
1.17G
    }
4250
4251
267k
    if (chunkSize > 0)
4252
93.7k
        xmlSBufAddString(buf, str - chunkSize, chunkSize);
4253
267k
}
4254
4255
/**
4256
 * xmlExpandEntitiesInAttValue:
4257
 * @ctxt:  parser context
4258
 * @str:  entity or attribute value
4259
 * @normalize:  whether to collapse whitespace
4260
 *
4261
 * Expand general entity references in an entity or attribute value.
4262
 * Perform attribute value normalization.
4263
 *
4264
 * Returns the expanded attribtue value.
4265
 */
4266
xmlChar *
4267
xmlExpandEntitiesInAttValue(xmlParserCtxtPtr ctxt, const xmlChar *str,
4268
0
                            int normalize) {
4269
0
    unsigned maxLength = (ctxt->options & XML_PARSE_HUGE) ?
4270
0
                         XML_MAX_HUGE_LENGTH :
4271
0
                         XML_MAX_TEXT_LENGTH;
4272
0
    xmlSBuf buf;
4273
0
    int inSpace = 1;
4274
4275
0
    xmlSBufInit(&buf, maxLength);
4276
4277
0
    xmlExpandEntityInAttValue(ctxt, &buf, str, NULL, normalize, &inSpace,
4278
0
                              ctxt->inputNr, /* check */ 0);
4279
4280
0
    if ((normalize) && (inSpace) && (buf.size > 0))
4281
0
        buf.size--;
4282
4283
0
    return(xmlSBufFinish(&buf, NULL, ctxt, "AttValue length too long"));
4284
0
}
4285
4286
/**
4287
 * xmlParseAttValueInternal:
4288
 * @ctxt:  an XML parser context
4289
 * @len:  attribute len result
4290
 * @alloc:  whether the attribute was reallocated as a new string
4291
 * @normalize:  if 1 then further non-CDATA normalization must be done
4292
 *
4293
 * parse a value for an attribute.
4294
 * NOTE: if no normalization is needed, the routine will return pointers
4295
 *       directly from the data buffer.
4296
 *
4297
 * 3.3.3 Attribute-Value Normalization:
4298
 * Before the value of an attribute is passed to the application or
4299
 * checked for validity, the XML processor must normalize it as follows:
4300
 * - a character reference is processed by appending the referenced
4301
 *   character to the attribute value
4302
 * - an entity reference is processed by recursively processing the
4303
 *   replacement text of the entity
4304
 * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
4305
 *   appending #x20 to the normalized value, except that only a single
4306
 *   #x20 is appended for a "#xD#xA" sequence that is part of an external
4307
 *   parsed entity or the literal entity value of an internal parsed entity
4308
 * - other characters are processed by appending them to the normalized value
4309
 * If the declared value is not CDATA, then the XML processor must further
4310
 * process the normalized attribute value by discarding any leading and
4311
 * trailing space (#x20) characters, and by replacing sequences of space
4312
 * (#x20) characters by a single space (#x20) character.
4313
 * All attributes for which no declaration has been read should be treated
4314
 * by a non-validating parser as if declared CDATA.
4315
 *
4316
 * Returns the AttValue parsed or NULL. The value has to be freed by the
4317
 *     caller if it was copied, this can be detected by val[*len] == 0.
4318
 */
4319
static xmlChar *
4320
xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *attlen, int *alloc,
4321
1.35M
                         int normalize, int isNamespace) {
4322
1.35M
    unsigned maxLength = (ctxt->options & XML_PARSE_HUGE) ?
4323
0
                         XML_MAX_HUGE_LENGTH :
4324
1.35M
                         XML_MAX_TEXT_LENGTH;
4325
1.35M
    xmlSBuf buf;
4326
1.35M
    xmlChar *ret;
4327
1.35M
    int c, l, quote, flags, chunkSize;
4328
1.35M
    int inSpace = 1;
4329
1.35M
    int replaceEntities;
4330
4331
    /* Always expand namespace URIs */
4332
1.35M
    replaceEntities = (ctxt->replaceEntities) || (isNamespace);
4333
4334
1.35M
    xmlSBufInit(&buf, maxLength);
4335
4336
1.35M
    GROW;
4337
4338
1.35M
    quote = CUR;
4339
1.35M
    if ((quote != '"') && (quote != '\'')) {
4340
11.4k
  xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
4341
11.4k
  return(NULL);
4342
11.4k
    }
4343
1.33M
    NEXTL(1);
4344
4345
1.33M
    if (ctxt->inSubset == 0)
4346
1.29M
        flags = XML_ENT_CHECKED | XML_ENT_VALIDATED;
4347
42.4k
    else
4348
42.4k
        flags = XML_ENT_VALIDATED;
4349
4350
1.33M
    inSpace = 1;
4351
1.33M
    chunkSize = 0;
4352
4353
206M
    while (1) {
4354
206M
        if (PARSER_STOPPED(ctxt))
4355
623
            goto error;
4356
4357
206M
        if (CUR_PTR >= ctxt->input->end) {
4358
2.54k
            xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4359
2.54k
                           "AttValue: ' expected\n");
4360
2.54k
            goto error;
4361
2.54k
        }
4362
4363
        /*
4364
         * TODO: Check growth threshold
4365
         */
4366
206M
        if (ctxt->input->end - CUR_PTR < 10)
4367
66.6k
            GROW;
4368
4369
206M
        c = CUR;
4370
4371
206M
        if (c >= 0x80) {
4372
36.8M
            l = xmlUTF8MultibyteLen(ctxt, CUR_PTR,
4373
36.8M
                    "invalid character in attribute value\n");
4374
36.8M
            if (l == 0) {
4375
19.7M
                if (chunkSize > 0) {
4376
261k
                    xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize);
4377
261k
                    chunkSize = 0;
4378
261k
                }
4379
19.7M
                xmlSBufAddReplChar(&buf);
4380
19.7M
                NEXTL(1);
4381
19.7M
            } else {
4382
17.0M
                chunkSize += l;
4383
17.0M
                NEXTL(l);
4384
17.0M
            }
4385
4386
36.8M
            inSpace = 0;
4387
169M
        } else if (c != '&') {
4388
169M
            if (c > 0x20) {
4389
30.6M
                if (c == quote)
4390
1.33M
                    break;
4391
4392
29.2M
                if (c == '<')
4393
272k
                    xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
4394
4395
29.2M
                chunkSize += 1;
4396
29.2M
                inSpace = 0;
4397
138M
            } else if (!IS_BYTE_CHAR(c)) {
4398
131M
                xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
4399
131M
                        "invalid character in attribute value\n");
4400
131M
                if (chunkSize > 0) {
4401
54.6k
                    xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize);
4402
54.6k
                    chunkSize = 0;
4403
54.6k
                }
4404
131M
                xmlSBufAddReplChar(&buf);
4405
131M
                inSpace = 0;
4406
131M
            } else {
4407
                /* Whitespace */
4408
7.26M
                if ((normalize) && (inSpace)) {
4409
                    /* Skip char */
4410
58.1k
                    if (chunkSize > 0) {
4411
37.8k
                        xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize);
4412
37.8k
                        chunkSize = 0;
4413
37.8k
                    }
4414
7.20M
                } else if (c < 0x20) {
4415
                    /* Convert to space */
4416
6.60M
                    if (chunkSize > 0) {
4417
116k
                        xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize);
4418
116k
                        chunkSize = 0;
4419
116k
                    }
4420
4421
6.60M
                    xmlSBufAddCString(&buf, " ", 1);
4422
6.60M
                } else {
4423
604k
                    chunkSize += 1;
4424
604k
                }
4425
4426
7.26M
                inSpace = 1;
4427
4428
7.26M
                if ((c == 0xD) && (NXT(1) == 0xA))
4429
2.70k
                    CUR_PTR++;
4430
7.26M
            }
4431
4432
167M
            NEXTL(1);
4433
167M
        } else if (NXT(1) == '#') {
4434
95.0k
            int val;
4435
4436
95.0k
            if (chunkSize > 0) {
4437
59.9k
                xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize);
4438
59.9k
                chunkSize = 0;
4439
59.9k
            }
4440
4441
95.0k
            val = xmlParseCharRef(ctxt);
4442
95.0k
            if (val == 0)
4443
5.08k
                goto error;
4444
4445
89.9k
            if ((val == '&') && (!replaceEntities)) {
4446
                /*
4447
                 * The reparsing will be done in xmlNodeParseContent()
4448
                 * called from SAX2.c
4449
                 */
4450
6
                xmlSBufAddCString(&buf, "&#38;", 5);
4451
6
                inSpace = 0;
4452
89.9k
            } else if (val == ' ') {
4453
8.83k
                if ((!normalize) || (!inSpace))
4454
8.75k
                    xmlSBufAddCString(&buf, " ", 1);
4455
8.83k
                inSpace = 1;
4456
81.1k
            } else {
4457
81.1k
                xmlSBufAddChar(&buf, val);
4458
81.1k
                inSpace = 0;
4459
81.1k
            }
4460
409k
        } else {
4461
409k
            const xmlChar *name;
4462
409k
            xmlEntityPtr ent;
4463
4464
409k
            if (chunkSize > 0) {
4465
323k
                xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize);
4466
323k
                chunkSize = 0;
4467
323k
            }
4468
4469
409k
            name = xmlParseEntityRefInternal(ctxt);
4470
409k
            if (name == NULL) {
4471
                /*
4472
                 * Probably a literal '&' which wasn't escaped.
4473
                 * TODO: Handle gracefully in recovery mode.
4474
                 */
4475
155k
                continue;
4476
155k
            }
4477
4478
254k
            ent = xmlLookupGeneralEntity(ctxt, name, /* isAttr */ 1);
4479
254k
            if (ent == NULL)
4480
41.8k
                continue;
4481
4482
212k
            if (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY) {
4483
2.43k
                if ((ent->content[0] == '&') && (!replaceEntities))
4484
281
                    xmlSBufAddCString(&buf, "&#38;", 5);
4485
2.15k
                else
4486
2.15k
                    xmlSBufAddString(&buf, ent->content, ent->length);
4487
2.43k
                inSpace = 0;
4488
209k
            } else if (replaceEntities) {
4489
186k
                xmlExpandEntityInAttValue(ctxt, &buf, ent->content, ent,
4490
186k
                                          normalize, &inSpace, ctxt->inputNr,
4491
186k
                                          /* check */ 1);
4492
186k
            } else {
4493
23.0k
                if ((ent->flags & flags) != flags)
4494
50
                    xmlCheckEntityInAttValue(ctxt, ent, ctxt->inputNr);
4495
4496
23.0k
                if (xmlParserEntityCheck(ctxt, ent->expandedSize)) {
4497
26
                    ent->content[0] = 0;
4498
26
                    goto error;
4499
26
                }
4500
4501
                /*
4502
                 * Just output the reference
4503
                 */
4504
23.0k
                xmlSBufAddCString(&buf, "&", 1);
4505
23.0k
                xmlSBufAddString(&buf, ent->name, xmlStrlen(ent->name));
4506
23.0k
                xmlSBufAddCString(&buf, ";", 1);
4507
4508
23.0k
                inSpace = 0;
4509
23.0k
            }
4510
212k
  }
4511
206M
    }
4512
4513
1.33M
    if ((buf.mem == NULL) && (alloc != NULL)) {
4514
1.20M
        ret = (xmlChar *) CUR_PTR - chunkSize;
4515
4516
1.20M
        if (attlen != NULL)
4517
1.20M
            *attlen = chunkSize;
4518
1.20M
        if ((normalize) && (inSpace) && (chunkSize > 0))
4519
953
            *attlen -= 1;
4520
1.20M
        *alloc = 0;
4521
4522
        /* Report potential error */
4523
1.20M
        xmlSBufCleanup(&buf, ctxt, "AttValue length too long");
4524
1.20M
    } else {
4525
122k
        if (chunkSize > 0)
4526
77.8k
            xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize);
4527
4528
122k
        if ((normalize) && (inSpace) && (buf.size > 0))
4529
170
            buf.size--;
4530
4531
122k
        ret = xmlSBufFinish(&buf, attlen, ctxt, "AttValue length too long");
4532
4533
122k
        if (ret != NULL) {
4534
122k
            if (attlen != NULL)
4535
80.0k
                *attlen = buf.size;
4536
122k
            if (alloc != NULL)
4537
80.0k
                *alloc = 1;
4538
122k
        }
4539
122k
    }
4540
4541
1.33M
    NEXTL(1);
4542
4543
1.33M
    return(ret);
4544
4545
8.27k
error:
4546
8.27k
    xmlSBufCleanup(&buf, ctxt, "AttValue length too long");
4547
8.27k
    return(NULL);
4548
1.33M
}
4549
4550
/**
4551
 * xmlParseAttValue:
4552
 * @ctxt:  an XML parser context
4553
 *
4554
 * DEPRECATED: Internal function, don't use.
4555
 *
4556
 * parse a value for an attribute
4557
 * Note: the parser won't do substitution of entities here, this
4558
 * will be handled later in xmlStringGetNodeList
4559
 *
4560
 * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' |
4561
 *                   "'" ([^<&'] | Reference)* "'"
4562
 *
4563
 * 3.3.3 Attribute-Value Normalization:
4564
 * Before the value of an attribute is passed to the application or
4565
 * checked for validity, the XML processor must normalize it as follows:
4566
 * - a character reference is processed by appending the referenced
4567
 *   character to the attribute value
4568
 * - an entity reference is processed by recursively processing the
4569
 *   replacement text of the entity
4570
 * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
4571
 *   appending #x20 to the normalized value, except that only a single
4572
 *   #x20 is appended for a "#xD#xA" sequence that is part of an external
4573
 *   parsed entity or the literal entity value of an internal parsed entity
4574
 * - other characters are processed by appending them to the normalized value
4575
 * If the declared value is not CDATA, then the XML processor must further
4576
 * process the normalized attribute value by discarding any leading and
4577
 * trailing space (#x20) characters, and by replacing sequences of space
4578
 * (#x20) characters by a single space (#x20) character.
4579
 * All attributes for which no declaration has been read should be treated
4580
 * by a non-validating parser as if declared CDATA.
4581
 *
4582
 * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
4583
 */
4584
4585
4586
xmlChar *
4587
49.7k
xmlParseAttValue(xmlParserCtxtPtr ctxt) {
4588
49.7k
    if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL);
4589
49.7k
    return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0, 0));
4590
49.7k
}
4591
4592
/**
4593
 * xmlParseSystemLiteral:
4594
 * @ctxt:  an XML parser context
4595
 *
4596
 * DEPRECATED: Internal function, don't use.
4597
 *
4598
 * parse an XML Literal
4599
 *
4600
 * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
4601
 *
4602
 * Returns the SystemLiteral parsed or NULL
4603
 */
4604
4605
xmlChar *
4606
35.1k
xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
4607
35.1k
    xmlChar *buf = NULL;
4608
35.1k
    int len = 0;
4609
35.1k
    int size = XML_PARSER_BUFFER_SIZE;
4610
35.1k
    int cur, l;
4611
35.1k
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
4612
0
                    XML_MAX_TEXT_LENGTH :
4613
35.1k
                    XML_MAX_NAME_LENGTH;
4614
35.1k
    xmlChar stop;
4615
4616
35.1k
    if (RAW == '"') {
4617
26.6k
        NEXT;
4618
26.6k
  stop = '"';
4619
26.6k
    } else if (RAW == '\'') {
4620
6.29k
        NEXT;
4621
6.29k
  stop = '\'';
4622
6.29k
    } else {
4623
2.28k
  xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4624
2.28k
  return(NULL);
4625
2.28k
    }
4626
4627
32.9k
    buf = xmlMalloc(size);
4628
32.9k
    if (buf == NULL) {
4629
5
        xmlErrMemory(ctxt);
4630
5
  return(NULL);
4631
5
    }
4632
32.9k
    cur = xmlCurrentCharRecover(ctxt, &l);
4633
2.41M
    while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */
4634
2.37M
  if (len + 5 >= size) {
4635
6.25k
      xmlChar *tmp;
4636
6.25k
            int newSize;
4637
4638
6.25k
            newSize = xmlGrowCapacity(size, 1, 1, maxLength);
4639
6.25k
            if (newSize < 0) {
4640
64
                xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "SystemLiteral");
4641
64
                xmlFree(buf);
4642
64
                return(NULL);
4643
64
            }
4644
6.19k
      tmp = xmlRealloc(buf, newSize);
4645
6.19k
      if (tmp == NULL) {
4646
1
          xmlFree(buf);
4647
1
    xmlErrMemory(ctxt);
4648
1
    return(NULL);
4649
1
      }
4650
6.19k
      buf = tmp;
4651
6.19k
            size = newSize;
4652
6.19k
  }
4653
2.37M
  COPY_BUF(buf, len, cur);
4654
2.37M
  NEXTL(l);
4655
2.37M
  cur = xmlCurrentCharRecover(ctxt, &l);
4656
2.37M
    }
4657
32.8k
    buf[len] = 0;
4658
32.8k
    if (!IS_CHAR(cur)) {
4659
627
  xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4660
32.2k
    } else {
4661
32.2k
  NEXT;
4662
32.2k
    }
4663
32.8k
    return(buf);
4664
32.9k
}
4665
4666
/**
4667
 * xmlParsePubidLiteral:
4668
 * @ctxt:  an XML parser context
4669
 *
4670
 * DEPRECATED: Internal function, don't use.
4671
 *
4672
 * parse an XML public literal
4673
 *
4674
 * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
4675
 *
4676
 * Returns the PubidLiteral parsed or NULL.
4677
 */
4678
4679
xmlChar *
4680
11.6k
xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
4681
11.6k
    xmlChar *buf = NULL;
4682
11.6k
    int len = 0;
4683
11.6k
    int size = XML_PARSER_BUFFER_SIZE;
4684
11.6k
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
4685
0
                    XML_MAX_TEXT_LENGTH :
4686
11.6k
                    XML_MAX_NAME_LENGTH;
4687
11.6k
    xmlChar cur;
4688
11.6k
    xmlChar stop;
4689
4690
11.6k
    if (RAW == '"') {
4691
3.57k
        NEXT;
4692
3.57k
  stop = '"';
4693
8.11k
    } else if (RAW == '\'') {
4694
7.05k
        NEXT;
4695
7.05k
  stop = '\'';
4696
7.05k
    } else {
4697
1.05k
  xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4698
1.05k
  return(NULL);
4699
1.05k
    }
4700
10.6k
    buf = xmlMalloc(size);
4701
10.6k
    if (buf == NULL) {
4702
1
  xmlErrMemory(ctxt);
4703
1
  return(NULL);
4704
1
    }
4705
10.6k
    cur = CUR;
4706
29.2M
    while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop) &&
4707
29.2M
           (PARSER_STOPPED(ctxt) == 0)) { /* checked */
4708
29.2M
  if (len + 1 >= size) {
4709
10.7k
      xmlChar *tmp;
4710
10.7k
            int newSize;
4711
4712
10.7k
      newSize = xmlGrowCapacity(size, 1, 1, maxLength);
4713
10.7k
            if (newSize < 0) {
4714
561
                xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Public ID");
4715
561
                xmlFree(buf);
4716
561
                return(NULL);
4717
561
            }
4718
10.1k
      tmp = xmlRealloc(buf, newSize);
4719
10.1k
      if (tmp == NULL) {
4720
1
    xmlErrMemory(ctxt);
4721
1
    xmlFree(buf);
4722
1
    return(NULL);
4723
1
      }
4724
10.1k
      buf = tmp;
4725
10.1k
            size = newSize;
4726
10.1k
  }
4727
29.2M
  buf[len++] = cur;
4728
29.2M
  NEXT;
4729
29.2M
  cur = CUR;
4730
29.2M
    }
4731
10.0k
    buf[len] = 0;
4732
10.0k
    if (cur != stop) {
4733
438
  xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4734
9.62k
    } else {
4735
9.62k
  NEXTL(1);
4736
9.62k
    }
4737
10.0k
    return(buf);
4738
10.6k
}
4739
4740
static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int partial);
4741
4742
/*
4743
 * used for the test in the inner loop of the char data testing
4744
 */
4745
static const unsigned char test_char_data[256] = {
4746
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4747
    0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9, CR/LF separated */
4748
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4749
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4750
    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x00, 0x27, /* & */
4751
    0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
4752
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
4753
    0x38, 0x39, 0x3A, 0x3B, 0x00, 0x3D, 0x3E, 0x3F, /* < */
4754
    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
4755
    0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
4756
    0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
4757
    0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x00, 0x5E, 0x5F, /* ] */
4758
    0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
4759
    0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
4760
    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
4761
    0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
4762
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* non-ascii */
4763
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4764
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4765
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4766
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4767
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4768
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4769
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4770
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4771
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4772
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4773
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4774
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4775
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4776
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4777
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
4778
};
4779
4780
static void
4781
xmlCharacters(xmlParserCtxtPtr ctxt, const xmlChar *buf, int size,
4782
4.33M
              int isBlank) {
4783
4.33M
    int checkBlanks;
4784
4785
4.33M
    if ((ctxt->sax == NULL) || (ctxt->disableSAX))
4786
2.16M
        return;
4787
4788
2.17M
    checkBlanks = (!ctxt->keepBlanks) ||
4789
2.17M
                  (ctxt->sax->ignorableWhitespace != ctxt->sax->characters);
4790
4791
    /*
4792
     * Calling areBlanks with only parts of a text node
4793
     * is fundamentally broken, making the NOBLANKS option
4794
     * essentially unusable.
4795
     */
4796
2.17M
    if ((checkBlanks) &&
4797
0
        (areBlanks(ctxt, buf, size, isBlank))) {
4798
0
        if ((ctxt->sax->ignorableWhitespace != NULL) &&
4799
0
            (ctxt->keepBlanks))
4800
0
            ctxt->sax->ignorableWhitespace(ctxt->userData, buf, size);
4801
2.17M
    } else {
4802
2.17M
        if (ctxt->sax->characters != NULL)
4803
2.17M
            ctxt->sax->characters(ctxt->userData, buf, size);
4804
4805
        /*
4806
         * The old code used to update this value for "complex" data
4807
         * even if checkBlanks was false. This was probably a bug.
4808
         */
4809
2.17M
        if ((checkBlanks) && (*ctxt->space == -1))
4810
0
            *ctxt->space = -2;
4811
2.17M
    }
4812
2.17M
}
4813
4814
/**
4815
 * xmlParseCharDataInternal:
4816
 * @ctxt:  an XML parser context
4817
 * @partial:  buffer may contain partial UTF-8 sequences
4818
 *
4819
 * Parse character data. Always makes progress if the first char isn't
4820
 * '<' or '&'.
4821
 *
4822
 * The right angle bracket (>) may be represented using the string "&gt;",
4823
 * and must, for compatibility, be escaped using "&gt;" or a character
4824
 * reference when it appears in the string "]]>" in content, when that
4825
 * string is not marking the end of a CDATA section.
4826
 *
4827
 * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
4828
 */
4829
static void
4830
145M
xmlParseCharDataInternal(xmlParserCtxtPtr ctxt, int partial) {
4831
145M
    const xmlChar *in;
4832
145M
    int nbchar = 0;
4833
145M
    int line = ctxt->input->line;
4834
145M
    int col = ctxt->input->col;
4835
145M
    int ccol;
4836
4837
145M
    GROW;
4838
    /*
4839
     * Accelerated common case where input don't need to be
4840
     * modified before passing it to the handler.
4841
     */
4842
145M
    in = ctxt->input->cur;
4843
145M
    do {
4844
146M
get_more_space:
4845
147M
        while (*in == 0x20) { in++; ctxt->input->col++; }
4846
146M
        if (*in == 0xA) {
4847
13.9M
            do {
4848
13.9M
                ctxt->input->line++; ctxt->input->col = 1;
4849
13.9M
                in++;
4850
13.9M
            } while (*in == 0xA);
4851
547k
            goto get_more_space;
4852
547k
        }
4853
145M
        if (*in == '<') {
4854
633k
            nbchar = in - ctxt->input->cur;
4855
633k
            if (nbchar > 0) {
4856
633k
                const xmlChar *tmp = ctxt->input->cur;
4857
633k
                ctxt->input->cur = in;
4858
4859
633k
                xmlCharacters(ctxt, tmp, nbchar, 1);
4860
633k
            }
4861
633k
            return;
4862
633k
        }
4863
4864
145M
get_more:
4865
145M
        ccol = ctxt->input->col;
4866
197M
        while (test_char_data[*in]) {
4867
52.3M
            in++;
4868
52.3M
            ccol++;
4869
52.3M
        }
4870
145M
        ctxt->input->col = ccol;
4871
145M
        if (*in == 0xA) {
4872
11.4M
            do {
4873
11.4M
                ctxt->input->line++; ctxt->input->col = 1;
4874
11.4M
                in++;
4875
11.4M
            } while (*in == 0xA);
4876
183k
            goto get_more;
4877
183k
        }
4878
145M
        if (*in == ']') {
4879
58.6k
            if ((in[1] == ']') && (in[2] == '>')) {
4880
994
                xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4881
994
                ctxt->input->cur = in + 1;
4882
994
                return;
4883
994
            }
4884
57.6k
            if ((!partial) || (ctxt->input->end - in >= 2)) {
4885
57.6k
                in++;
4886
57.6k
                ctxt->input->col++;
4887
57.6k
                goto get_more;
4888
57.6k
            }
4889
57.6k
        }
4890
144M
        nbchar = in - ctxt->input->cur;
4891
144M
        if (nbchar > 0) {
4892
1.42M
            const xmlChar *tmp = ctxt->input->cur;
4893
1.42M
            ctxt->input->cur = in;
4894
4895
1.42M
            xmlCharacters(ctxt, tmp, nbchar, 0);
4896
4897
1.42M
            line = ctxt->input->line;
4898
1.42M
            col = ctxt->input->col;
4899
1.42M
        }
4900
144M
        ctxt->input->cur = in;
4901
144M
        if (*in == 0xD) {
4902
39.8k
            in++;
4903
39.8k
            if (*in == 0xA) {
4904
26.4k
                ctxt->input->cur = in;
4905
26.4k
                in++;
4906
26.4k
                ctxt->input->line++; ctxt->input->col = 1;
4907
26.4k
                continue; /* while */
4908
26.4k
            }
4909
13.3k
            in--;
4910
13.3k
        }
4911
144M
        if (*in == '<') {
4912
739k
            return;
4913
739k
        }
4914
144M
        if (*in == '&') {
4915
56.7k
            return;
4916
56.7k
        }
4917
144M
        if ((partial) && (*in == ']') && (ctxt->input->end - in < 2)) {
4918
0
            return;
4919
0
        }
4920
144M
        SHRINK;
4921
144M
        GROW;
4922
144M
        in = ctxt->input->cur;
4923
144M
    } while (((*in >= 0x20) && (*in <= 0x7F)) ||
4924
144M
             (*in == 0x09) || (*in == 0x0a));
4925
144M
    ctxt->input->line = line;
4926
144M
    ctxt->input->col = col;
4927
144M
    xmlParseCharDataComplex(ctxt, partial);
4928
144M
}
4929
4930
/**
4931
 * xmlParseCharDataComplex:
4932
 * @ctxt:  an XML parser context
4933
 * @cdata:  int indicating whether we are within a CDATA section
4934
 *
4935
 * Always makes progress if the first char isn't '<' or '&'.
4936
 *
4937
 * parse a CharData section.this is the fallback function
4938
 * of xmlParseCharData() when the parsing requires handling
4939
 * of non-ASCII characters.
4940
 */
4941
static void
4942
144M
xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int partial) {
4943
144M
    xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5];
4944
144M
    int nbchar = 0;
4945
144M
    int cur, l;
4946
4947
144M
    cur = xmlCurrentCharRecover(ctxt, &l);
4948
343M
    while ((cur != '<') && /* checked */
4949
343M
           (cur != '&') &&
4950
343M
           ((!partial) || (cur != ']') ||
4951
0
            (ctxt->input->end - ctxt->input->cur >= 2)) &&
4952
343M
     (IS_CHAR(cur))) {
4953
199M
  if ((cur == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
4954
2.82k
      xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4955
2.82k
  }
4956
199M
  COPY_BUF(buf, nbchar, cur);
4957
  /* move current position before possible calling of ctxt->sax->characters */
4958
199M
  NEXTL(l);
4959
199M
  if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) {
4960
1.27M
      buf[nbchar] = 0;
4961
4962
1.27M
            xmlCharacters(ctxt, buf, nbchar, 0);
4963
1.27M
      nbchar = 0;
4964
1.27M
            SHRINK;
4965
1.27M
  }
4966
199M
  cur = xmlCurrentCharRecover(ctxt, &l);
4967
199M
    }
4968
144M
    if (nbchar != 0) {
4969
1.00M
        buf[nbchar] = 0;
4970
4971
1.00M
        xmlCharacters(ctxt, buf, nbchar, 0);
4972
1.00M
    }
4973
    /*
4974
     * cur == 0 can mean
4975
     *
4976
     * - End of buffer.
4977
     * - An actual 0 character.
4978
     * - An incomplete UTF-8 sequence. This is allowed if partial is set.
4979
     */
4980
144M
    if (ctxt->input->cur < ctxt->input->end) {
4981
144M
        if ((cur == 0) && (CUR != 0)) {
4982
1.30k
            if (partial == 0) {
4983
1.30k
                xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4984
1.30k
                        "Incomplete UTF-8 sequence starting with %02X\n", CUR);
4985
1.30k
                NEXTL(1);
4986
1.30k
            }
4987
144M
        } else if ((cur != '<') && (cur != '&') && (cur != ']')) {
4988
            /* Generate the error and skip the offending character */
4989
143M
            xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4990
143M
                              "PCDATA invalid Char value %d\n", cur);
4991
143M
            NEXTL(l);
4992
143M
        }
4993
144M
    }
4994
144M
}
4995
4996
/**
4997
 * xmlParseCharData:
4998
 * @ctxt:  an XML parser context
4999
 * @cdata:  unused
5000
 *
5001
 * DEPRECATED: Internal function, don't use.
5002
 */
5003
void
5004
0
xmlParseCharData(xmlParserCtxtPtr ctxt, ATTRIBUTE_UNUSED int cdata) {
5005
0
    xmlParseCharDataInternal(ctxt, 0);
5006
0
}
5007
5008
/**
5009
 * xmlParseExternalID:
5010
 * @ctxt:  an XML parser context
5011
 * @publicID:  a xmlChar** receiving PubidLiteral
5012
 * @strict: indicate whether we should restrict parsing to only
5013
 *          production [75], see NOTE below
5014
 *
5015
 * DEPRECATED: Internal function, don't use.
5016
 *
5017
 * Parse an External ID or a Public ID
5018
 *
5019
 * NOTE: Productions [75] and [83] interact badly since [75] can generate
5020
 *       'PUBLIC' S PubidLiteral S SystemLiteral
5021
 *
5022
 * [75] ExternalID ::= 'SYSTEM' S SystemLiteral
5023
 *                   | 'PUBLIC' S PubidLiteral S SystemLiteral
5024
 *
5025
 * [83] PublicID ::= 'PUBLIC' S PubidLiteral
5026
 *
5027
 * Returns the function returns SystemLiteral and in the second
5028
 *                case publicID receives PubidLiteral, is strict is off
5029
 *                it is possible to return NULL and have publicID set.
5030
 */
5031
5032
xmlChar *
5033
86.7k
xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
5034
86.7k
    xmlChar *URI = NULL;
5035
5036
86.7k
    *publicID = NULL;
5037
86.7k
    if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) {
5038
26.2k
        SKIP(6);
5039
26.2k
  if (SKIP_BLANKS == 0) {
5040
178
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5041
178
                     "Space required after 'SYSTEM'\n");
5042
178
  }
5043
26.2k
  URI = xmlParseSystemLiteral(ctxt);
5044
26.2k
  if (URI == NULL) {
5045
263
      xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
5046
263
        }
5047
60.4k
    } else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) {
5048
11.6k
        SKIP(6);
5049
11.6k
  if (SKIP_BLANKS == 0) {
5050
794
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5051
794
        "Space required after 'PUBLIC'\n");
5052
794
  }
5053
11.6k
  *publicID = xmlParsePubidLiteral(ctxt);
5054
11.6k
  if (*publicID == NULL) {
5055
1.62k
      xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
5056
1.62k
  }
5057
11.6k
  if (strict) {
5058
      /*
5059
       * We don't handle [83] so "S SystemLiteral" is required.
5060
       */
5061
8.11k
      if (SKIP_BLANKS == 0) {
5062
1.86k
    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5063
1.86k
      "Space required after the Public Identifier\n");
5064
1.86k
      }
5065
8.11k
  } else {
5066
      /*
5067
       * We handle [83] so we return immediately, if
5068
       * "S SystemLiteral" is not detected. We skip blanks if no
5069
             * system literal was found, but this is harmless since we must
5070
             * be at the end of a NotationDecl.
5071
       */
5072
3.57k
      if (SKIP_BLANKS == 0) return(NULL);
5073
1.15k
      if ((CUR != '\'') && (CUR != '"')) return(NULL);
5074
1.15k
  }
5075
8.97k
  URI = xmlParseSystemLiteral(ctxt);
5076
8.97k
  if (URI == NULL) {
5077
2.09k
      xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
5078
2.09k
        }
5079
8.97k
    }
5080
83.9k
    return(URI);
5081
86.7k
}
5082
5083
/**
5084
 * xmlParseCommentComplex:
5085
 * @ctxt:  an XML parser context
5086
 * @buf:  the already parsed part of the buffer
5087
 * @len:  number of bytes in the buffer
5088
 * @size:  allocated size of the buffer
5089
 *
5090
 * Skip an XML (SGML) comment <!-- .... -->
5091
 *  The spec says that "For compatibility, the string "--" (double-hyphen)
5092
 *  must not occur within comments. "
5093
 * This is the slow routine in case the accelerator for ascii didn't work
5094
 *
5095
 * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
5096
 */
5097
static void
5098
xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf,
5099
64.8k
                       size_t len, size_t size) {
5100
64.8k
    int q, ql;
5101
64.8k
    int r, rl;
5102
64.8k
    int cur, l;
5103
64.8k
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
5104
0
                    XML_MAX_HUGE_LENGTH :
5105
64.8k
                    XML_MAX_TEXT_LENGTH;
5106
5107
64.8k
    if (buf == NULL) {
5108
2.59k
        len = 0;
5109
2.59k
  size = XML_PARSER_BUFFER_SIZE;
5110
2.59k
  buf = xmlMalloc(size);
5111
2.59k
  if (buf == NULL) {
5112
1
      xmlErrMemory(ctxt);
5113
1
      return;
5114
1
  }
5115
2.59k
    }
5116
64.8k
    q = xmlCurrentCharRecover(ctxt, &ql);
5117
64.8k
    if (q == 0)
5118
782
        goto not_terminated;
5119
64.0k
    if (!IS_CHAR(q)) {
5120
9.48k
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
5121
9.48k
                          "xmlParseComment: invalid xmlChar value %d\n",
5122
9.48k
                    q);
5123
9.48k
  xmlFree (buf);
5124
9.48k
  return;
5125
9.48k
    }
5126
54.6k
    NEXTL(ql);
5127
54.6k
    r = xmlCurrentCharRecover(ctxt, &rl);
5128
54.6k
    if (r == 0)
5129
1.80k
        goto not_terminated;
5130
52.8k
    if (!IS_CHAR(r)) {
5131
233
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
5132
233
                          "xmlParseComment: invalid xmlChar value %d\n",
5133
233
                    r);
5134
233
  xmlFree (buf);
5135
233
  return;
5136
233
    }
5137
52.5k
    NEXTL(rl);
5138
52.5k
    cur = xmlCurrentCharRecover(ctxt, &l);
5139
52.5k
    if (cur == 0)
5140
409
        goto not_terminated;
5141
45.7M
    while (IS_CHAR(cur) && /* checked */
5142
45.7M
           ((cur != '>') ||
5143
45.6M
      (r != '-') || (q != '-'))) {
5144
45.6M
  if ((r == '-') && (q == '-')) {
5145
54.0k
      xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
5146
54.0k
  }
5147
45.6M
  if (len + 5 >= size) {
5148
54.2k
      xmlChar *tmp;
5149
54.2k
            int newSize;
5150
5151
54.2k
      newSize = xmlGrowCapacity(size, 1, 1, maxLength);
5152
54.2k
            if (newSize < 0) {
5153
0
                xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
5154
0
                             "Comment too big found", NULL);
5155
0
                xmlFree (buf);
5156
0
                return;
5157
0
            }
5158
54.2k
      tmp = xmlRealloc(buf, newSize);
5159
54.2k
      if (tmp == NULL) {
5160
3
    xmlErrMemory(ctxt);
5161
3
    xmlFree(buf);
5162
3
    return;
5163
3
      }
5164
54.2k
      buf = tmp;
5165
54.2k
            size = newSize;
5166
54.2k
  }
5167
45.6M
  COPY_BUF(buf, len, q);
5168
5169
45.6M
  q = r;
5170
45.6M
  ql = rl;
5171
45.6M
  r = cur;
5172
45.6M
  rl = l;
5173
5174
45.6M
  NEXTL(l);
5175
45.6M
  cur = xmlCurrentCharRecover(ctxt, &l);
5176
5177
45.6M
    }
5178
52.1k
    buf[len] = 0;
5179
52.1k
    if (cur == 0) {
5180
4.04k
  xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
5181
4.04k
                       "Comment not terminated \n<!--%.50s\n", buf);
5182
48.1k
    } else if (!IS_CHAR(cur)) {
5183
2.12k
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
5184
2.12k
                          "xmlParseComment: invalid xmlChar value %d\n",
5185
2.12k
                    cur);
5186
46.0k
    } else {
5187
46.0k
        NEXT;
5188
46.0k
  if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
5189
46.0k
      (!ctxt->disableSAX))
5190
8.86k
      ctxt->sax->comment(ctxt->userData, buf);
5191
46.0k
    }
5192
52.1k
    xmlFree(buf);
5193
52.1k
    return;
5194
2.99k
not_terminated:
5195
2.99k
    xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
5196
2.99k
       "Comment not terminated\n", NULL);
5197
2.99k
    xmlFree(buf);
5198
2.99k
}
5199
5200
/**
5201
 * xmlParseComment:
5202
 * @ctxt:  an XML parser context
5203
 *
5204
 * DEPRECATED: Internal function, don't use.
5205
 *
5206
 * Parse an XML (SGML) comment. Always consumes '<!'.
5207
 *
5208
 *  The spec says that "For compatibility, the string "--" (double-hyphen)
5209
 *  must not occur within comments. "
5210
 *
5211
 * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
5212
 */
5213
void
5214
186k
xmlParseComment(xmlParserCtxtPtr ctxt) {
5215
186k
    xmlChar *buf = NULL;
5216
186k
    size_t size = XML_PARSER_BUFFER_SIZE;
5217
186k
    size_t len = 0;
5218
186k
    size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ?
5219
0
                       XML_MAX_HUGE_LENGTH :
5220
186k
                       XML_MAX_TEXT_LENGTH;
5221
186k
    const xmlChar *in;
5222
186k
    size_t nbchar = 0;
5223
186k
    int ccol;
5224
5225
    /*
5226
     * Check that there is a comment right here.
5227
     */
5228
186k
    if ((RAW != '<') || (NXT(1) != '!'))
5229
0
        return;
5230
186k
    SKIP(2);
5231
186k
    if ((RAW != '-') || (NXT(1) != '-'))
5232
39
        return;
5233
186k
    SKIP(2);
5234
186k
    GROW;
5235
5236
    /*
5237
     * Accelerated common case where input don't need to be
5238
     * modified before passing it to the handler.
5239
     */
5240
186k
    in = ctxt->input->cur;
5241
187k
    do {
5242
187k
  if (*in == 0xA) {
5243
25.1k
      do {
5244
25.1k
    ctxt->input->line++; ctxt->input->col = 1;
5245
25.1k
    in++;
5246
25.1k
      } while (*in == 0xA);
5247
6.53k
  }
5248
301k
get_more:
5249
301k
        ccol = ctxt->input->col;
5250
8.88M
  while (((*in > '-') && (*in <= 0x7F)) ||
5251
5.82M
         ((*in >= 0x20) && (*in < '-')) ||
5252
8.58M
         (*in == 0x09)) {
5253
8.58M
        in++;
5254
8.58M
        ccol++;
5255
8.58M
  }
5256
301k
  ctxt->input->col = ccol;
5257
301k
  if (*in == 0xA) {
5258
164k
      do {
5259
164k
    ctxt->input->line++; ctxt->input->col = 1;
5260
164k
    in++;
5261
164k
      } while (*in == 0xA);
5262
18.2k
      goto get_more;
5263
18.2k
  }
5264
283k
  nbchar = in - ctxt->input->cur;
5265
  /*
5266
   * save current set of data
5267
   */
5268
283k
  if (nbchar > 0) {
5269
265k
            if (nbchar > maxLength - len) {
5270
0
                xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
5271
0
                                  "Comment too big found", NULL);
5272
0
                xmlFree(buf);
5273
0
                return;
5274
0
            }
5275
265k
            if (buf == NULL) {
5276
179k
                if ((*in == '-') && (in[1] == '-'))
5277
108k
                    size = nbchar + 1;
5278
71.6k
                else
5279
71.6k
                    size = XML_PARSER_BUFFER_SIZE + nbchar;
5280
179k
                buf = xmlMalloc(size);
5281
179k
                if (buf == NULL) {
5282
8
                    xmlErrMemory(ctxt);
5283
8
                    return;
5284
8
                }
5285
179k
                len = 0;
5286
179k
            } else if (len + nbchar + 1 >= size) {
5287
38.7k
                xmlChar *new_buf;
5288
38.7k
                size += len + nbchar + XML_PARSER_BUFFER_SIZE;
5289
38.7k
                new_buf = xmlRealloc(buf, size);
5290
38.7k
                if (new_buf == NULL) {
5291
4
                    xmlErrMemory(ctxt);
5292
4
                    xmlFree(buf);
5293
4
                    return;
5294
4
                }
5295
38.7k
                buf = new_buf;
5296
38.7k
            }
5297
265k
            memcpy(&buf[len], ctxt->input->cur, nbchar);
5298
265k
            len += nbchar;
5299
265k
            buf[len] = 0;
5300
265k
  }
5301
283k
  ctxt->input->cur = in;
5302
283k
  if (*in == 0xA) {
5303
0
      in++;
5304
0
      ctxt->input->line++; ctxt->input->col = 1;
5305
0
  }
5306
283k
  if (*in == 0xD) {
5307
12.9k
      in++;
5308
12.9k
      if (*in == 0xA) {
5309
10.9k
    ctxt->input->cur = in;
5310
10.9k
    in++;
5311
10.9k
    ctxt->input->line++; ctxt->input->col = 1;
5312
10.9k
    goto get_more;
5313
10.9k
      }
5314
1.99k
      in--;
5315
1.99k
  }
5316
272k
  SHRINK;
5317
272k
  GROW;
5318
272k
  in = ctxt->input->cur;
5319
272k
  if (*in == '-') {
5320
206k
      if (in[1] == '-') {
5321
170k
          if (in[2] == '>') {
5322
121k
        SKIP(3);
5323
121k
        if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
5324
121k
            (!ctxt->disableSAX)) {
5325
18.6k
      if (buf != NULL)
5326
14.7k
          ctxt->sax->comment(ctxt->userData, buf);
5327
3.91k
      else
5328
3.91k
          ctxt->sax->comment(ctxt->userData, BAD_CAST "");
5329
18.6k
        }
5330
121k
        if (buf != NULL)
5331
117k
            xmlFree(buf);
5332
121k
        return;
5333
121k
    }
5334
48.5k
    if (buf != NULL) {
5335
40.0k
        xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
5336
40.0k
                          "Double hyphen within comment: "
5337
40.0k
                                      "<!--%.50s\n",
5338
40.0k
              buf);
5339
40.0k
    } else
5340
8.47k
        xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
5341
8.47k
                          "Double hyphen within comment\n", NULL);
5342
48.5k
    in++;
5343
48.5k
    ctxt->input->col++;
5344
48.5k
      }
5345
84.7k
      in++;
5346
84.7k
      ctxt->input->col++;
5347
84.7k
      goto get_more;
5348
206k
  }
5349
272k
    } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09) || (*in == 0x0a));
5350
64.8k
    xmlParseCommentComplex(ctxt, buf, len, size);
5351
64.8k
}
5352
5353
5354
/**
5355
 * xmlParsePITarget:
5356
 * @ctxt:  an XML parser context
5357
 *
5358
 * DEPRECATED: Internal function, don't use.
5359
 *
5360
 * parse the name of a PI
5361
 *
5362
 * [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
5363
 *
5364
 * Returns the PITarget name or NULL
5365
 */
5366
5367
const xmlChar *
5368
48.6k
xmlParsePITarget(xmlParserCtxtPtr ctxt) {
5369
48.6k
    const xmlChar *name;
5370
5371
48.6k
    name = xmlParseName(ctxt);
5372
48.6k
    if ((name != NULL) &&
5373
46.1k
        ((name[0] == 'x') || (name[0] == 'X')) &&
5374
22.1k
        ((name[1] == 'm') || (name[1] == 'M')) &&
5375
9.60k
        ((name[2] == 'l') || (name[2] == 'L'))) {
5376
4.40k
  int i;
5377
4.40k
  if ((name[0] == 'x') && (name[1] == 'm') &&
5378
4.09k
      (name[2] == 'l') && (name[3] == 0)) {
5379
1.12k
      xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
5380
1.12k
     "XML declaration allowed only at the start of the document\n");
5381
1.12k
      return(name);
5382
3.28k
  } else if (name[3] == 0) {
5383
315
      xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
5384
315
      return(name);
5385
315
  }
5386
7.00k
  for (i = 0;;i++) {
5387
7.00k
      if (xmlW3CPIs[i] == NULL) break;
5388
5.58k
      if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i]))
5389
1.54k
          return(name);
5390
5.58k
  }
5391
1.42k
  xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
5392
1.42k
          "xmlParsePITarget: invalid name prefix 'xml'\n",
5393
1.42k
          NULL, NULL);
5394
1.42k
    }
5395
45.6k
    if ((name != NULL) && (xmlStrchr(name, ':') != NULL)) {
5396
861
  xmlNsErr(ctxt, XML_NS_ERR_COLON,
5397
861
     "colons are forbidden from PI names '%s'\n", name, NULL, NULL);
5398
861
    }
5399
45.6k
    return(name);
5400
48.6k
}
5401
5402
#ifdef LIBXML_CATALOG_ENABLED
5403
/**
5404
 * xmlParseCatalogPI:
5405
 * @ctxt:  an XML parser context
5406
 * @catalog:  the PI value string
5407
 *
5408
 * parse an XML Catalog Processing Instruction.
5409
 *
5410
 * <?oasis-xml-catalog catalog="http://example.com/catalog.xml"?>
5411
 *
5412
 * Occurs only if allowed by the user and if happening in the Misc
5413
 * part of the document before any doctype information
5414
 * This will add the given catalog to the parsing context in order
5415
 * to be used if there is a resolution need further down in the document
5416
 */
5417
5418
static void
5419
0
xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
5420
0
    xmlChar *URL = NULL;
5421
0
    const xmlChar *tmp, *base;
5422
0
    xmlChar marker;
5423
5424
0
    tmp = catalog;
5425
0
    while (IS_BLANK_CH(*tmp)) tmp++;
5426
0
    if (xmlStrncmp(tmp, BAD_CAST"catalog", 7))
5427
0
  goto error;
5428
0
    tmp += 7;
5429
0
    while (IS_BLANK_CH(*tmp)) tmp++;
5430
0
    if (*tmp != '=') {
5431
0
  return;
5432
0
    }
5433
0
    tmp++;
5434
0
    while (IS_BLANK_CH(*tmp)) tmp++;
5435
0
    marker = *tmp;
5436
0
    if ((marker != '\'') && (marker != '"'))
5437
0
  goto error;
5438
0
    tmp++;
5439
0
    base = tmp;
5440
0
    while ((*tmp != 0) && (*tmp != marker)) tmp++;
5441
0
    if (*tmp == 0)
5442
0
  goto error;
5443
0
    URL = xmlStrndup(base, tmp - base);
5444
0
    tmp++;
5445
0
    while (IS_BLANK_CH(*tmp)) tmp++;
5446
0
    if (*tmp != 0)
5447
0
  goto error;
5448
5449
0
    if (URL != NULL) {
5450
        /*
5451
         * Unfortunately, the catalog API doesn't report OOM errors.
5452
         * xmlGetLastError isn't very helpful since we don't know
5453
         * where the last error came from. We'd have to reset it
5454
         * before this call and restore it afterwards.
5455
         */
5456
0
  ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
5457
0
  xmlFree(URL);
5458
0
    }
5459
0
    return;
5460
5461
0
error:
5462
0
    xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
5463
0
            "Catalog PI syntax error: %s\n",
5464
0
      catalog, NULL);
5465
0
    if (URL != NULL)
5466
0
  xmlFree(URL);
5467
0
}
5468
#endif
5469
5470
/**
5471
 * xmlParsePI:
5472
 * @ctxt:  an XML parser context
5473
 *
5474
 * DEPRECATED: Internal function, don't use.
5475
 *
5476
 * parse an XML Processing Instruction.
5477
 *
5478
 * [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
5479
 *
5480
 * The processing is transferred to SAX once parsed.
5481
 */
5482
5483
void
5484
48.6k
xmlParsePI(xmlParserCtxtPtr ctxt) {
5485
48.6k
    xmlChar *buf = NULL;
5486
48.6k
    size_t len = 0;
5487
48.6k
    size_t size = XML_PARSER_BUFFER_SIZE;
5488
48.6k
    size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ?
5489
0
                       XML_MAX_HUGE_LENGTH :
5490
48.6k
                       XML_MAX_TEXT_LENGTH;
5491
48.6k
    int cur, l;
5492
48.6k
    const xmlChar *target;
5493
5494
48.6k
    if ((RAW == '<') && (NXT(1) == '?')) {
5495
  /*
5496
   * this is a Processing Instruction.
5497
   */
5498
48.6k
  SKIP(2);
5499
5500
  /*
5501
   * Parse the target name and check for special support like
5502
   * namespace.
5503
   */
5504
48.6k
        target = xmlParsePITarget(ctxt);
5505
48.6k
  if (target != NULL) {
5506
46.1k
      if ((RAW == '?') && (NXT(1) == '>')) {
5507
19.9k
    SKIP(2);
5508
5509
    /*
5510
     * SAX: PI detected.
5511
     */
5512
19.9k
    if ((ctxt->sax) && (!ctxt->disableSAX) &&
5513
18.4k
        (ctxt->sax->processingInstruction != NULL))
5514
18.4k
        ctxt->sax->processingInstruction(ctxt->userData,
5515
18.4k
                                         target, NULL);
5516
19.9k
    return;
5517
19.9k
      }
5518
26.1k
      buf = xmlMalloc(size);
5519
26.1k
      if (buf == NULL) {
5520
2
    xmlErrMemory(ctxt);
5521
2
    return;
5522
2
      }
5523
26.1k
      if (SKIP_BLANKS == 0) {
5524
8.31k
    xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
5525
8.31k
        "ParsePI: PI %s space expected\n", target);
5526
8.31k
      }
5527
26.1k
      cur = xmlCurrentCharRecover(ctxt, &l);
5528
25.6M
      while (IS_CHAR(cur) && /* checked */
5529
25.6M
       ((cur != '?') || (NXT(1) != '>'))) {
5530
25.5M
    if (len + 5 >= size) {
5531
9.39k
        xmlChar *tmp;
5532
9.39k
                    int newSize;
5533
5534
9.39k
                    newSize = xmlGrowCapacity(size, 1, 1, maxLength);
5535
9.39k
                    if (newSize < 0) {
5536
0
                        xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5537
0
                                          "PI %s too big found", target);
5538
0
                        xmlFree(buf);
5539
0
                        return;
5540
0
                    }
5541
9.39k
        tmp = xmlRealloc(buf, newSize);
5542
9.39k
        if (tmp == NULL) {
5543
1
      xmlErrMemory(ctxt);
5544
1
      xmlFree(buf);
5545
1
      return;
5546
1
        }
5547
9.38k
        buf = tmp;
5548
9.38k
                    size = newSize;
5549
9.38k
    }
5550
25.5M
    COPY_BUF(buf, len, cur);
5551
25.5M
    NEXTL(l);
5552
25.5M
    cur = xmlCurrentCharRecover(ctxt, &l);
5553
25.5M
      }
5554
26.1k
      buf[len] = 0;
5555
26.1k
      if (cur != '?') {
5556
7.46k
    xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5557
7.46k
          "ParsePI: PI %s never end ...\n", target);
5558
18.6k
      } else {
5559
18.6k
    SKIP(2);
5560
5561
18.6k
#ifdef LIBXML_CATALOG_ENABLED
5562
18.6k
    if ((ctxt->inSubset == 0) &&
5563
16.4k
        (xmlStrEqual(target, XML_CATALOG_PI))) {
5564
356
        xmlCatalogAllow allow = xmlCatalogGetDefaults();
5565
5566
356
        if ((ctxt->options & XML_PARSE_CATALOG_PI) &&
5567
0
                        ((allow == XML_CATA_ALLOW_DOCUMENT) ||
5568
0
       (allow == XML_CATA_ALLOW_ALL)))
5569
0
      xmlParseCatalogPI(ctxt, buf);
5570
356
    }
5571
18.6k
#endif
5572
5573
    /*
5574
     * SAX: PI detected.
5575
     */
5576
18.6k
    if ((ctxt->sax) && (!ctxt->disableSAX) &&
5577
15.6k
        (ctxt->sax->processingInstruction != NULL))
5578
15.6k
        ctxt->sax->processingInstruction(ctxt->userData,
5579
15.6k
                                         target, buf);
5580
18.6k
      }
5581
26.1k
      xmlFree(buf);
5582
26.1k
  } else {
5583
2.54k
      xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
5584
2.54k
  }
5585
48.6k
    }
5586
48.6k
}
5587
5588
/**
5589
 * xmlParseNotationDecl:
5590
 * @ctxt:  an XML parser context
5591
 *
5592
 * DEPRECATED: Internal function, don't use.
5593
 *
5594
 * Parse a notation declaration. Always consumes '<!'.
5595
 *
5596
 * [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID |  PublicID) S? '>'
5597
 *
5598
 * Hence there is actually 3 choices:
5599
 *     'PUBLIC' S PubidLiteral
5600
 *     'PUBLIC' S PubidLiteral S SystemLiteral
5601
 * and 'SYSTEM' S SystemLiteral
5602
 *
5603
 * See the NOTE on xmlParseExternalID().
5604
 */
5605
5606
void
5607
8.85k
xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
5608
8.85k
    const xmlChar *name;
5609
8.85k
    xmlChar *Pubid;
5610
8.85k
    xmlChar *Systemid;
5611
5612
8.85k
    if ((CUR != '<') || (NXT(1) != '!'))
5613
0
        return;
5614
8.85k
    SKIP(2);
5615
5616
8.85k
    if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
5617
7.66k
  int inputid = ctxt->input->id;
5618
7.66k
  SKIP(8);
5619
7.66k
  if (SKIP_BLANKS_PE == 0) {
5620
222
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5621
222
         "Space required after '<!NOTATION'\n");
5622
222
      return;
5623
222
  }
5624
5625
7.44k
        name = xmlParseName(ctxt);
5626
7.44k
  if (name == NULL) {
5627
250
      xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5628
250
      return;
5629
250
  }
5630
7.19k
  if (xmlStrchr(name, ':') != NULL) {
5631
63
      xmlNsErr(ctxt, XML_NS_ERR_COLON,
5632
63
         "colons are forbidden from notation names '%s'\n",
5633
63
         name, NULL, NULL);
5634
63
  }
5635
7.19k
  if (SKIP_BLANKS_PE == 0) {
5636
102
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5637
102
         "Space required after the NOTATION name'\n");
5638
102
      return;
5639
102
  }
5640
5641
  /*
5642
   * Parse the IDs.
5643
   */
5644
7.09k
  Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
5645
7.09k
  SKIP_BLANKS_PE;
5646
5647
7.09k
  if (RAW == '>') {
5648
6.60k
      if (inputid != ctxt->input->id) {
5649
48
    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5650
48
                         "Notation declaration doesn't start and stop"
5651
48
                               " in the same entity\n");
5652
48
      }
5653
6.60k
      NEXT;
5654
6.60k
      if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5655
6.28k
    (ctxt->sax->notationDecl != NULL))
5656
6.28k
    ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
5657
6.60k
  } else {
5658
487
      xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5659
487
  }
5660
7.09k
  if (Systemid != NULL) xmlFree(Systemid);
5661
7.09k
  if (Pubid != NULL) xmlFree(Pubid);
5662
7.09k
    }
5663
8.85k
}
5664
5665
/**
5666
 * xmlParseEntityDecl:
5667
 * @ctxt:  an XML parser context
5668
 *
5669
 * DEPRECATED: Internal function, don't use.
5670
 *
5671
 * Parse an entity declaration. Always consumes '<!'.
5672
 *
5673
 * [70] EntityDecl ::= GEDecl | PEDecl
5674
 *
5675
 * [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
5676
 *
5677
 * [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
5678
 *
5679
 * [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)
5680
 *
5681
 * [74] PEDef ::= EntityValue | ExternalID
5682
 *
5683
 * [76] NDataDecl ::= S 'NDATA' S Name
5684
 *
5685
 * [ VC: Notation Declared ]
5686
 * The Name must match the declared name of a notation.
5687
 */
5688
5689
void
5690
61.8k
xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
5691
61.8k
    const xmlChar *name = NULL;
5692
61.8k
    xmlChar *value = NULL;
5693
61.8k
    xmlChar *URI = NULL, *literal = NULL;
5694
61.8k
    const xmlChar *ndata = NULL;
5695
61.8k
    int isParameter = 0;
5696
61.8k
    xmlChar *orig = NULL;
5697
5698
61.8k
    if ((CUR != '<') || (NXT(1) != '!'))
5699
0
        return;
5700
61.8k
    SKIP(2);
5701
5702
    /* GROW; done in the caller */
5703
61.8k
    if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
5704
61.2k
  int inputid = ctxt->input->id;
5705
61.2k
  SKIP(6);
5706
61.2k
  if (SKIP_BLANKS_PE == 0) {
5707
3.89k
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5708
3.89k
         "Space required after '<!ENTITY'\n");
5709
3.89k
  }
5710
5711
61.2k
  if (RAW == '%') {
5712
30.7k
      NEXT;
5713
30.7k
      if (SKIP_BLANKS_PE == 0) {
5714
4.87k
    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5715
4.87k
             "Space required after '%%'\n");
5716
4.87k
      }
5717
30.7k
      isParameter = 1;
5718
30.7k
  }
5719
5720
61.2k
        name = xmlParseName(ctxt);
5721
61.2k
  if (name == NULL) {
5722
2.47k
      xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5723
2.47k
                     "xmlParseEntityDecl: no name\n");
5724
2.47k
            return;
5725
2.47k
  }
5726
58.8k
  if (xmlStrchr(name, ':') != NULL) {
5727
1.58k
      xmlNsErr(ctxt, XML_NS_ERR_COLON,
5728
1.58k
         "colons are forbidden from entities names '%s'\n",
5729
1.58k
         name, NULL, NULL);
5730
1.58k
  }
5731
58.8k
  if (SKIP_BLANKS_PE == 0) {
5732
3.73k
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5733
3.73k
         "Space required after the entity name\n");
5734
3.73k
  }
5735
5736
  /*
5737
   * handle the various case of definitions...
5738
   */
5739
58.8k
  if (isParameter) {
5740
28.6k
      if ((RAW == '"') || (RAW == '\'')) {
5741
13.9k
          value = xmlParseEntityValue(ctxt, &orig);
5742
13.9k
    if (value) {
5743
13.5k
        if ((ctxt->sax != NULL) &&
5744
13.5k
      (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5745
10.6k
      ctxt->sax->entityDecl(ctxt->userData, name,
5746
10.6k
                        XML_INTERNAL_PARAMETER_ENTITY,
5747
10.6k
            NULL, NULL, value);
5748
13.5k
    }
5749
14.7k
      } else {
5750
14.7k
          URI = xmlParseExternalID(ctxt, &literal, 1);
5751
14.7k
    if ((URI == NULL) && (literal == NULL)) {
5752
803
        xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5753
803
    }
5754
14.7k
    if (URI) {
5755
13.5k
                    if (xmlStrchr(URI, '#')) {
5756
592
                        xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5757
12.9k
                    } else {
5758
12.9k
                        if ((ctxt->sax != NULL) &&
5759
12.9k
                            (!ctxt->disableSAX) &&
5760
11.4k
                            (ctxt->sax->entityDecl != NULL))
5761
11.4k
                            ctxt->sax->entityDecl(ctxt->userData, name,
5762
11.4k
                                        XML_EXTERNAL_PARAMETER_ENTITY,
5763
11.4k
                                        literal, URI, NULL);
5764
12.9k
                    }
5765
13.5k
    }
5766
14.7k
      }
5767
30.1k
  } else {
5768
30.1k
      if ((RAW == '"') || (RAW == '\'')) {
5769
22.3k
          value = xmlParseEntityValue(ctxt, &orig);
5770
22.3k
    if ((ctxt->sax != NULL) &&
5771
22.3k
        (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5772
12.4k
        ctxt->sax->entityDecl(ctxt->userData, name,
5773
12.4k
        XML_INTERNAL_GENERAL_ENTITY,
5774
12.4k
        NULL, NULL, value);
5775
    /*
5776
     * For expat compatibility in SAX mode.
5777
     */
5778
22.3k
    if ((ctxt->myDoc == NULL) ||
5779
18.3k
        (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
5780
5.32k
        if (ctxt->myDoc == NULL) {
5781
4.00k
      ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5782
4.00k
      if (ctxt->myDoc == NULL) {
5783
6
          xmlErrMemory(ctxt);
5784
6
          goto done;
5785
6
      }
5786
3.99k
      ctxt->myDoc->properties = XML_DOC_INTERNAL;
5787
3.99k
        }
5788
5.31k
        if (ctxt->myDoc->intSubset == NULL) {
5789
3.99k
      ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5790
3.99k
              BAD_CAST "fake", NULL, NULL);
5791
3.99k
                        if (ctxt->myDoc->intSubset == NULL) {
5792
1
                            xmlErrMemory(ctxt);
5793
1
                            goto done;
5794
1
                        }
5795
3.99k
                    }
5796
5797
5.31k
        xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
5798
5.31k
                    NULL, NULL, value);
5799
5.31k
    }
5800
22.3k
      } else {
5801
7.75k
          URI = xmlParseExternalID(ctxt, &literal, 1);
5802
7.75k
    if ((URI == NULL) && (literal == NULL)) {
5803
3.34k
        xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5804
3.34k
    }
5805
7.75k
    if (URI) {
5806
4.33k
                    if (xmlStrchr(URI, '#')) {
5807
1
                        xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5808
1
                    }
5809
4.33k
    }
5810
7.75k
    if ((RAW != '>') && (SKIP_BLANKS_PE == 0)) {
5811
2.01k
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5812
2.01k
           "Space required before 'NDATA'\n");
5813
2.01k
    }
5814
7.75k
    if (CMP5(CUR_PTR, 'N', 'D', 'A', 'T', 'A')) {
5815
935
        SKIP(5);
5816
935
        if (SKIP_BLANKS_PE == 0) {
5817
724
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5818
724
               "Space required after 'NDATA'\n");
5819
724
        }
5820
935
        ndata = xmlParseName(ctxt);
5821
935
        if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5822
210
            (ctxt->sax->unparsedEntityDecl != NULL))
5823
210
      ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
5824
210
            literal, URI, ndata);
5825
6.81k
    } else {
5826
6.81k
        if ((ctxt->sax != NULL) &&
5827
6.81k
            (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5828
4.24k
      ctxt->sax->entityDecl(ctxt->userData, name,
5829
4.24k
            XML_EXTERNAL_GENERAL_PARSED_ENTITY,
5830
4.24k
            literal, URI, NULL);
5831
        /*
5832
         * For expat compatibility in SAX mode.
5833
         * assuming the entity replacement was asked for
5834
         */
5835
6.81k
        if ((ctxt->replaceEntities != 0) &&
5836
5.37k
      ((ctxt->myDoc == NULL) ||
5837
4.96k
      (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
5838
593
      if (ctxt->myDoc == NULL) {
5839
407
          ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5840
407
          if (ctxt->myDoc == NULL) {
5841
3
              xmlErrMemory(ctxt);
5842
3
        goto done;
5843
3
          }
5844
404
          ctxt->myDoc->properties = XML_DOC_INTERNAL;
5845
404
      }
5846
5847
590
      if (ctxt->myDoc->intSubset == NULL) {
5848
404
          ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5849
404
            BAD_CAST "fake", NULL, NULL);
5850
404
                            if (ctxt->myDoc->intSubset == NULL) {
5851
0
                                xmlErrMemory(ctxt);
5852
0
                                goto done;
5853
0
                            }
5854
404
                        }
5855
590
      xmlSAX2EntityDecl(ctxt, name,
5856
590
                  XML_EXTERNAL_GENERAL_PARSED_ENTITY,
5857
590
                  literal, URI, NULL);
5858
590
        }
5859
6.81k
    }
5860
7.75k
      }
5861
30.1k
  }
5862
58.8k
  SKIP_BLANKS_PE;
5863
58.8k
  if (RAW != '>') {
5864
9.85k
      xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
5865
9.85k
              "xmlParseEntityDecl: entity %s not terminated\n", name);
5866
9.85k
      xmlHaltParser(ctxt);
5867
48.9k
  } else {
5868
48.9k
      if (inputid != ctxt->input->id) {
5869
118
    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5870
118
                         "Entity declaration doesn't start and stop in"
5871
118
                               " the same entity\n");
5872
118
      }
5873
48.9k
      NEXT;
5874
48.9k
  }
5875
58.8k
  if (orig != NULL) {
5876
      /*
5877
       * Ugly mechanism to save the raw entity value.
5878
       */
5879
35.2k
      xmlEntityPtr cur = NULL;
5880
5881
35.2k
      if (isParameter) {
5882
13.5k
          if ((ctxt->sax != NULL) &&
5883
13.5k
        (ctxt->sax->getParameterEntity != NULL))
5884
13.5k
        cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
5885
21.7k
      } else {
5886
21.7k
          if ((ctxt->sax != NULL) &&
5887
21.7k
        (ctxt->sax->getEntity != NULL))
5888
21.7k
        cur = ctxt->sax->getEntity(ctxt->userData, name);
5889
21.7k
    if ((cur == NULL) && (ctxt->userData==ctxt)) {
5890
4.27k
        cur = xmlSAX2GetEntity(ctxt, name);
5891
4.27k
    }
5892
21.7k
      }
5893
35.2k
            if ((cur != NULL) && (cur->orig == NULL)) {
5894
17.4k
    cur->orig = orig;
5895
17.4k
                orig = NULL;
5896
17.4k
      }
5897
35.2k
  }
5898
5899
58.8k
done:
5900
58.8k
  if (value != NULL) xmlFree(value);
5901
58.8k
  if (URI != NULL) xmlFree(URI);
5902
58.8k
  if (literal != NULL) xmlFree(literal);
5903
58.8k
        if (orig != NULL) xmlFree(orig);
5904
58.8k
    }
5905
61.8k
}
5906
5907
/**
5908
 * xmlParseDefaultDecl:
5909
 * @ctxt:  an XML parser context
5910
 * @value:  Receive a possible fixed default value for the attribute
5911
 *
5912
 * DEPRECATED: Internal function, don't use.
5913
 *
5914
 * Parse an attribute default declaration
5915
 *
5916
 * [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue)
5917
 *
5918
 * [ VC: Required Attribute ]
5919
 * if the default declaration is the keyword #REQUIRED, then the
5920
 * attribute must be specified for all elements of the type in the
5921
 * attribute-list declaration.
5922
 *
5923
 * [ VC: Attribute Default Legal ]
5924
 * The declared default value must meet the lexical constraints of
5925
 * the declared attribute type c.f. xmlValidateAttributeDecl()
5926
 *
5927
 * [ VC: Fixed Attribute Default ]
5928
 * if an attribute has a default value declared with the #FIXED
5929
 * keyword, instances of that attribute must match the default value.
5930
 *
5931
 * [ WFC: No < in Attribute Values ]
5932
 * handled in xmlParseAttValue()
5933
 *
5934
 * returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED
5935
 *          or XML_ATTRIBUTE_FIXED.
5936
 */
5937
5938
int
5939
59.0k
xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
5940
59.0k
    int val;
5941
59.0k
    xmlChar *ret;
5942
5943
59.0k
    *value = NULL;
5944
59.0k
    if (CMP9(CUR_PTR, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E', 'D')) {
5945
402
  SKIP(9);
5946
402
  return(XML_ATTRIBUTE_REQUIRED);
5947
402
    }
5948
58.6k
    if (CMP8(CUR_PTR, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D')) {
5949
8.80k
  SKIP(8);
5950
8.80k
  return(XML_ATTRIBUTE_IMPLIED);
5951
8.80k
    }
5952
49.7k
    val = XML_ATTRIBUTE_NONE;
5953
49.7k
    if (CMP6(CUR_PTR, '#', 'F', 'I', 'X', 'E', 'D')) {
5954
86
  SKIP(6);
5955
86
  val = XML_ATTRIBUTE_FIXED;
5956
86
  if (SKIP_BLANKS_PE == 0) {
5957
66
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5958
66
         "Space required after '#FIXED'\n");
5959
66
  }
5960
86
    }
5961
49.7k
    ret = xmlParseAttValue(ctxt);
5962
49.7k
    if (ret == NULL) {
5963
7.58k
  xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
5964
7.58k
           "Attribute default value declaration error\n");
5965
7.58k
    } else
5966
42.2k
        *value = ret;
5967
49.7k
    return(val);
5968
58.6k
}
5969
5970
/**
5971
 * xmlParseNotationType:
5972
 * @ctxt:  an XML parser context
5973
 *
5974
 * DEPRECATED: Internal function, don't use.
5975
 *
5976
 * parse an Notation attribute type.
5977
 *
5978
 * Note: the leading 'NOTATION' S part has already being parsed...
5979
 *
5980
 * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
5981
 *
5982
 * [ VC: Notation Attributes ]
5983
 * Values of this type must match one of the notation names included
5984
 * in the declaration; all notation names in the declaration must be declared.
5985
 *
5986
 * Returns: the notation attribute tree built while parsing
5987
 */
5988
5989
xmlEnumerationPtr
5990
674
xmlParseNotationType(xmlParserCtxtPtr ctxt) {
5991
674
    const xmlChar *name;
5992
674
    xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
5993
5994
674
    if (RAW != '(') {
5995
93
  xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5996
93
  return(NULL);
5997
93
    }
5998
1.14k
    do {
5999
1.14k
        NEXT;
6000
1.14k
  SKIP_BLANKS_PE;
6001
1.14k
        name = xmlParseName(ctxt);
6002
1.14k
  if (name == NULL) {
6003
262
      xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6004
262
         "Name expected in NOTATION declaration\n");
6005
262
            xmlFreeEnumeration(ret);
6006
262
      return(NULL);
6007
262
  }
6008
881
        tmp = NULL;
6009
#ifdef LIBXML_VALID_ENABLED
6010
        if (ctxt->validate) {
6011
            tmp = ret;
6012
            while (tmp != NULL) {
6013
                if (xmlStrEqual(name, tmp->name)) {
6014
                    xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
6015
              "standalone: attribute notation value token %s duplicated\n",
6016
                                     name, NULL);
6017
                    if (!xmlDictOwns(ctxt->dict, name))
6018
                        xmlFree((xmlChar *) name);
6019
                    break;
6020
                }
6021
                tmp = tmp->next;
6022
            }
6023
        }
6024
#endif /* LIBXML_VALID_ENABLED */
6025
881
  if (tmp == NULL) {
6026
881
      cur = xmlCreateEnumeration(name);
6027
881
      if (cur == NULL) {
6028
0
                xmlErrMemory(ctxt);
6029
0
                xmlFreeEnumeration(ret);
6030
0
                return(NULL);
6031
0
            }
6032
881
      if (last == NULL) ret = last = cur;
6033
337
      else {
6034
337
    last->next = cur;
6035
337
    last = cur;
6036
337
      }
6037
881
  }
6038
881
  SKIP_BLANKS_PE;
6039
881
    } while (RAW == '|');
6040
319
    if (RAW != ')') {
6041
249
  xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
6042
249
        xmlFreeEnumeration(ret);
6043
249
  return(NULL);
6044
249
    }
6045
70
    NEXT;
6046
70
    return(ret);
6047
319
}
6048
6049
/**
6050
 * xmlParseEnumerationType:
6051
 * @ctxt:  an XML parser context
6052
 *
6053
 * DEPRECATED: Internal function, don't use.
6054
 *
6055
 * parse an Enumeration attribute type.
6056
 *
6057
 * [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'
6058
 *
6059
 * [ VC: Enumeration ]
6060
 * Values of this type must match one of the Nmtoken tokens in
6061
 * the declaration
6062
 *
6063
 * Returns: the enumeration attribute tree built while parsing
6064
 */
6065
6066
xmlEnumerationPtr
6067
4.69k
xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
6068
4.69k
    xmlChar *name;
6069
4.69k
    xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
6070
6071
4.69k
    if (RAW != '(') {
6072
3.68k
  xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
6073
3.68k
  return(NULL);
6074
3.68k
    }
6075
1.70k
    do {
6076
1.70k
        NEXT;
6077
1.70k
  SKIP_BLANKS_PE;
6078
1.70k
        name = xmlParseNmtoken(ctxt);
6079
1.70k
  if (name == NULL) {
6080
177
      xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
6081
177
      return(ret);
6082
177
  }
6083
1.53k
        tmp = NULL;
6084
#ifdef LIBXML_VALID_ENABLED
6085
        if (ctxt->validate) {
6086
            tmp = ret;
6087
            while (tmp != NULL) {
6088
                if (xmlStrEqual(name, tmp->name)) {
6089
                    xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
6090
              "standalone: attribute enumeration value token %s duplicated\n",
6091
                                     name, NULL);
6092
                    if (!xmlDictOwns(ctxt->dict, name))
6093
                        xmlFree(name);
6094
                    break;
6095
                }
6096
                tmp = tmp->next;
6097
            }
6098
        }
6099
#endif /* LIBXML_VALID_ENABLED */
6100
1.53k
  if (tmp == NULL) {
6101
1.53k
      cur = xmlCreateEnumeration(name);
6102
1.53k
      if (!xmlDictOwns(ctxt->dict, name))
6103
1.53k
    xmlFree(name);
6104
1.53k
      if (cur == NULL) {
6105
1
                xmlErrMemory(ctxt);
6106
1
                xmlFreeEnumeration(ret);
6107
1
                return(NULL);
6108
1
            }
6109
1.53k
      if (last == NULL) ret = last = cur;
6110
694
      else {
6111
694
    last->next = cur;
6112
694
    last = cur;
6113
694
      }
6114
1.53k
  }
6115
1.53k
  SKIP_BLANKS_PE;
6116
1.53k
    } while (RAW == '|');
6117
833
    if (RAW != ')') {
6118
147
  xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
6119
147
  return(ret);
6120
147
    }
6121
686
    NEXT;
6122
686
    return(ret);
6123
833
}
6124
6125
/**
6126
 * xmlParseEnumeratedType:
6127
 * @ctxt:  an XML parser context
6128
 * @tree:  the enumeration tree built while parsing
6129
 *
6130
 * DEPRECATED: Internal function, don't use.
6131
 *
6132
 * parse an Enumerated attribute type.
6133
 *
6134
 * [57] EnumeratedType ::= NotationType | Enumeration
6135
 *
6136
 * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
6137
 *
6138
 *
6139
 * Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION
6140
 */
6141
6142
int
6143
5.57k
xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
6144
5.57k
    if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
6145
886
  SKIP(8);
6146
886
  if (SKIP_BLANKS_PE == 0) {
6147
212
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6148
212
         "Space required after 'NOTATION'\n");
6149
212
      return(0);
6150
212
  }
6151
674
  *tree = xmlParseNotationType(ctxt);
6152
674
  if (*tree == NULL) return(0);
6153
70
  return(XML_ATTRIBUTE_NOTATION);
6154
674
    }
6155
4.69k
    *tree = xmlParseEnumerationType(ctxt);
6156
4.69k
    if (*tree == NULL) return(0);
6157
835
    return(XML_ATTRIBUTE_ENUMERATION);
6158
4.69k
}
6159
6160
/**
6161
 * xmlParseAttributeType:
6162
 * @ctxt:  an XML parser context
6163
 * @tree:  the enumeration tree built while parsing
6164
 *
6165
 * DEPRECATED: Internal function, don't use.
6166
 *
6167
 * parse the Attribute list def for an element
6168
 *
6169
 * [54] AttType ::= StringType | TokenizedType | EnumeratedType
6170
 *
6171
 * [55] StringType ::= 'CDATA'
6172
 *
6173
 * [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' |
6174
 *                        'ENTITIES' | 'NMTOKEN' | 'NMTOKENS'
6175
 *
6176
 * Validity constraints for attribute values syntax are checked in
6177
 * xmlValidateAttributeValue()
6178
 *
6179
 * [ VC: ID ]
6180
 * Values of type ID must match the Name production. A name must not
6181
 * appear more than once in an XML document as a value of this type;
6182
 * i.e., ID values must uniquely identify the elements which bear them.
6183
 *
6184
 * [ VC: One ID per Element Type ]
6185
 * No element type may have more than one ID attribute specified.
6186
 *
6187
 * [ VC: ID Attribute Default ]
6188
 * An ID attribute must have a declared default of #IMPLIED or #REQUIRED.
6189
 *
6190
 * [ VC: IDREF ]
6191
 * Values of type IDREF must match the Name production, and values
6192
 * of type IDREFS must match Names; each IDREF Name must match the value
6193
 * of an ID attribute on some element in the XML document; i.e. IDREF
6194
 * values must match the value of some ID attribute.
6195
 *
6196
 * [ VC: Entity Name ]
6197
 * Values of type ENTITY must match the Name production, values
6198
 * of type ENTITIES must match Names; each Entity Name must match the
6199
 * name of an unparsed entity declared in the DTD.
6200
 *
6201
 * [ VC: Name Token ]
6202
 * Values of type NMTOKEN must match the Nmtoken production; values
6203
 * of type NMTOKENS must match Nmtokens.
6204
 *
6205
 * Returns the attribute type
6206
 */
6207
int
6208
65.9k
xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
6209
65.9k
    if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) {
6210
7.23k
  SKIP(5);
6211
7.23k
  return(XML_ATTRIBUTE_CDATA);
6212
58.7k
     } else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) {
6213
344
  SKIP(6);
6214
344
  return(XML_ATTRIBUTE_IDREFS);
6215
58.3k
     } else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) {
6216
333
  SKIP(5);
6217
333
  return(XML_ATTRIBUTE_IDREF);
6218
58.0k
     } else if ((RAW == 'I') && (NXT(1) == 'D')) {
6219
47.0k
        SKIP(2);
6220
47.0k
  return(XML_ATTRIBUTE_ID);
6221
47.0k
     } else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
6222
109
  SKIP(6);
6223
109
  return(XML_ATTRIBUTE_ENTITY);
6224
10.8k
     } else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) {
6225
558
  SKIP(8);
6226
558
  return(XML_ATTRIBUTE_ENTITIES);
6227
10.3k
     } else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) {
6228
4.28k
  SKIP(8);
6229
4.28k
  return(XML_ATTRIBUTE_NMTOKENS);
6230
6.05k
     } else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) {
6231
474
  SKIP(7);
6232
474
  return(XML_ATTRIBUTE_NMTOKEN);
6233
474
     }
6234
5.57k
     return(xmlParseEnumeratedType(ctxt, tree));
6235
65.9k
}
6236
6237
/**
6238
 * xmlParseAttributeListDecl:
6239
 * @ctxt:  an XML parser context
6240
 *
6241
 * DEPRECATED: Internal function, don't use.
6242
 *
6243
 * Parse an attribute list declaration for an element. Always consumes '<!'.
6244
 *
6245
 * [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
6246
 *
6247
 * [53] AttDef ::= S Name S AttType S DefaultDecl
6248
 *
6249
 */
6250
void
6251
32.4k
xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
6252
32.4k
    const xmlChar *elemName;
6253
32.4k
    const xmlChar *attrName;
6254
32.4k
    xmlEnumerationPtr tree;
6255
6256
32.4k
    if ((CUR != '<') || (NXT(1) != '!'))
6257
0
        return;
6258
32.4k
    SKIP(2);
6259
6260
32.4k
    if (CMP7(CUR_PTR, 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
6261
31.5k
  int inputid = ctxt->input->id;
6262
6263
31.5k
  SKIP(7);
6264
31.5k
  if (SKIP_BLANKS_PE == 0) {
6265
2.22k
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6266
2.22k
                     "Space required after '<!ATTLIST'\n");
6267
2.22k
  }
6268
31.5k
        elemName = xmlParseName(ctxt);
6269
31.5k
  if (elemName == NULL) {
6270
23
      xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6271
23
         "ATTLIST: no name for Element\n");
6272
23
      return;
6273
23
  }
6274
31.4k
  SKIP_BLANKS_PE;
6275
31.4k
  GROW;
6276
83.4k
  while ((RAW != '>') && (PARSER_STOPPED(ctxt) == 0)) {
6277
67.7k
      int type;
6278
67.7k
      int def;
6279
67.7k
      xmlChar *defaultValue = NULL;
6280
6281
67.7k
      GROW;
6282
67.7k
            tree = NULL;
6283
67.7k
      attrName = xmlParseName(ctxt);
6284
67.7k
      if (attrName == NULL) {
6285
720
    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6286
720
             "ATTLIST: no name for Attribute\n");
6287
720
    break;
6288
720
      }
6289
66.9k
      GROW;
6290
66.9k
      if (SKIP_BLANKS_PE == 0) {
6291
1.05k
    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6292
1.05k
            "Space required after the attribute name\n");
6293
1.05k
    break;
6294
1.05k
      }
6295
6296
65.9k
      type = xmlParseAttributeType(ctxt, &tree);
6297
65.9k
      if (type <= 0) {
6298
4.67k
          break;
6299
4.67k
      }
6300
6301
61.2k
      GROW;
6302
61.2k
      if (SKIP_BLANKS_PE == 0) {
6303
2.26k
    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6304
2.26k
             "Space required after the attribute type\n");
6305
2.26k
          if (tree != NULL)
6306
170
        xmlFreeEnumeration(tree);
6307
2.26k
    break;
6308
2.26k
      }
6309
6310
59.0k
      def = xmlParseDefaultDecl(ctxt, &defaultValue);
6311
59.0k
      if (def <= 0) {
6312
0
                if (defaultValue != NULL)
6313
0
        xmlFree(defaultValue);
6314
0
          if (tree != NULL)
6315
0
        xmlFreeEnumeration(tree);
6316
0
          break;
6317
0
      }
6318
59.0k
      if ((type != XML_ATTRIBUTE_CDATA) && (defaultValue != NULL))
6319
40.5k
          xmlAttrNormalizeSpace(defaultValue, defaultValue);
6320
6321
59.0k
      GROW;
6322
59.0k
            if (RAW != '>') {
6323
46.2k
    if (SKIP_BLANKS_PE == 0) {
6324
6.99k
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6325
6.99k
      "Space required after the attribute default value\n");
6326
6.99k
        if (defaultValue != NULL)
6327
490
      xmlFree(defaultValue);
6328
6.99k
        if (tree != NULL)
6329
337
      xmlFreeEnumeration(tree);
6330
6.99k
        break;
6331
6.99k
    }
6332
46.2k
      }
6333
52.0k
      if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6334
35.1k
    (ctxt->sax->attributeDecl != NULL))
6335
35.1k
    ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
6336
35.1k
                          type, def, defaultValue, tree);
6337
16.8k
      else if (tree != NULL)
6338
184
    xmlFreeEnumeration(tree);
6339
6340
52.0k
      if ((ctxt->sax2) && (defaultValue != NULL) &&
6341
41.7k
          (def != XML_ATTRIBUTE_IMPLIED) &&
6342
41.7k
    (def != XML_ATTRIBUTE_REQUIRED)) {
6343
41.7k
    xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
6344
41.7k
      }
6345
52.0k
      if (ctxt->sax2) {
6346
52.0k
    xmlAddSpecialAttr(ctxt, elemName, attrName, type);
6347
52.0k
      }
6348
52.0k
      if (defaultValue != NULL)
6349
41.7k
          xmlFree(defaultValue);
6350
52.0k
      GROW;
6351
52.0k
  }
6352
31.4k
  if (RAW == '>') {
6353
15.8k
      if (inputid != ctxt->input->id) {
6354
1.87k
    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6355
1.87k
                               "Attribute list declaration doesn't start and"
6356
1.87k
                               " stop in the same entity\n");
6357
1.87k
      }
6358
15.8k
      NEXT;
6359
15.8k
  }
6360
31.4k
    }
6361
32.4k
}
6362
6363
/**
6364
 * xmlParseElementMixedContentDecl:
6365
 * @ctxt:  an XML parser context
6366
 * @inputchk:  the input used for the current entity, needed for boundary checks
6367
 *
6368
 * DEPRECATED: Internal function, don't use.
6369
 *
6370
 * parse the declaration for a Mixed Element content
6371
 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6372
 *
6373
 * [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' |
6374
 *                '(' S? '#PCDATA' S? ')'
6375
 *
6376
 * [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49])
6377
 *
6378
 * [ VC: No Duplicate Types ]
6379
 * The same name must not appear more than once in a single
6380
 * mixed-content declaration.
6381
 *
6382
 * returns: the list of the xmlElementContentPtr describing the element choices
6383
 */
6384
xmlElementContentPtr
6385
7.24k
xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6386
7.24k
    xmlElementContentPtr ret = NULL, cur = NULL, n;
6387
7.24k
    const xmlChar *elem = NULL;
6388
6389
7.24k
    GROW;
6390
7.24k
    if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
6391
7.24k
  SKIP(7);
6392
7.24k
  SKIP_BLANKS_PE;
6393
7.24k
  if (RAW == ')') {
6394
5.15k
      if (ctxt->input->id != inputchk) {
6395
166
    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6396
166
                               "Element content declaration doesn't start and"
6397
166
                               " stop in the same entity\n");
6398
166
      }
6399
5.15k
      NEXT;
6400
5.15k
      ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
6401
5.15k
      if (ret == NULL)
6402
1
                goto mem_error;
6403
5.15k
      if (RAW == '*') {
6404
8
    ret->ocur = XML_ELEMENT_CONTENT_MULT;
6405
8
    NEXT;
6406
8
      }
6407
5.15k
      return(ret);
6408
5.15k
  }
6409
2.09k
  if ((RAW == '(') || (RAW == '|')) {
6410
1.05k
      ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
6411
1.05k
      if (ret == NULL)
6412
1
                goto mem_error;
6413
1.05k
  }
6414
3.38k
  while ((RAW == '|') && (PARSER_STOPPED(ctxt) == 0)) {
6415
1.62k
      NEXT;
6416
1.62k
            n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6417
1.62k
            if (n == NULL)
6418
0
                goto mem_error;
6419
1.62k
      if (elem == NULL) {
6420
870
    n->c1 = cur;
6421
870
    if (cur != NULL)
6422
870
        cur->parent = n;
6423
870
    ret = cur = n;
6424
870
      } else {
6425
753
          cur->c2 = n;
6426
753
    n->parent = cur;
6427
753
    n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6428
753
                if (n->c1 == NULL)
6429
0
                    goto mem_error;
6430
753
    n->c1->parent = n;
6431
753
    cur = n;
6432
753
      }
6433
1.62k
      SKIP_BLANKS_PE;
6434
1.62k
      elem = xmlParseName(ctxt);
6435
1.62k
      if (elem == NULL) {
6436
329
    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6437
329
      "xmlParseElementMixedContentDecl : Name expected\n");
6438
329
    xmlFreeDocElementContent(ctxt->myDoc, ret);
6439
329
    return(NULL);
6440
329
      }
6441
1.29k
      SKIP_BLANKS_PE;
6442
1.29k
      GROW;
6443
1.29k
  }
6444
1.76k
  if ((RAW == ')') && (NXT(1) == '*')) {
6445
311
      if (elem != NULL) {
6446
311
    cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
6447
311
                                   XML_ELEMENT_CONTENT_ELEMENT);
6448
311
    if (cur->c2 == NULL)
6449
1
                    goto mem_error;
6450
310
    cur->c2->parent = cur;
6451
310
            }
6452
310
            if (ret != NULL)
6453
310
                ret->ocur = XML_ELEMENT_CONTENT_MULT;
6454
310
      if (ctxt->input->id != inputchk) {
6455
0
    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6456
0
                               "Element content declaration doesn't start and"
6457
0
                               " stop in the same entity\n");
6458
0
      }
6459
310
      SKIP(2);
6460
1.45k
  } else {
6461
1.45k
      xmlFreeDocElementContent(ctxt->myDoc, ret);
6462
1.45k
      xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
6463
1.45k
      return(NULL);
6464
1.45k
  }
6465
6466
1.76k
    } else {
6467
0
  xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
6468
0
    }
6469
310
    return(ret);
6470
6471
3
mem_error:
6472
3
    xmlErrMemory(ctxt);
6473
3
    xmlFreeDocElementContent(ctxt->myDoc, ret);
6474
3
    return(NULL);
6475
7.24k
}
6476
6477
/**
6478
 * xmlParseElementChildrenContentDeclPriv:
6479
 * @ctxt:  an XML parser context
6480
 * @inputchk:  the input used for the current entity, needed for boundary checks
6481
 * @depth: the level of recursion
6482
 *
6483
 * parse the declaration for a Mixed Element content
6484
 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6485
 *
6486
 *
6487
 * [47] children ::= (choice | seq) ('?' | '*' | '+')?
6488
 *
6489
 * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
6490
 *
6491
 * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
6492
 *
6493
 * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
6494
 *
6495
 * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
6496
 * TODO Parameter-entity replacement text must be properly nested
6497
 *  with parenthesized groups. That is to say, if either of the
6498
 *  opening or closing parentheses in a choice, seq, or Mixed
6499
 *  construct is contained in the replacement text for a parameter
6500
 *  entity, both must be contained in the same replacement text. For
6501
 *  interoperability, if a parameter-entity reference appears in a
6502
 *  choice, seq, or Mixed construct, its replacement text should not
6503
 *  be empty, and neither the first nor last non-blank character of
6504
 *  the replacement text should be a connector (| or ,).
6505
 *
6506
 * Returns the tree of xmlElementContentPtr describing the element
6507
 *          hierarchy.
6508
 */
6509
static xmlElementContentPtr
6510
xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk,
6511
44.2k
                                       int depth) {
6512
44.2k
    int maxDepth = (ctxt->options & XML_PARSE_HUGE) ? 2048 : 256;
6513
44.2k
    xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
6514
44.2k
    const xmlChar *elem;
6515
44.2k
    xmlChar type = 0;
6516
6517
44.2k
    if (depth > maxDepth) {
6518
57
        xmlFatalErrMsgInt(ctxt, XML_ERR_RESOURCE_LIMIT,
6519
57
                "xmlParseElementChildrenContentDecl : depth %d too deep, "
6520
57
                "use XML_PARSE_HUGE\n", depth);
6521
57
  return(NULL);
6522
57
    }
6523
44.2k
    SKIP_BLANKS_PE;
6524
44.2k
    GROW;
6525
44.2k
    if (RAW == '(') {
6526
23.1k
  int inputid = ctxt->input->id;
6527
6528
        /* Recurse on first child */
6529
23.1k
  NEXT;
6530
23.1k
  SKIP_BLANKS_PE;
6531
23.1k
        cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6532
23.1k
                                                           depth + 1);
6533
23.1k
        if (cur == NULL)
6534
19.2k
            return(NULL);
6535
3.92k
  SKIP_BLANKS_PE;
6536
3.92k
  GROW;
6537
21.0k
    } else {
6538
21.0k
  elem = xmlParseName(ctxt);
6539
21.0k
  if (elem == NULL) {
6540
710
      xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6541
710
      return(NULL);
6542
710
  }
6543
20.3k
        cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6544
20.3k
  if (cur == NULL) {
6545
3
      xmlErrMemory(ctxt);
6546
3
      return(NULL);
6547
3
  }
6548
20.2k
  GROW;
6549
20.2k
  if (RAW == '?') {
6550
900
      cur->ocur = XML_ELEMENT_CONTENT_OPT;
6551
900
      NEXT;
6552
19.3k
  } else if (RAW == '*') {
6553
3.44k
      cur->ocur = XML_ELEMENT_CONTENT_MULT;
6554
3.44k
      NEXT;
6555
15.9k
  } else if (RAW == '+') {
6556
648
      cur->ocur = XML_ELEMENT_CONTENT_PLUS;
6557
648
      NEXT;
6558
15.3k
  } else {
6559
15.3k
      cur->ocur = XML_ELEMENT_CONTENT_ONCE;
6560
15.3k
  }
6561
20.2k
  GROW;
6562
20.2k
    }
6563
24.2k
    SKIP_BLANKS_PE;
6564
42.4k
    while ((RAW != ')') && (PARSER_STOPPED(ctxt) == 0)) {
6565
        /*
6566
   * Each loop we parse one separator and one element.
6567
   */
6568
24.5k
        if (RAW == ',') {
6569
9.16k
      if (type == 0) type = CUR;
6570
6571
      /*
6572
       * Detect "Name | Name , Name" error
6573
       */
6574
5.91k
      else if (type != CUR) {
6575
1
    xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6576
1
        "xmlParseElementChildrenContentDecl : '%c' expected\n",
6577
1
                      type);
6578
1
    if ((last != NULL) && (last != ret))
6579
1
        xmlFreeDocElementContent(ctxt->myDoc, last);
6580
1
    if (ret != NULL)
6581
1
        xmlFreeDocElementContent(ctxt->myDoc, ret);
6582
1
    return(NULL);
6583
1
      }
6584
9.15k
      NEXT;
6585
6586
9.15k
      op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
6587
9.15k
      if (op == NULL) {
6588
5
                xmlErrMemory(ctxt);
6589
5
    if ((last != NULL) && (last != ret))
6590
2
        xmlFreeDocElementContent(ctxt->myDoc, last);
6591
5
          xmlFreeDocElementContent(ctxt->myDoc, ret);
6592
5
    return(NULL);
6593
5
      }
6594
9.15k
      if (last == NULL) {
6595
3.24k
    op->c1 = ret;
6596
3.24k
    if (ret != NULL)
6597
3.24k
        ret->parent = op;
6598
3.24k
    ret = cur = op;
6599
5.91k
      } else {
6600
5.91k
          cur->c2 = op;
6601
5.91k
    if (op != NULL)
6602
5.91k
        op->parent = cur;
6603
5.91k
    op->c1 = last;
6604
5.91k
    if (last != NULL)
6605
5.91k
        last->parent = op;
6606
5.91k
    cur =op;
6607
5.91k
    last = NULL;
6608
5.91k
      }
6609
15.3k
  } else if (RAW == '|') {
6610
13.4k
      if (type == 0) type = CUR;
6611
6612
      /*
6613
       * Detect "Name , Name | Name" error
6614
       */
6615
4.63k
      else if (type != CUR) {
6616
18
    xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6617
18
        "xmlParseElementChildrenContentDecl : '%c' expected\n",
6618
18
          type);
6619
18
    if ((last != NULL) && (last != ret))
6620
18
        xmlFreeDocElementContent(ctxt->myDoc, last);
6621
18
    if (ret != NULL)
6622
18
        xmlFreeDocElementContent(ctxt->myDoc, ret);
6623
18
    return(NULL);
6624
18
      }
6625
13.4k
      NEXT;
6626
6627
13.4k
      op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6628
13.4k
      if (op == NULL) {
6629
3
                xmlErrMemory(ctxt);
6630
3
    if ((last != NULL) && (last != ret))
6631
1
        xmlFreeDocElementContent(ctxt->myDoc, last);
6632
3
    if (ret != NULL)
6633
3
        xmlFreeDocElementContent(ctxt->myDoc, ret);
6634
3
    return(NULL);
6635
3
      }
6636
13.4k
      if (last == NULL) {
6637
8.79k
    op->c1 = ret;
6638
8.79k
    if (ret != NULL)
6639
8.79k
        ret->parent = op;
6640
8.79k
    ret = cur = op;
6641
8.79k
      } else {
6642
4.61k
          cur->c2 = op;
6643
4.61k
    if (op != NULL)
6644
4.61k
        op->parent = cur;
6645
4.61k
    op->c1 = last;
6646
4.61k
    if (last != NULL)
6647
4.61k
        last->parent = op;
6648
4.61k
    cur =op;
6649
4.61k
    last = NULL;
6650
4.61k
      }
6651
13.4k
  } else {
6652
1.92k
      xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
6653
1.92k
      if ((last != NULL) && (last != ret))
6654
761
          xmlFreeDocElementContent(ctxt->myDoc, last);
6655
1.92k
      if (ret != NULL)
6656
1.92k
    xmlFreeDocElementContent(ctxt->myDoc, ret);
6657
1.92k
      return(NULL);
6658
1.92k
  }
6659
22.5k
  GROW;
6660
22.5k
  SKIP_BLANKS_PE;
6661
22.5k
  GROW;
6662
22.5k
  if (RAW == '(') {
6663
10.2k
      int inputid = ctxt->input->id;
6664
      /* Recurse on second child */
6665
10.2k
      NEXT;
6666
10.2k
      SKIP_BLANKS_PE;
6667
10.2k
      last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6668
10.2k
                                                          depth + 1);
6669
10.2k
            if (last == NULL) {
6670
3.94k
    if (ret != NULL)
6671
3.94k
        xmlFreeDocElementContent(ctxt->myDoc, ret);
6672
3.94k
    return(NULL);
6673
3.94k
            }
6674
6.35k
      SKIP_BLANKS_PE;
6675
12.2k
  } else {
6676
12.2k
      elem = xmlParseName(ctxt);
6677
12.2k
      if (elem == NULL) {
6678
341
    xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6679
341
    if (ret != NULL)
6680
341
        xmlFreeDocElementContent(ctxt->myDoc, ret);
6681
341
    return(NULL);
6682
341
      }
6683
11.9k
      last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6684
11.9k
      if (last == NULL) {
6685
2
                xmlErrMemory(ctxt);
6686
2
    if (ret != NULL)
6687
2
        xmlFreeDocElementContent(ctxt->myDoc, ret);
6688
2
    return(NULL);
6689
2
      }
6690
11.9k
      if (RAW == '?') {
6691
3.47k
    last->ocur = XML_ELEMENT_CONTENT_OPT;
6692
3.47k
    NEXT;
6693
8.45k
      } else if (RAW == '*') {
6694
276
    last->ocur = XML_ELEMENT_CONTENT_MULT;
6695
276
    NEXT;
6696
8.17k
      } else if (RAW == '+') {
6697
1.97k
    last->ocur = XML_ELEMENT_CONTENT_PLUS;
6698
1.97k
    NEXT;
6699
6.19k
      } else {
6700
6.19k
    last->ocur = XML_ELEMENT_CONTENT_ONCE;
6701
6.19k
      }
6702
11.9k
  }
6703
18.2k
  SKIP_BLANKS_PE;
6704
18.2k
  GROW;
6705
18.2k
    }
6706
17.9k
    if ((cur != NULL) && (last != NULL)) {
6707
6.96k
        cur->c2 = last;
6708
6.96k
  if (last != NULL)
6709
6.96k
      last->parent = cur;
6710
6.96k
    }
6711
17.9k
    if (ctxt->input->id != inputchk) {
6712
619
  xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6713
619
                       "Element content declaration doesn't start and stop in"
6714
619
                       " the same entity\n");
6715
619
    }
6716
17.9k
    NEXT;
6717
17.9k
    if (RAW == '?') {
6718
1.85k
  if (ret != NULL) {
6719
1.85k
      if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) ||
6720
1.48k
          (ret->ocur == XML_ELEMENT_CONTENT_MULT))
6721
698
          ret->ocur = XML_ELEMENT_CONTENT_MULT;
6722
1.15k
      else
6723
1.15k
          ret->ocur = XML_ELEMENT_CONTENT_OPT;
6724
1.85k
  }
6725
1.85k
  NEXT;
6726
16.1k
    } else if (RAW == '*') {
6727
1.46k
  if (ret != NULL) {
6728
1.46k
      ret->ocur = XML_ELEMENT_CONTENT_MULT;
6729
1.46k
      cur = ret;
6730
      /*
6731
       * Some normalization:
6732
       * (a | b* | c?)* == (a | b | c)*
6733
       */
6734
4.12k
      while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
6735
2.66k
    if ((cur->c1 != NULL) &&
6736
2.66k
              ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
6737
2.24k
         (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT)))
6738
717
        cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
6739
2.66k
    if ((cur->c2 != NULL) &&
6740
2.66k
              ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
6741
2.25k
         (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT)))
6742
560
        cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
6743
2.66k
    cur = cur->c2;
6744
2.66k
      }
6745
1.46k
  }
6746
1.46k
  NEXT;
6747
14.6k
    } else if (RAW == '+') {
6748
2.90k
  if (ret != NULL) {
6749
2.90k
      int found = 0;
6750
6751
2.90k
      if ((ret->ocur == XML_ELEMENT_CONTENT_OPT) ||
6752
2.83k
          (ret->ocur == XML_ELEMENT_CONTENT_MULT))
6753
747
          ret->ocur = XML_ELEMENT_CONTENT_MULT;
6754
2.15k
      else
6755
2.15k
          ret->ocur = XML_ELEMENT_CONTENT_PLUS;
6756
      /*
6757
       * Some normalization:
6758
       * (a | b*)+ == (a | b)*
6759
       * (a | b?)+ == (a | b)*
6760
       */
6761
5.47k
      while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
6762
2.57k
    if ((cur->c1 != NULL) &&
6763
2.57k
              ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
6764
2.42k
         (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
6765
198
        cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
6766
198
        found = 1;
6767
198
    }
6768
2.57k
    if ((cur->c2 != NULL) &&
6769
2.57k
              ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
6770
2.05k
         (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) {
6771
2.05k
        cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
6772
2.05k
        found = 1;
6773
2.05k
    }
6774
2.57k
    cur = cur->c2;
6775
2.57k
      }
6776
2.90k
      if (found)
6777
2.06k
    ret->ocur = XML_ELEMENT_CONTENT_MULT;
6778
2.90k
  }
6779
2.90k
  NEXT;
6780
2.90k
    }
6781
17.9k
    return(ret);
6782
24.2k
}
6783
6784
/**
6785
 * xmlParseElementChildrenContentDecl:
6786
 * @ctxt:  an XML parser context
6787
 * @inputchk:  the input used for the current entity, needed for boundary checks
6788
 *
6789
 * DEPRECATED: Internal function, don't use.
6790
 *
6791
 * parse the declaration for a Mixed Element content
6792
 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6793
 *
6794
 * [47] children ::= (choice | seq) ('?' | '*' | '+')?
6795
 *
6796
 * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
6797
 *
6798
 * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
6799
 *
6800
 * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
6801
 *
6802
 * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
6803
 * TODO Parameter-entity replacement text must be properly nested
6804
 *  with parenthesized groups. That is to say, if either of the
6805
 *  opening or closing parentheses in a choice, seq, or Mixed
6806
 *  construct is contained in the replacement text for a parameter
6807
 *  entity, both must be contained in the same replacement text. For
6808
 *  interoperability, if a parameter-entity reference appears in a
6809
 *  choice, seq, or Mixed construct, its replacement text should not
6810
 *  be empty, and neither the first nor last non-blank character of
6811
 *  the replacement text should be a connector (| or ,).
6812
 *
6813
 * Returns the tree of xmlElementContentPtr describing the element
6814
 *          hierarchy.
6815
 */
6816
xmlElementContentPtr
6817
0
xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6818
    /* stub left for API/ABI compat */
6819
0
    return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1));
6820
0
}
6821
6822
/**
6823
 * xmlParseElementContentDecl:
6824
 * @ctxt:  an XML parser context
6825
 * @name:  the name of the element being defined.
6826
 * @result:  the Element Content pointer will be stored here if any
6827
 *
6828
 * DEPRECATED: Internal function, don't use.
6829
 *
6830
 * parse the declaration for an Element content either Mixed or Children,
6831
 * the cases EMPTY and ANY are handled directly in xmlParseElementDecl
6832
 *
6833
 * [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children
6834
 *
6835
 * returns: the type of element content XML_ELEMENT_TYPE_xxx
6836
 */
6837
6838
int
6839
xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
6840
18.0k
                           xmlElementContentPtr *result) {
6841
6842
18.0k
    xmlElementContentPtr tree = NULL;
6843
18.0k
    int inputid = ctxt->input->id;
6844
18.0k
    int res;
6845
6846
18.0k
    *result = NULL;
6847
6848
18.0k
    if (RAW != '(') {
6849
0
  xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6850
0
    "xmlParseElementContentDecl : %s '(' expected\n", name);
6851
0
  return(-1);
6852
0
    }
6853
18.0k
    NEXT;
6854
18.0k
    GROW;
6855
18.0k
    SKIP_BLANKS_PE;
6856
18.0k
    if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
6857
7.24k
        tree = xmlParseElementMixedContentDecl(ctxt, inputid);
6858
7.24k
  res = XML_ELEMENT_TYPE_MIXED;
6859
10.7k
    } else {
6860
10.7k
        tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1);
6861
10.7k
  res = XML_ELEMENT_TYPE_ELEMENT;
6862
10.7k
    }
6863
18.0k
    SKIP_BLANKS_PE;
6864
18.0k
    *result = tree;
6865
18.0k
    return(res);
6866
18.0k
}
6867
6868
/**
6869
 * xmlParseElementDecl:
6870
 * @ctxt:  an XML parser context
6871
 *
6872
 * DEPRECATED: Internal function, don't use.
6873
 *
6874
 * Parse an element declaration. Always consumes '<!'.
6875
 *
6876
 * [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'
6877
 *
6878
 * [ VC: Unique Element Type Declaration ]
6879
 * No element type may be declared more than once
6880
 *
6881
 * Returns the type of the element, or -1 in case of error
6882
 */
6883
int
6884
24.2k
xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
6885
24.2k
    const xmlChar *name;
6886
24.2k
    int ret = -1;
6887
24.2k
    xmlElementContentPtr content  = NULL;
6888
6889
24.2k
    if ((CUR != '<') || (NXT(1) != '!'))
6890
0
        return(ret);
6891
24.2k
    SKIP(2);
6892
6893
    /* GROW; done in the caller */
6894
24.2k
    if (CMP7(CUR_PTR, 'E', 'L', 'E', 'M', 'E', 'N', 'T')) {
6895
23.7k
  int inputid = ctxt->input->id;
6896
6897
23.7k
  SKIP(7);
6898
23.7k
  if (SKIP_BLANKS_PE == 0) {
6899
314
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6900
314
               "Space required after 'ELEMENT'\n");
6901
314
      return(-1);
6902
314
  }
6903
23.3k
        name = xmlParseName(ctxt);
6904
23.3k
  if (name == NULL) {
6905
4
      xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6906
4
         "xmlParseElementDecl: no name for Element\n");
6907
4
      return(-1);
6908
4
  }
6909
23.3k
  if (SKIP_BLANKS_PE == 0) {
6910
3.98k
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6911
3.98k
         "Space required after the element name\n");
6912
3.98k
  }
6913
23.3k
  if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) {
6914
3.95k
      SKIP(5);
6915
      /*
6916
       * Element must always be empty.
6917
       */
6918
3.95k
      ret = XML_ELEMENT_TYPE_EMPTY;
6919
19.4k
  } else if ((RAW == 'A') && (NXT(1) == 'N') &&
6920
326
             (NXT(2) == 'Y')) {
6921
283
      SKIP(3);
6922
      /*
6923
       * Element is a generic container.
6924
       */
6925
283
      ret = XML_ELEMENT_TYPE_ANY;
6926
19.1k
  } else if (RAW == '(') {
6927
18.0k
      ret = xmlParseElementContentDecl(ctxt, name, &content);
6928
18.0k
  } else {
6929
      /*
6930
       * [ WFC: PEs in Internal Subset ] error handling.
6931
       */
6932
1.13k
            xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6933
1.13k
                  "xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n");
6934
1.13k
      return(-1);
6935
1.13k
  }
6936
6937
22.2k
  SKIP_BLANKS_PE;
6938
6939
22.2k
  if (RAW != '>') {
6940
6.51k
      xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
6941
6.51k
      if (content != NULL) {
6942
2.38k
    xmlFreeDocElementContent(ctxt->myDoc, content);
6943
2.38k
      }
6944
15.7k
  } else {
6945
15.7k
      if (inputid != ctxt->input->id) {
6946
188
    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6947
188
                               "Element declaration doesn't start and stop in"
6948
188
                               " the same entity\n");
6949
188
      }
6950
6951
15.7k
      NEXT;
6952
15.7k
      if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6953
13.1k
    (ctxt->sax->elementDecl != NULL)) {
6954
13.1k
    if (content != NULL)
6955
9.98k
        content->parent = NULL;
6956
13.1k
          ctxt->sax->elementDecl(ctxt->userData, name, ret,
6957
13.1k
                           content);
6958
13.1k
    if ((content != NULL) && (content->parent == NULL)) {
6959
        /*
6960
         * this is a trick: if xmlAddElementDecl is called,
6961
         * instead of copying the full tree it is plugged directly
6962
         * if called from the parser. Avoid duplicating the
6963
         * interfaces or change the API/ABI
6964
         */
6965
1.27k
        xmlFreeDocElementContent(ctxt->myDoc, content);
6966
1.27k
    }
6967
13.1k
      } else if (content != NULL) {
6968
802
    xmlFreeDocElementContent(ctxt->myDoc, content);
6969
802
      }
6970
15.7k
  }
6971
22.2k
    }
6972
22.8k
    return(ret);
6973
24.2k
}
6974
6975
/**
6976
 * xmlParseConditionalSections
6977
 * @ctxt:  an XML parser context
6978
 *
6979
 * Parse a conditional section. Always consumes '<!['.
6980
 *
6981
 * [61] conditionalSect ::= includeSect | ignoreSect
6982
 * [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'
6983
 * [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
6984
 * [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*
6985
 * [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)
6986
 */
6987
6988
static void
6989
3.12k
xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
6990
3.12k
    int *inputIds = NULL;
6991
3.12k
    size_t inputIdsSize = 0;
6992
3.12k
    size_t depth = 0;
6993
6994
245k
    while (PARSER_STOPPED(ctxt) == 0) {
6995
245k
        if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
6996
122k
            int id = ctxt->input->id;
6997
6998
122k
            SKIP(3);
6999
122k
            SKIP_BLANKS_PE;
7000
7001
122k
            if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) {
7002
121k
                SKIP(7);
7003
121k
                SKIP_BLANKS_PE;
7004
121k
                if (RAW != '[') {
7005
171
                    xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
7006
171
                    xmlHaltParser(ctxt);
7007
171
                    goto error;
7008
171
                }
7009
121k
                if (ctxt->input->id != id) {
7010
191
                    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
7011
191
                                   "All markup of the conditional section is"
7012
191
                                   " not in the same entity\n");
7013
191
                }
7014
121k
                NEXT;
7015
7016
121k
                if (inputIdsSize <= depth) {
7017
6.01k
                    int *tmp;
7018
6.01k
                    int newSize;
7019
7020
6.01k
                    newSize = xmlGrowCapacity(inputIdsSize, sizeof(tmp[0]),
7021
6.01k
                                              4, 1000);
7022
6.01k
                    if (newSize < 0) {
7023
82
                        xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT,
7024
82
                                       "Maximum conditional section nesting"
7025
82
                                       " depth exceeded\n");
7026
82
                        goto error;
7027
82
                    }
7028
5.92k
                    tmp = xmlRealloc(inputIds, newSize * sizeof(tmp[0]));
7029
5.92k
                    if (tmp == NULL) {
7030
0
                        xmlErrMemory(ctxt);
7031
0
                        goto error;
7032
0
                    }
7033
5.92k
                    inputIds = tmp;
7034
5.92k
                    inputIdsSize = newSize;
7035
5.92k
                }
7036
121k
                inputIds[depth] = id;
7037
121k
                depth++;
7038
121k
            } else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) {
7039
598
                size_t ignoreDepth = 0;
7040
7041
598
                SKIP(6);
7042
598
                SKIP_BLANKS_PE;
7043
598
                if (RAW != '[') {
7044
140
                    xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
7045
140
                    xmlHaltParser(ctxt);
7046
140
                    goto error;
7047
140
                }
7048
458
                if (ctxt->input->id != id) {
7049
107
                    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
7050
107
                                   "All markup of the conditional section is"
7051
107
                                   " not in the same entity\n");
7052
107
                }
7053
458
                NEXT;
7054
7055
568k
                while (PARSER_STOPPED(ctxt) == 0) {
7056
568k
                    if (RAW == 0) {
7057
93
                        xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
7058
93
                        goto error;
7059
93
                    }
7060
568k
                    if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
7061
203
                        SKIP(3);
7062
203
                        ignoreDepth++;
7063
                        /* Check for integer overflow */
7064
203
                        if (ignoreDepth == 0) {
7065
0
                            xmlErrMemory(ctxt);
7066
0
                            goto error;
7067
0
                        }
7068
568k
                    } else if ((RAW == ']') && (NXT(1) == ']') &&
7069
711
                               (NXT(2) == '>')) {
7070
476
                        SKIP(3);
7071
476
                        if (ignoreDepth == 0)
7072
364
                            break;
7073
112
                        ignoreDepth--;
7074
567k
                    } else {
7075
567k
                        NEXT;
7076
567k
                    }
7077
568k
                }
7078
7079
365
                if (ctxt->input->id != id) {
7080
107
                    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
7081
107
                                   "All markup of the conditional section is"
7082
107
                                   " not in the same entity\n");
7083
107
                }
7084
950
            } else {
7085
950
                xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
7086
950
                xmlHaltParser(ctxt);
7087
950
                goto error;
7088
950
            }
7089
122k
        } else if ((depth > 0) &&
7090
122k
                   (RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
7091
219
            depth--;
7092
219
            if (ctxt->input->id != inputIds[depth]) {
7093
10
                xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
7094
10
                               "All markup of the conditional section is not"
7095
10
                               " in the same entity\n");
7096
10
            }
7097
219
            SKIP(3);
7098
121k
        } else if ((RAW == '<') && ((NXT(1) == '!') || (NXT(1) == '?'))) {
7099
120k
            xmlParseMarkupDecl(ctxt);
7100
120k
        } else {
7101
1.15k
            xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
7102
1.15k
            xmlHaltParser(ctxt);
7103
1.15k
            goto error;
7104
1.15k
        }
7105
7106
242k
        if (depth == 0)
7107
375
            break;
7108
7109
242k
        SKIP_BLANKS_PE;
7110
242k
        SHRINK;
7111
242k
        GROW;
7112
242k
    }
7113
7114
3.12k
error:
7115
3.12k
    xmlFree(inputIds);
7116
3.12k
}
7117
7118
/**
7119
 * xmlParseMarkupDecl:
7120
 * @ctxt:  an XML parser context
7121
 *
7122
 * DEPRECATED: Internal function, don't use.
7123
 *
7124
 * Parse markup declarations. Always consumes '<!' or '<?'.
7125
 *
7126
 * [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl |
7127
 *                     NotationDecl | PI | Comment
7128
 *
7129
 * [ VC: Proper Declaration/PE Nesting ]
7130
 * Parameter-entity replacement text must be properly nested with
7131
 * markup declarations. That is to say, if either the first character
7132
 * or the last character of a markup declaration (markupdecl above) is
7133
 * contained in the replacement text for a parameter-entity reference,
7134
 * both must be contained in the same replacement text.
7135
 *
7136
 * [ WFC: PEs in Internal Subset ]
7137
 * In the internal DTD subset, parameter-entity references can occur
7138
 * only where markup declarations can occur, not within markup declarations.
7139
 * (This does not apply to references that occur in external parameter
7140
 * entities or to the external subset.)
7141
 */
7142
void
7143
271k
xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
7144
271k
    GROW;
7145
271k
    if (CUR == '<') {
7146
271k
        if (NXT(1) == '!') {
7147
265k
      switch (NXT(2)) {
7148
86.2k
          case 'E':
7149
86.2k
        if (NXT(3) == 'L')
7150
24.2k
      xmlParseElementDecl(ctxt);
7151
61.9k
        else if (NXT(3) == 'N')
7152
61.8k
      xmlParseEntityDecl(ctxt);
7153
139
                    else
7154
139
                        SKIP(2);
7155
86.2k
        break;
7156
32.4k
          case 'A':
7157
32.4k
        xmlParseAttributeListDecl(ctxt);
7158
32.4k
        break;
7159
8.85k
          case 'N':
7160
8.85k
        xmlParseNotationDecl(ctxt);
7161
8.85k
        break;
7162
130k
          case '-':
7163
130k
        xmlParseComment(ctxt);
7164
130k
        break;
7165
7.32k
    default:
7166
7.32k
                    xmlFatalErr(ctxt,
7167
7.32k
                                ctxt->inSubset == 2 ?
7168
381
                                    XML_ERR_EXT_SUBSET_NOT_FINISHED :
7169
7.32k
                                    XML_ERR_INT_SUBSET_NOT_FINISHED,
7170
7.32k
                                NULL);
7171
7.32k
                    SKIP(2);
7172
7.32k
        break;
7173
265k
      }
7174
265k
  } else if (NXT(1) == '?') {
7175
6.33k
      xmlParsePI(ctxt);
7176
6.33k
  }
7177
271k
    }
7178
271k
}
7179
7180
/**
7181
 * xmlParseTextDecl:
7182
 * @ctxt:  an XML parser context
7183
 *
7184
 * DEPRECATED: Internal function, don't use.
7185
 *
7186
 * parse an XML declaration header for external entities
7187
 *
7188
 * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
7189
 */
7190
7191
void
7192
7.17k
xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
7193
7.17k
    xmlChar *version;
7194
7195
    /*
7196
     * We know that '<?xml' is here.
7197
     */
7198
7.17k
    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
7199
6.87k
  SKIP(5);
7200
6.87k
    } else {
7201
302
  xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
7202
302
  return;
7203
302
    }
7204
7205
6.87k
    if (SKIP_BLANKS == 0) {
7206
0
  xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
7207
0
           "Space needed after '<?xml'\n");
7208
0
    }
7209
7210
    /*
7211
     * We may have the VersionInfo here.
7212
     */
7213
6.87k
    version = xmlParseVersionInfo(ctxt);
7214
6.87k
    if (version == NULL) {
7215
4.72k
  version = xmlCharStrdup(XML_DEFAULT_VERSION);
7216
4.72k
        if (version == NULL) {
7217
3
            xmlErrMemory(ctxt);
7218
3
            return;
7219
3
        }
7220
4.72k
    } else {
7221
2.14k
  if (SKIP_BLANKS == 0) {
7222
873
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
7223
873
               "Space needed here\n");
7224
873
  }
7225
2.14k
    }
7226
6.86k
    ctxt->input->version = version;
7227
7228
    /*
7229
     * We must have the encoding declaration
7230
     */
7231
6.86k
    xmlParseEncodingDecl(ctxt);
7232
7233
6.86k
    SKIP_BLANKS;
7234
6.86k
    if ((RAW == '?') && (NXT(1) == '>')) {
7235
762
        SKIP(2);
7236
6.10k
    } else if (RAW == '>') {
7237
        /* Deprecated old WD ... */
7238
70
  xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
7239
70
  NEXT;
7240
6.03k
    } else {
7241
6.03k
        int c;
7242
7243
6.03k
  xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
7244
3.57M
        while ((PARSER_STOPPED(ctxt) == 0) && ((c = CUR) != 0)) {
7245
3.57M
            NEXT;
7246
3.57M
            if (c == '>')
7247
4.11k
                break;
7248
3.57M
        }
7249
6.03k
    }
7250
6.86k
}
7251
7252
/**
7253
 * xmlParseExternalSubset:
7254
 * @ctxt:  an XML parser context
7255
 * @ExternalID: the external identifier
7256
 * @SystemID: the system identifier (or URL)
7257
 *
7258
 * DEPRECATED: Internal function, don't use.
7259
 *
7260
 * parse Markup declarations from an external subset
7261
 *
7262
 * [30] extSubset ::= textDecl? extSubsetDecl
7263
 *
7264
 * [31] extSubsetDecl ::= (markupdecl | conditionalSect | PEReference | S) *
7265
 */
7266
void
7267
xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
7268
5.81k
                       const xmlChar *SystemID) {
7269
5.81k
    int oldInputNr;
7270
7271
5.81k
    xmlCtxtInitializeLate(ctxt);
7272
7273
5.81k
    xmlDetectEncoding(ctxt);
7274
7275
5.81k
    if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) {
7276
2.61k
  xmlParseTextDecl(ctxt);
7277
2.61k
    }
7278
5.81k
    if (ctxt->myDoc == NULL) {
7279
0
        ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
7280
0
  if (ctxt->myDoc == NULL) {
7281
0
      xmlErrMemory(ctxt);
7282
0
      return;
7283
0
  }
7284
0
  ctxt->myDoc->properties = XML_DOC_INTERNAL;
7285
0
    }
7286
5.81k
    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL) &&
7287
0
        (xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID) == NULL)) {
7288
0
        xmlErrMemory(ctxt);
7289
0
    }
7290
7291
5.81k
    ctxt->inSubset = 2;
7292
5.81k
    oldInputNr = ctxt->inputNr;
7293
7294
5.81k
    SKIP_BLANKS_PE;
7295
18.4k
    while (((RAW != 0) || (ctxt->inputNr > oldInputNr)) &&
7296
16.5k
           (!PARSER_STOPPED(ctxt))) {
7297
14.8k
  GROW;
7298
14.8k
        if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
7299
2.03k
            xmlParseConditionalSections(ctxt);
7300
12.7k
        } else if ((RAW == '<') && ((NXT(1) == '!') || (NXT(1) == '?'))) {
7301
10.5k
            xmlParseMarkupDecl(ctxt);
7302
10.5k
        } else {
7303
2.21k
            xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
7304
2.21k
            xmlHaltParser(ctxt);
7305
2.21k
            return;
7306
2.21k
        }
7307
12.5k
        SKIP_BLANKS_PE;
7308
12.5k
        SHRINK;
7309
12.5k
    }
7310
7311
4.02k
    while (ctxt->inputNr > oldInputNr)
7312
420
        xmlPopPE(ctxt);
7313
7314
3.60k
    xmlParserCheckEOF(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED);
7315
3.60k
}
7316
7317
/**
7318
 * xmlParseReference:
7319
 * @ctxt:  an XML parser context
7320
 *
7321
 * DEPRECATED: Internal function, don't use.
7322
 *
7323
 * parse and handle entity references in content, depending on the SAX
7324
 * interface, this may end-up in a call to character() if this is a
7325
 * CharRef, a predefined entity, if there is no reference() callback.
7326
 * or if the parser was asked to switch to that mode.
7327
 *
7328
 * Always consumes '&'.
7329
 *
7330
 * [67] Reference ::= EntityRef | CharRef
7331
 */
7332
void
7333
131k
xmlParseReference(xmlParserCtxtPtr ctxt) {
7334
131k
    xmlEntityPtr ent = NULL;
7335
131k
    const xmlChar *name;
7336
131k
    xmlChar *val;
7337
7338
131k
    if (RAW != '&')
7339
0
        return;
7340
7341
    /*
7342
     * Simple case of a CharRef
7343
     */
7344
131k
    if (NXT(1) == '#') {
7345
21.2k
  int i = 0;
7346
21.2k
  xmlChar out[16];
7347
21.2k
  int value = xmlParseCharRef(ctxt);
7348
7349
21.2k
  if (value == 0)
7350
8.06k
      return;
7351
7352
        /*
7353
         * Just encode the value in UTF-8
7354
         */
7355
13.2k
        COPY_BUF(out, i, value);
7356
13.2k
        out[i] = 0;
7357
13.2k
        if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7358
13.2k
            (!ctxt->disableSAX))
7359
11.6k
            ctxt->sax->characters(ctxt->userData, out, i);
7360
13.2k
  return;
7361
21.2k
    }
7362
7363
    /*
7364
     * We are seeing an entity reference
7365
     */
7366
109k
    name = xmlParseEntityRefInternal(ctxt);
7367
109k
    if (name == NULL)
7368
59.7k
        return;
7369
50.2k
    ent = xmlLookupGeneralEntity(ctxt, name, /* isAttr */ 0);
7370
50.2k
    if (ent == NULL) {
7371
        /*
7372
         * Create a reference for undeclared entities.
7373
         */
7374
33.6k
        if ((ctxt->replaceEntities == 0) &&
7375
4.09k
            (ctxt->sax != NULL) &&
7376
4.09k
            (ctxt->disableSAX == 0) &&
7377
4.09k
            (ctxt->sax->reference != NULL)) {
7378
4.09k
            ctxt->sax->reference(ctxt->userData, name);
7379
4.09k
        }
7380
33.6k
        return;
7381
33.6k
    }
7382
16.6k
    if (!ctxt->wellFormed)
7383
7.56k
  return;
7384
7385
    /* special case of predefined entities */
7386
9.07k
    if ((ent->name == NULL) ||
7387
9.07k
        (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
7388
5.47k
  val = ent->content;
7389
5.47k
  if (val == NULL) return;
7390
  /*
7391
   * inline the entity.
7392
   */
7393
5.47k
  if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7394
5.47k
      (!ctxt->disableSAX))
7395
5.47k
      ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
7396
5.47k
  return;
7397
5.47k
    }
7398
7399
    /*
7400
     * Some users try to parse entities on their own and used to set
7401
     * the renamed "checked" member. Fix the flags to cover this
7402
     * case.
7403
     */
7404
3.60k
    if (((ent->flags & XML_ENT_PARSED) == 0) && (ent->children != NULL))
7405
0
        ent->flags |= XML_ENT_PARSED;
7406
7407
    /*
7408
     * The first reference to the entity trigger a parsing phase
7409
     * where the ent->children is filled with the result from
7410
     * the parsing.
7411
     * Note: external parsed entities will not be loaded, it is not
7412
     * required for a non-validating parser, unless the parsing option
7413
     * of validating, or substituting entities were given. Doing so is
7414
     * far more secure as the parser will only process data coming from
7415
     * the document entity by default.
7416
     *
7417
     * FIXME: This doesn't work correctly since entities can be
7418
     * expanded with different namespace declarations in scope.
7419
     * For example:
7420
     *
7421
     * <!DOCTYPE doc [
7422
     *   <!ENTITY ent "<ns:elem/>">
7423
     * ]>
7424
     * <doc>
7425
     *   <decl1 xmlns:ns="urn:ns1">
7426
     *     &ent;
7427
     *   </decl1>
7428
     *   <decl2 xmlns:ns="urn:ns2">
7429
     *     &ent;
7430
     *   </decl2>
7431
     * </doc>
7432
     *
7433
     * Proposed fix:
7434
     *
7435
     * - Ignore current namespace declarations when parsing the
7436
     *   entity. If a prefix can't be resolved, don't report an error
7437
     *   but mark it as unresolved.
7438
     * - Try to resolve these prefixes when expanding the entity.
7439
     *   This will require a specialized version of xmlStaticCopyNode
7440
     *   which can also make use of the namespace hash table to avoid
7441
     *   quadratic behavior.
7442
     *
7443
     * Alternatively, we could simply reparse the entity on each
7444
     * expansion like we already do with custom SAX callbacks.
7445
     * External entity content should be cached in this case.
7446
     */
7447
3.60k
    if ((ent->etype == XML_INTERNAL_GENERAL_ENTITY) ||
7448
2.56k
        (((ctxt->options & XML_PARSE_NO_XXE) == 0) &&
7449
2.56k
         ((ctxt->replaceEntities) ||
7450
3.60k
          (ctxt->validate)))) {
7451
3.60k
        if ((ent->flags & XML_ENT_PARSED) == 0) {
7452
3.12k
            xmlCtxtParseEntity(ctxt, ent);
7453
3.12k
        } else if (ent->children == NULL) {
7454
            /*
7455
             * Probably running in SAX mode and the callbacks don't
7456
             * build the entity content. Parse the entity again.
7457
             *
7458
             * This will also be triggered in normal tree builder mode
7459
             * if an entity happens to be empty, causing unnecessary
7460
             * reloads. It's hard to come up with a reliable check in
7461
             * which mode we're running.
7462
             */
7463
205
            xmlCtxtParseEntity(ctxt, ent);
7464
205
        }
7465
3.60k
    }
7466
7467
    /*
7468
     * We also check for amplification if entities aren't substituted.
7469
     * They might be expanded later.
7470
     */
7471
3.60k
    if (xmlParserEntityCheck(ctxt, ent->expandedSize))
7472
22
        return;
7473
7474
3.57k
    if ((ctxt->sax == NULL) || (ctxt->disableSAX))
7475
2.67k
        return;
7476
7477
903
    if (ctxt->replaceEntities == 0) {
7478
  /*
7479
   * Create a reference
7480
   */
7481
24
        if (ctxt->sax->reference != NULL)
7482
24
      ctxt->sax->reference(ctxt->userData, ent->name);
7483
879
    } else if ((ent->children != NULL) && (ctxt->node != NULL)) {
7484
539
        xmlNodePtr copy, cur;
7485
7486
        /*
7487
         * Seems we are generating the DOM content, copy the tree
7488
   */
7489
539
        cur = ent->children;
7490
7491
        /*
7492
         * Handle first text node with SAX to coalesce text efficiently
7493
         */
7494
539
        if ((cur->type == XML_TEXT_NODE) ||
7495
276
            (cur->type == XML_CDATA_SECTION_NODE)) {
7496
263
            int len = xmlStrlen(cur->content);
7497
7498
263
            if ((cur->type == XML_TEXT_NODE) ||
7499
263
                (ctxt->options & XML_PARSE_NOCDATA)) {
7500
263
                if (ctxt->sax->characters != NULL)
7501
263
                    ctxt->sax->characters(ctxt, cur->content, len);
7502
263
            } else {
7503
0
                if (ctxt->sax->cdataBlock != NULL)
7504
0
                    ctxt->sax->cdataBlock(ctxt, cur->content, len);
7505
0
            }
7506
7507
263
            cur = cur->next;
7508
263
        }
7509
7510
1.35k
        while (cur != NULL) {
7511
1.09k
            xmlNodePtr last;
7512
7513
            /*
7514
             * Handle last text node with SAX to coalesce text efficiently
7515
             */
7516
1.09k
            if ((cur->next == NULL) &&
7517
317
                ((cur->type == XML_TEXT_NODE) ||
7518
276
                 (cur->type == XML_CDATA_SECTION_NODE))) {
7519
276
                int len = xmlStrlen(cur->content);
7520
7521
276
                if ((cur->type == XML_TEXT_NODE) ||
7522
276
                    (ctxt->options & XML_PARSE_NOCDATA)) {
7523
276
                    if (ctxt->sax->characters != NULL)
7524
276
                        ctxt->sax->characters(ctxt, cur->content, len);
7525
276
                } else {
7526
0
                    if (ctxt->sax->cdataBlock != NULL)
7527
0
                        ctxt->sax->cdataBlock(ctxt, cur->content, len);
7528
0
                }
7529
7530
276
                break;
7531
276
            }
7532
7533
            /*
7534
             * Reset coalesce buffer stats only for non-text nodes.
7535
             */
7536
816
            ctxt->nodemem = 0;
7537
816
            ctxt->nodelen = 0;
7538
7539
816
            copy = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7540
7541
816
            if (copy == NULL) {
7542
1
                xmlErrMemory(ctxt);
7543
1
                break;
7544
1
            }
7545
7546
815
            if (ctxt->parseMode == XML_PARSE_READER) {
7547
                /* Needed for reader */
7548
0
                copy->extra = cur->extra;
7549
                /* Maybe needed for reader */
7550
0
                copy->_private = cur->_private;
7551
0
            }
7552
7553
815
            copy->parent = ctxt->node;
7554
815
            last = ctxt->node->last;
7555
815
            if (last == NULL) {
7556
192
                ctxt->node->children = copy;
7557
623
            } else {
7558
623
                last->next = copy;
7559
623
                copy->prev = last;
7560
623
            }
7561
815
            ctxt->node->last = copy;
7562
7563
815
            cur = cur->next;
7564
815
        }
7565
539
    }
7566
903
}
7567
7568
static void
7569
109k
xmlHandleUndeclaredEntity(xmlParserCtxtPtr ctxt, const xmlChar *name) {
7570
    /*
7571
     * [ WFC: Entity Declared ]
7572
     * In a document without any DTD, a document with only an
7573
     * internal DTD subset which contains no parameter entity
7574
     * references, or a document with "standalone='yes'", the
7575
     * Name given in the entity reference must match that in an
7576
     * entity declaration, except that well-formed documents
7577
     * need not declare any of the following entities: amp, lt,
7578
     * gt, apos, quot.
7579
     * The declaration of a parameter entity must precede any
7580
     * reference to it.
7581
     * Similarly, the declaration of a general entity must
7582
     * precede any reference to it which appears in a default
7583
     * value in an attribute-list declaration. Note that if
7584
     * entities are declared in the external subset or in
7585
     * external parameter entities, a non-validating processor
7586
     * is not obligated to read and process their declarations;
7587
     * for such documents, the rule that an entity must be
7588
     * declared is a well-formedness constraint only if
7589
     * standalone='yes'.
7590
     */
7591
109k
    if ((ctxt->standalone == 1) ||
7592
109k
        ((ctxt->hasExternalSubset == 0) &&
7593
105k
         (ctxt->hasPErefs == 0))) {
7594
99.2k
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7595
99.2k
                          "Entity '%s' not defined\n", name);
7596
99.2k
    } else if (ctxt->validate) {
7597
        /*
7598
         * [ VC: Entity Declared ]
7599
         * In a document with an external subset or external
7600
         * parameter entities with "standalone='no'", ...
7601
         * ... The declaration of a parameter entity must
7602
         * precede any reference to it...
7603
         */
7604
0
        xmlValidityError(ctxt, XML_ERR_UNDECLARED_ENTITY,
7605
0
                         "Entity '%s' not defined\n", name, NULL);
7606
9.91k
    } else if ((ctxt->loadsubset & ~XML_SKIP_IDS) ||
7607
1.85k
               ((ctxt->replaceEntities) &&
7608
8.06k
                ((ctxt->options & XML_PARSE_NO_XXE) == 0))) {
7609
        /*
7610
         * Also raise a non-fatal error
7611
         *
7612
         * - if the external subset is loaded and all entity declarations
7613
         *   should be available, or
7614
         * - entity substition was requested without restricting
7615
         *   external entity access.
7616
         */
7617
8.06k
        xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7618
8.06k
                     "Entity '%s' not defined\n", name);
7619
8.06k
    } else {
7620
1.85k
        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7621
1.85k
                      "Entity '%s' not defined\n", name, NULL);
7622
1.85k
    }
7623
7624
109k
    ctxt->valid = 0;
7625
109k
}
7626
7627
static xmlEntityPtr
7628
462k
xmlLookupGeneralEntity(xmlParserCtxtPtr ctxt, const xmlChar *name, int inAttr) {
7629
462k
    xmlEntityPtr ent = NULL;
7630
7631
    /*
7632
     * Predefined entities override any extra definition
7633
     */
7634
462k
    if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7635
462k
        ent = xmlGetPredefinedEntity(name);
7636
462k
        if (ent != NULL)
7637
51.0k
            return(ent);
7638
462k
    }
7639
7640
    /*
7641
     * Ask first SAX for entity resolution, otherwise try the
7642
     * entities which may have stored in the parser context.
7643
     */
7644
411k
    if (ctxt->sax != NULL) {
7645
411k
  if (ctxt->sax->getEntity != NULL)
7646
411k
      ent = ctxt->sax->getEntity(ctxt->userData, name);
7647
411k
  if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7648
729
      (ctxt->options & XML_PARSE_OLDSAX))
7649
0
      ent = xmlGetPredefinedEntity(name);
7650
411k
  if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7651
729
      (ctxt->userData==ctxt)) {
7652
729
      ent = xmlSAX2GetEntity(ctxt, name);
7653
729
  }
7654
411k
    }
7655
7656
411k
    if (ent == NULL) {
7657
99.4k
        xmlHandleUndeclaredEntity(ctxt, name);
7658
99.4k
    }
7659
7660
    /*
7661
     * [ WFC: Parsed Entity ]
7662
     * An entity reference must not contain the name of an
7663
     * unparsed entity
7664
     */
7665
311k
    else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
7666
0
  xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7667
0
     "Entity reference to unparsed entity %s\n", name);
7668
0
        ent = NULL;
7669
0
    }
7670
7671
    /*
7672
     * [ WFC: No External Entity References ]
7673
     * Attribute values cannot contain direct or indirect
7674
     * entity references to external entities.
7675
     */
7676
311k
    else if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
7677
4.51k
        if (inAttr) {
7678
512
            xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7679
512
                 "Attribute references external entity '%s'\n", name);
7680
512
            ent = NULL;
7681
512
        }
7682
4.51k
    }
7683
7684
411k
    return(ent);
7685
462k
}
7686
7687
/**
7688
 * xmlParseEntityRefInternal:
7689
 * @ctxt:  an XML parser context
7690
 * @inAttr:  whether we are in an attribute value
7691
 *
7692
 * Parse an entity reference. Always consumes '&'.
7693
 *
7694
 * [68] EntityRef ::= '&' Name ';'
7695
 *
7696
 * Returns the name, or NULL in case of error.
7697
 */
7698
static const xmlChar *
7699
519k
xmlParseEntityRefInternal(xmlParserCtxtPtr ctxt) {
7700
519k
    const xmlChar *name;
7701
7702
519k
    GROW;
7703
7704
519k
    if (RAW != '&')
7705
0
        return(NULL);
7706
519k
    NEXT;
7707
519k
    name = xmlParseName(ctxt);
7708
519k
    if (name == NULL) {
7709
120k
  xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7710
120k
           "xmlParseEntityRef: no name\n");
7711
120k
        return(NULL);
7712
120k
    }
7713
398k
    if (RAW != ';') {
7714
94.2k
  xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7715
94.2k
  return(NULL);
7716
94.2k
    }
7717
304k
    NEXT;
7718
7719
304k
    return(name);
7720
398k
}
7721
7722
/**
7723
 * xmlParseEntityRef:
7724
 * @ctxt:  an XML parser context
7725
 *
7726
 * DEPRECATED: Internal function, don't use.
7727
 *
7728
 * Returns the xmlEntityPtr if found, or NULL otherwise.
7729
 */
7730
xmlEntityPtr
7731
0
xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
7732
0
    const xmlChar *name;
7733
7734
0
    if (ctxt == NULL)
7735
0
        return(NULL);
7736
7737
0
    name = xmlParseEntityRefInternal(ctxt);
7738
0
    if (name == NULL)
7739
0
        return(NULL);
7740
7741
0
    return(xmlLookupGeneralEntity(ctxt, name, /* inAttr */ 0));
7742
0
}
7743
7744
/**
7745
 * xmlParseStringEntityRef:
7746
 * @ctxt:  an XML parser context
7747
 * @str:  a pointer to an index in the string
7748
 *
7749
 * parse ENTITY references declarations, but this version parses it from
7750
 * a string value.
7751
 *
7752
 * [68] EntityRef ::= '&' Name ';'
7753
 *
7754
 * [ WFC: Entity Declared ]
7755
 * In a document without any DTD, a document with only an internal DTD
7756
 * subset which contains no parameter entity references, or a document
7757
 * with "standalone='yes'", the Name given in the entity reference
7758
 * must match that in an entity declaration, except that well-formed
7759
 * documents need not declare any of the following entities: amp, lt,
7760
 * gt, apos, quot.  The declaration of a parameter entity must precede
7761
 * any reference to it.  Similarly, the declaration of a general entity
7762
 * must precede any reference to it which appears in a default value in an
7763
 * attribute-list declaration. Note that if entities are declared in the
7764
 * external subset or in external parameter entities, a non-validating
7765
 * processor is not obligated to read and process their declarations;
7766
 * for such documents, the rule that an entity must be declared is a
7767
 * well-formedness constraint only if standalone='yes'.
7768
 *
7769
 * [ WFC: Parsed Entity ]
7770
 * An entity reference must not contain the name of an unparsed entity
7771
 *
7772
 * Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer
7773
 * is updated to the current location in the string.
7774
 */
7775
static xmlChar *
7776
158k
xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
7777
158k
    xmlChar *name;
7778
158k
    const xmlChar *ptr;
7779
158k
    xmlChar cur;
7780
7781
158k
    if ((str == NULL) || (*str == NULL))
7782
0
        return(NULL);
7783
158k
    ptr = *str;
7784
158k
    cur = *ptr;
7785
158k
    if (cur != '&')
7786
0
  return(NULL);
7787
7788
158k
    ptr++;
7789
158k
    name = xmlParseStringName(ctxt, &ptr);
7790
158k
    if (name == NULL) {
7791
379
  xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7792
379
           "xmlParseStringEntityRef: no name\n");
7793
379
  *str = ptr;
7794
379
  return(NULL);
7795
379
    }
7796
157k
    if (*ptr != ';') {
7797
252
  xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7798
252
        xmlFree(name);
7799
252
  *str = ptr;
7800
252
  return(NULL);
7801
252
    }
7802
157k
    ptr++;
7803
7804
157k
    *str = ptr;
7805
157k
    return(name);
7806
157k
}
7807
7808
/**
7809
 * xmlParsePEReference:
7810
 * @ctxt:  an XML parser context
7811
 *
7812
 * DEPRECATED: Internal function, don't use.
7813
 *
7814
 * Parse a parameter entity reference. Always consumes '%'.
7815
 *
7816
 * The entity content is handled directly by pushing it's content as
7817
 * a new input stream.
7818
 *
7819
 * [69] PEReference ::= '%' Name ';'
7820
 *
7821
 * [ WFC: No Recursion ]
7822
 * A parsed entity must not contain a recursive
7823
 * reference to itself, either directly or indirectly.
7824
 *
7825
 * [ WFC: Entity Declared ]
7826
 * In a document without any DTD, a document with only an internal DTD
7827
 * subset which contains no parameter entity references, or a document
7828
 * with "standalone='yes'", ...  ... The declaration of a parameter
7829
 * entity must precede any reference to it...
7830
 *
7831
 * [ VC: Entity Declared ]
7832
 * In a document with an external subset or external parameter entities
7833
 * with "standalone='no'", ...  ... The declaration of a parameter entity
7834
 * must precede any reference to it...
7835
 *
7836
 * [ WFC: In DTD ]
7837
 * Parameter-entity references may only appear in the DTD.
7838
 * NOTE: misleading but this is handled.
7839
 */
7840
void
7841
xmlParsePEReference(xmlParserCtxtPtr ctxt)
7842
49.6k
{
7843
49.6k
    const xmlChar *name;
7844
49.6k
    xmlEntityPtr entity = NULL;
7845
49.6k
    xmlParserInputPtr input;
7846
7847
49.6k
    if (RAW != '%')
7848
0
        return;
7849
49.6k
    NEXT;
7850
49.6k
    name = xmlParseName(ctxt);
7851
49.6k
    if (name == NULL) {
7852
19.9k
  xmlFatalErrMsg(ctxt, XML_ERR_PEREF_NO_NAME, "PEReference: no name\n");
7853
19.9k
  return;
7854
19.9k
    }
7855
29.6k
    if (RAW != ';') {
7856
4.83k
  xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
7857
4.83k
        return;
7858
4.83k
    }
7859
7860
24.8k
    NEXT;
7861
7862
    /* Must be set before xmlHandleUndeclaredEntity */
7863
24.8k
    ctxt->hasPErefs = 1;
7864
7865
    /*
7866
     * Request the entity from SAX
7867
     */
7868
24.8k
    if ((ctxt->sax != NULL) &&
7869
24.8k
  (ctxt->sax->getParameterEntity != NULL))
7870
24.8k
  entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
7871
7872
24.8k
    if (entity == NULL) {
7873
8.42k
        xmlHandleUndeclaredEntity(ctxt, name);
7874
16.4k
    } else {
7875
  /*
7876
   * Internal checking in case the entity quest barfed
7877
   */
7878
16.4k
  if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
7879
10.3k
      (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
7880
0
      xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7881
0
      "Internal: %%%s; is not a parameter entity\n",
7882
0
        name, NULL);
7883
16.4k
  } else {
7884
16.4k
      if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
7885
10.3k
                ((ctxt->options & XML_PARSE_NO_XXE) ||
7886
10.3k
     ((ctxt->loadsubset == 0) &&
7887
0
      (ctxt->replaceEntities == 0) &&
7888
0
      (ctxt->validate == 0))))
7889
0
    return;
7890
7891
16.4k
            if (entity->flags & XML_ENT_EXPANDING) {
7892
173
                xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7893
173
                xmlHaltParser(ctxt);
7894
173
                return;
7895
173
            }
7896
7897
16.2k
      input = xmlNewEntityInputStream(ctxt, entity);
7898
16.2k
      if (xmlCtxtPushInput(ctxt, input) < 0) {
7899
1.20k
                xmlFreeInputStream(input);
7900
1.20k
    return;
7901
1.20k
            }
7902
7903
15.0k
            entity->flags |= XML_ENT_EXPANDING;
7904
7905
15.0k
            GROW;
7906
7907
15.0k
      if (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) {
7908
8.98k
                xmlDetectEncoding(ctxt);
7909
7910
8.98k
                if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
7911
1.79k
                    (IS_BLANK_CH(NXT(5)))) {
7912
1.60k
                    xmlParseTextDecl(ctxt);
7913
1.60k
                }
7914
8.98k
            }
7915
15.0k
  }
7916
16.4k
    }
7917
24.8k
}
7918
7919
/**
7920
 * xmlLoadEntityContent:
7921
 * @ctxt:  an XML parser context
7922
 * @entity: an unloaded system entity
7923
 *
7924
 * Load the content of an entity.
7925
 *
7926
 * Returns 0 in case of success and -1 in case of failure
7927
 */
7928
static int
7929
5.29k
xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
7930
5.29k
    xmlParserInputPtr oldinput, input = NULL;
7931
5.29k
    xmlParserInputPtr *oldinputTab;
7932
5.29k
    const xmlChar *oldencoding;
7933
5.29k
    xmlChar *content = NULL;
7934
5.29k
    xmlResourceType rtype;
7935
5.29k
    size_t length, i;
7936
5.29k
    int oldinputNr, oldinputMax;
7937
5.29k
    int ret = -1;
7938
5.29k
    int res;
7939
7940
5.29k
    if ((ctxt == NULL) || (entity == NULL) ||
7941
5.29k
        ((entity->etype != XML_EXTERNAL_PARAMETER_ENTITY) &&
7942
0
   (entity->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY)) ||
7943
5.29k
  (entity->content != NULL)) {
7944
0
  xmlFatalErr(ctxt, XML_ERR_ARGUMENT,
7945
0
              "xmlLoadEntityContent parameter error");
7946
0
        return(-1);
7947
0
    }
7948
7949
5.29k
    if (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY)
7950
5.29k
        rtype = XML_RESOURCE_PARAMETER_ENTITY;
7951
0
    else
7952
0
        rtype = XML_RESOURCE_GENERAL_ENTITY;
7953
7954
5.29k
    input = xmlLoadResource(ctxt, (char *) entity->URI,
7955
5.29k
                            (char *) entity->ExternalID, rtype);
7956
5.29k
    if (input == NULL)
7957
734
        return(-1);
7958
7959
4.55k
    oldinput = ctxt->input;
7960
4.55k
    oldinputNr = ctxt->inputNr;
7961
4.55k
    oldinputMax = ctxt->inputMax;
7962
4.55k
    oldinputTab = ctxt->inputTab;
7963
4.55k
    oldencoding = ctxt->encoding;
7964
7965
4.55k
    ctxt->input = NULL;
7966
4.55k
    ctxt->inputNr = 0;
7967
4.55k
    ctxt->inputMax = 1;
7968
4.55k
    ctxt->encoding = NULL;
7969
4.55k
    ctxt->inputTab = xmlMalloc(sizeof(xmlParserInputPtr));
7970
4.55k
    if (ctxt->inputTab == NULL) {
7971
1
        xmlErrMemory(ctxt);
7972
1
        xmlFreeInputStream(input);
7973
1
        goto error;
7974
1
    }
7975
7976
4.55k
    xmlBufResetInput(input->buf->buffer, input);
7977
7978
4.55k
    if (xmlCtxtPushInput(ctxt, input) < 0) {
7979
0
        xmlFreeInputStream(input);
7980
0
        goto error;
7981
0
    }
7982
7983
4.55k
    xmlDetectEncoding(ctxt);
7984
7985
    /*
7986
     * Parse a possible text declaration first
7987
     */
7988
4.55k
    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
7989
2.32k
  xmlParseTextDecl(ctxt);
7990
        /*
7991
         * An XML-1.0 document can't reference an entity not XML-1.0
7992
         */
7993
2.32k
        if ((xmlStrEqual(ctxt->version, BAD_CAST "1.0")) &&
7994
1.87k
            (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
7995
676
            xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH,
7996
676
                           "Version mismatch between document and entity\n");
7997
676
        }
7998
2.32k
    }
7999
8000
4.55k
    length = input->cur - input->base;
8001
4.55k
    xmlBufShrink(input->buf->buffer, length);
8002
4.55k
    xmlSaturatedAdd(&ctxt->sizeentities, length);
8003
8004
9.08k
    while ((res = xmlParserInputBufferGrow(input->buf, 4096)) > 0)
8005
4.53k
        ;
8006
8007
4.55k
    xmlBufResetInput(input->buf->buffer, input);
8008
8009
4.55k
    if (res < 0) {
8010
26
        xmlCtxtErrIO(ctxt, input->buf->error, NULL);
8011
26
        goto error;
8012
26
    }
8013
8014
4.53k
    length = xmlBufUse(input->buf->buffer);
8015
4.53k
    if (length > INT_MAX) {
8016
0
        xmlErrMemory(ctxt);
8017
0
        goto error;
8018
0
    }
8019
8020
4.53k
    content = xmlStrndup(xmlBufContent(input->buf->buffer), length);
8021
4.53k
    if (content == NULL) {
8022
2
        xmlErrMemory(ctxt);
8023
2
        goto error;
8024
2
    }
8025
8026
5.04M
    for (i = 0; i < length; ) {
8027
5.04M
        int clen = length - i;
8028
5.04M
        int c = xmlGetUTF8Char(content + i, &clen);
8029
8030
5.04M
        if ((c < 0) || (!IS_CHAR(c))) {
8031
3.81k
            xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
8032
3.81k
                              "xmlLoadEntityContent: invalid char value %d\n",
8033
3.81k
                              content[i]);
8034
3.81k
            goto error;
8035
3.81k
        }
8036
5.03M
        i += clen;
8037
5.03M
    }
8038
8039
719
    xmlSaturatedAdd(&ctxt->sizeentities, length);
8040
719
    entity->content = content;
8041
719
    entity->length = length;
8042
719
    content = NULL;
8043
719
    ret = 0;
8044
8045
4.55k
error:
8046
9.11k
    while (ctxt->inputNr > 0)
8047
4.55k
        xmlFreeInputStream(xmlCtxtPopInput(ctxt));
8048
4.55k
    xmlFree(ctxt->inputTab);
8049
4.55k
    xmlFree((xmlChar *) ctxt->encoding);
8050
8051
4.55k
    ctxt->input = oldinput;
8052
4.55k
    ctxt->inputNr = oldinputNr;
8053
4.55k
    ctxt->inputMax = oldinputMax;
8054
4.55k
    ctxt->inputTab = oldinputTab;
8055
4.55k
    ctxt->encoding = oldencoding;
8056
8057
4.55k
    xmlFree(content);
8058
8059
4.55k
    return(ret);
8060
719
}
8061
8062
/**
8063
 * xmlParseStringPEReference:
8064
 * @ctxt:  an XML parser context
8065
 * @str:  a pointer to an index in the string
8066
 *
8067
 * parse PEReference declarations
8068
 *
8069
 * [69] PEReference ::= '%' Name ';'
8070
 *
8071
 * [ WFC: No Recursion ]
8072
 * A parsed entity must not contain a recursive
8073
 * reference to itself, either directly or indirectly.
8074
 *
8075
 * [ WFC: Entity Declared ]
8076
 * In a document without any DTD, a document with only an internal DTD
8077
 * subset which contains no parameter entity references, or a document
8078
 * with "standalone='yes'", ...  ... The declaration of a parameter
8079
 * entity must precede any reference to it...
8080
 *
8081
 * [ VC: Entity Declared ]
8082
 * In a document with an external subset or external parameter entities
8083
 * with "standalone='no'", ...  ... The declaration of a parameter entity
8084
 * must precede any reference to it...
8085
 *
8086
 * [ WFC: In DTD ]
8087
 * Parameter-entity references may only appear in the DTD.
8088
 * NOTE: misleading but this is handled.
8089
 *
8090
 * Returns the string of the entity content.
8091
 *         str is updated to the current value of the index
8092
 */
8093
static xmlEntityPtr
8094
22.0k
xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
8095
22.0k
    const xmlChar *ptr;
8096
22.0k
    xmlChar cur;
8097
22.0k
    xmlChar *name;
8098
22.0k
    xmlEntityPtr entity = NULL;
8099
8100
22.0k
    if ((str == NULL) || (*str == NULL)) return(NULL);
8101
22.0k
    ptr = *str;
8102
22.0k
    cur = *ptr;
8103
22.0k
    if (cur != '%')
8104
0
        return(NULL);
8105
22.0k
    ptr++;
8106
22.0k
    name = xmlParseStringName(ctxt, &ptr);
8107
22.0k
    if (name == NULL) {
8108
2.08k
  xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8109
2.08k
           "xmlParseStringPEReference: no name\n");
8110
2.08k
  *str = ptr;
8111
2.08k
  return(NULL);
8112
2.08k
    }
8113
19.9k
    cur = *ptr;
8114
19.9k
    if (cur != ';') {
8115
2.66k
  xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
8116
2.66k
  xmlFree(name);
8117
2.66k
  *str = ptr;
8118
2.66k
  return(NULL);
8119
2.66k
    }
8120
17.3k
    ptr++;
8121
8122
    /* Must be set before xmlHandleUndeclaredEntity */
8123
17.3k
    ctxt->hasPErefs = 1;
8124
8125
    /*
8126
     * Request the entity from SAX
8127
     */
8128
17.3k
    if ((ctxt->sax != NULL) &&
8129
17.3k
  (ctxt->sax->getParameterEntity != NULL))
8130
17.3k
  entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
8131
8132
17.3k
    if (entity == NULL) {
8133
1.32k
        xmlHandleUndeclaredEntity(ctxt, name);
8134
16.0k
    } else {
8135
  /*
8136
   * Internal checking in case the entity quest barfed
8137
   */
8138
16.0k
  if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
8139
15.6k
      (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
8140
0
      xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8141
0
        "%%%s; is not a parameter entity\n",
8142
0
        name, NULL);
8143
0
  }
8144
16.0k
    }
8145
8146
17.3k
    xmlFree(name);
8147
17.3k
    *str = ptr;
8148
17.3k
    return(entity);
8149
19.9k
}
8150
8151
/**
8152
 * xmlParseDocTypeDecl:
8153
 * @ctxt:  an XML parser context
8154
 *
8155
 * DEPRECATED: Internal function, don't use.
8156
 *
8157
 * parse a DOCTYPE declaration
8158
 *
8159
 * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?
8160
 *                      ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
8161
 *
8162
 * [ VC: Root Element Type ]
8163
 * The Name in the document type declaration must match the element
8164
 * type of the root element.
8165
 */
8166
8167
void
8168
57.1k
xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
8169
57.1k
    const xmlChar *name = NULL;
8170
57.1k
    xmlChar *ExternalID = NULL;
8171
57.1k
    xmlChar *URI = NULL;
8172
8173
    /*
8174
     * We know that '<!DOCTYPE' has been detected.
8175
     */
8176
57.1k
    SKIP(9);
8177
8178
57.1k
    if (SKIP_BLANKS == 0) {
8179
8.99k
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8180
8.99k
                       "Space required after 'DOCTYPE'\n");
8181
8.99k
    }
8182
8183
    /*
8184
     * Parse the DOCTYPE name.
8185
     */
8186
57.1k
    name = xmlParseName(ctxt);
8187
57.1k
    if (name == NULL) {
8188
3.90k
  xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8189
3.90k
           "xmlParseDocTypeDecl : no DOCTYPE name !\n");
8190
3.90k
    }
8191
57.1k
    ctxt->intSubName = name;
8192
8193
57.1k
    SKIP_BLANKS;
8194
8195
    /*
8196
     * Check for SystemID and ExternalID
8197
     */
8198
57.1k
    URI = xmlParseExternalID(ctxt, &ExternalID, 1);
8199
8200
57.1k
    if ((URI != NULL) || (ExternalID != NULL)) {
8201
11.6k
        ctxt->hasExternalSubset = 1;
8202
11.6k
    }
8203
57.1k
    ctxt->extSubURI = URI;
8204
57.1k
    ctxt->extSubSystem = ExternalID;
8205
8206
57.1k
    SKIP_BLANKS;
8207
8208
    /*
8209
     * Create and update the internal subset.
8210
     */
8211
57.1k
    if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
8212
57.1k
  (!ctxt->disableSAX))
8213
43.8k
  ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
8214
8215
57.1k
    if ((RAW != '[') && (RAW != '>')) {
8216
3.14k
  xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8217
3.14k
    }
8218
57.1k
}
8219
8220
/**
8221
 * xmlParseInternalSubset:
8222
 * @ctxt:  an XML parser context
8223
 *
8224
 * parse the internal subset declaration
8225
 *
8226
 * [28 end] ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
8227
 */
8228
8229
static void
8230
48.3k
xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
8231
    /*
8232
     * Is there any DTD definition ?
8233
     */
8234
48.3k
    if (RAW == '[') {
8235
48.3k
        int oldInputNr = ctxt->inputNr;
8236
8237
48.3k
        NEXT;
8238
  /*
8239
   * Parse the succession of Markup declarations and
8240
   * PEReferences.
8241
   * Subsequence (markupdecl | PEReference | S)*
8242
   */
8243
48.3k
  SKIP_BLANKS;
8244
218k
  while (((RAW != ']') || (ctxt->inputNr > oldInputNr)) &&
8245
205k
               (PARSER_STOPPED(ctxt) == 0)) {
8246
8247
            /*
8248
             * Conditional sections are allowed from external entities included
8249
             * by PE References in the internal subset.
8250
             */
8251
195k
            if ((PARSER_EXTERNAL(ctxt)) &&
8252
20.4k
                (RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
8253
1.08k
                xmlParseConditionalSections(ctxt);
8254
194k
            } else if ((RAW == '<') && ((NXT(1) == '!') || (NXT(1) == '?'))) {
8255
140k
          xmlParseMarkupDecl(ctxt);
8256
140k
            } else if (RAW == '%') {
8257
28.4k
          xmlParsePEReference(ctxt);
8258
28.4k
            } else {
8259
25.5k
    xmlFatalErr(ctxt, XML_ERR_INT_SUBSET_NOT_FINISHED, NULL);
8260
25.5k
                break;
8261
25.5k
            }
8262
170k
      SKIP_BLANKS_PE;
8263
170k
            SHRINK;
8264
170k
            GROW;
8265
170k
  }
8266
8267
52.3k
        while (ctxt->inputNr > oldInputNr)
8268
3.99k
            xmlPopPE(ctxt);
8269
8270
48.3k
  if (RAW == ']') {
8271
12.9k
      NEXT;
8272
12.9k
      SKIP_BLANKS;
8273
12.9k
  }
8274
48.3k
    }
8275
8276
    /*
8277
     * We should be at the end of the DOCTYPE declaration.
8278
     */
8279
48.3k
    if ((ctxt->wellFormed) && (RAW != '>')) {
8280
165
  xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8281
165
  return;
8282
165
    }
8283
48.1k
    NEXT;
8284
48.1k
}
8285
8286
#ifdef LIBXML_SAX1_ENABLED
8287
/**
8288
 * xmlParseAttribute:
8289
 * @ctxt:  an XML parser context
8290
 * @value:  a xmlChar ** used to store the value of the attribute
8291
 *
8292
 * DEPRECATED: Internal function, don't use.
8293
 *
8294
 * parse an attribute
8295
 *
8296
 * [41] Attribute ::= Name Eq AttValue
8297
 *
8298
 * [ WFC: No External Entity References ]
8299
 * Attribute values cannot contain direct or indirect entity references
8300
 * to external entities.
8301
 *
8302
 * [ WFC: No < in Attribute Values ]
8303
 * The replacement text of any entity referred to directly or indirectly in
8304
 * an attribute value (other than "&lt;") must not contain a <.
8305
 *
8306
 * [ VC: Attribute Value Type ]
8307
 * The attribute must have been declared; the value must be of the type
8308
 * declared for it.
8309
 *
8310
 * [25] Eq ::= S? '=' S?
8311
 *
8312
 * With namespace:
8313
 *
8314
 * [NS 11] Attribute ::= QName Eq AttValue
8315
 *
8316
 * Also the case QName == xmlns:??? is handled independently as a namespace
8317
 * definition.
8318
 *
8319
 * Returns the attribute name, and the value in *value.
8320
 */
8321
8322
const xmlChar *
8323
xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
8324
    const xmlChar *name;
8325
    xmlChar *val;
8326
8327
    *value = NULL;
8328
    GROW;
8329
    name = xmlParseName(ctxt);
8330
    if (name == NULL) {
8331
  xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8332
                 "error parsing attribute name\n");
8333
        return(NULL);
8334
    }
8335
8336
    /*
8337
     * read the value
8338
     */
8339
    SKIP_BLANKS;
8340
    if (RAW == '=') {
8341
        NEXT;
8342
  SKIP_BLANKS;
8343
  val = xmlParseAttValue(ctxt);
8344
    } else {
8345
  xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8346
         "Specification mandates value for attribute %s\n", name);
8347
  return(name);
8348
    }
8349
8350
    /*
8351
     * Check that xml:lang conforms to the specification
8352
     * No more registered as an error, just generate a warning now
8353
     * since this was deprecated in XML second edition
8354
     */
8355
    if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
8356
  if (!xmlCheckLanguageID(val)) {
8357
      xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8358
              "Malformed value for xml:lang : %s\n",
8359
        val, NULL);
8360
  }
8361
    }
8362
8363
    /*
8364
     * Check that xml:space conforms to the specification
8365
     */
8366
    if (xmlStrEqual(name, BAD_CAST "xml:space")) {
8367
  if (xmlStrEqual(val, BAD_CAST "default"))
8368
      *(ctxt->space) = 0;
8369
  else if (xmlStrEqual(val, BAD_CAST "preserve"))
8370
      *(ctxt->space) = 1;
8371
  else {
8372
    xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8373
"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
8374
                                 val, NULL);
8375
  }
8376
    }
8377
8378
    *value = val;
8379
    return(name);
8380
}
8381
8382
/**
8383
 * xmlParseStartTag:
8384
 * @ctxt:  an XML parser context
8385
 *
8386
 * DEPRECATED: Internal function, don't use.
8387
 *
8388
 * Parse a start tag. Always consumes '<'.
8389
 *
8390
 * [40] STag ::= '<' Name (S Attribute)* S? '>'
8391
 *
8392
 * [ WFC: Unique Att Spec ]
8393
 * No attribute name may appear more than once in the same start-tag or
8394
 * empty-element tag.
8395
 *
8396
 * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
8397
 *
8398
 * [ WFC: Unique Att Spec ]
8399
 * No attribute name may appear more than once in the same start-tag or
8400
 * empty-element tag.
8401
 *
8402
 * With namespace:
8403
 *
8404
 * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
8405
 *
8406
 * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
8407
 *
8408
 * Returns the element name parsed
8409
 */
8410
8411
const xmlChar *
8412
xmlParseStartTag(xmlParserCtxtPtr ctxt) {
8413
    const xmlChar *name;
8414
    const xmlChar *attname;
8415
    xmlChar *attvalue;
8416
    const xmlChar **atts = ctxt->atts;
8417
    int nbatts = 0;
8418
    int maxatts = ctxt->maxatts;
8419
    int i;
8420
8421
    if (RAW != '<') return(NULL);
8422
    NEXT1;
8423
8424
    name = xmlParseName(ctxt);
8425
    if (name == NULL) {
8426
  xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8427
       "xmlParseStartTag: invalid element name\n");
8428
        return(NULL);
8429
    }
8430
8431
    /*
8432
     * Now parse the attributes, it ends up with the ending
8433
     *
8434
     * (S Attribute)* S?
8435
     */
8436
    SKIP_BLANKS;
8437
    GROW;
8438
8439
    while (((RAW != '>') &&
8440
     ((RAW != '/') || (NXT(1) != '>')) &&
8441
     (IS_BYTE_CHAR(RAW))) && (PARSER_STOPPED(ctxt) == 0)) {
8442
  attname = xmlParseAttribute(ctxt, &attvalue);
8443
        if (attname == NULL)
8444
      break;
8445
        if (attvalue != NULL) {
8446
      /*
8447
       * [ WFC: Unique Att Spec ]
8448
       * No attribute name may appear more than once in the same
8449
       * start-tag or empty-element tag.
8450
       */
8451
      for (i = 0; i < nbatts;i += 2) {
8452
          if (xmlStrEqual(atts[i], attname)) {
8453
        xmlErrAttributeDup(ctxt, NULL, attname);
8454
        goto failed;
8455
    }
8456
      }
8457
      /*
8458
       * Add the pair to atts
8459
       */
8460
      if (nbatts + 4 > maxatts) {
8461
          const xmlChar **n;
8462
                int newSize;
8463
8464
                newSize = xmlGrowCapacity(maxatts, sizeof(n[0]) * 2,
8465
                                          11, XML_MAX_ATTRS);
8466
                if (newSize < 0) {
8467
        xmlErrMemory(ctxt);
8468
        goto failed;
8469
    }
8470
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
8471
                if (newSize < 2)
8472
                    newSize = 2;
8473
#endif
8474
          n = xmlRealloc(atts, newSize * sizeof(n[0]) * 2);
8475
    if (n == NULL) {
8476
        xmlErrMemory(ctxt);
8477
        goto failed;
8478
    }
8479
    atts = n;
8480
                maxatts = newSize * 2;
8481
    ctxt->atts = atts;
8482
    ctxt->maxatts = maxatts;
8483
      }
8484
8485
      atts[nbatts++] = attname;
8486
      atts[nbatts++] = attvalue;
8487
      atts[nbatts] = NULL;
8488
      atts[nbatts + 1] = NULL;
8489
8490
            attvalue = NULL;
8491
  }
8492
8493
failed:
8494
8495
        if (attvalue != NULL)
8496
            xmlFree(attvalue);
8497
8498
  GROW
8499
  if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
8500
      break;
8501
  if (SKIP_BLANKS == 0) {
8502
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8503
         "attributes construct error\n");
8504
  }
8505
  SHRINK;
8506
        GROW;
8507
    }
8508
8509
    /*
8510
     * SAX: Start of Element !
8511
     */
8512
    if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
8513
  (!ctxt->disableSAX)) {
8514
  if (nbatts > 0)
8515
      ctxt->sax->startElement(ctxt->userData, name, atts);
8516
  else
8517
      ctxt->sax->startElement(ctxt->userData, name, NULL);
8518
    }
8519
8520
    if (atts != NULL) {
8521
        /* Free only the content strings */
8522
        for (i = 1;i < nbatts;i+=2)
8523
      if (atts[i] != NULL)
8524
         xmlFree((xmlChar *) atts[i]);
8525
    }
8526
    return(name);
8527
}
8528
8529
/**
8530
 * xmlParseEndTag1:
8531
 * @ctxt:  an XML parser context
8532
 * @line:  line of the start tag
8533
 * @nsNr:  number of namespaces on the start tag
8534
 *
8535
 * Parse an end tag. Always consumes '</'.
8536
 *
8537
 * [42] ETag ::= '</' Name S? '>'
8538
 *
8539
 * With namespace
8540
 *
8541
 * [NS 9] ETag ::= '</' QName S? '>'
8542
 */
8543
8544
static void
8545
xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
8546
    const xmlChar *name;
8547
8548
    GROW;
8549
    if ((RAW != '<') || (NXT(1) != '/')) {
8550
  xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
8551
           "xmlParseEndTag: '</' not found\n");
8552
  return;
8553
    }
8554
    SKIP(2);
8555
8556
    name = xmlParseNameAndCompare(ctxt,ctxt->name);
8557
8558
    /*
8559
     * We should definitely be at the ending "S? '>'" part
8560
     */
8561
    GROW;
8562
    SKIP_BLANKS;
8563
    if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
8564
  xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8565
    } else
8566
  NEXT1;
8567
8568
    /*
8569
     * [ WFC: Element Type Match ]
8570
     * The Name in an element's end-tag must match the element type in the
8571
     * start-tag.
8572
     *
8573
     */
8574
    if (name != (xmlChar*)1) {
8575
        if (name == NULL) name = BAD_CAST "unparsable";
8576
        xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8577
         "Opening and ending tag mismatch: %s line %d and %s\n",
8578
                    ctxt->name, line, name);
8579
    }
8580
8581
    /*
8582
     * SAX: End of Tag
8583
     */
8584
    if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8585
  (!ctxt->disableSAX))
8586
        ctxt->sax->endElement(ctxt->userData, ctxt->name);
8587
8588
    namePop(ctxt);
8589
    spacePop(ctxt);
8590
}
8591
8592
/**
8593
 * xmlParseEndTag:
8594
 * @ctxt:  an XML parser context
8595
 *
8596
 * DEPRECATED: Internal function, don't use.
8597
 *
8598
 * parse an end of tag
8599
 *
8600
 * [42] ETag ::= '</' Name S? '>'
8601
 *
8602
 * With namespace
8603
 *
8604
 * [NS 9] ETag ::= '</' QName S? '>'
8605
 */
8606
8607
void
8608
xmlParseEndTag(xmlParserCtxtPtr ctxt) {
8609
    xmlParseEndTag1(ctxt, 0);
8610
}
8611
#endif /* LIBXML_SAX1_ENABLED */
8612
8613
/************************************************************************
8614
 *                  *
8615
 *          SAX 2 specific operations       *
8616
 *                  *
8617
 ************************************************************************/
8618
8619
/**
8620
 * xmlParseQNameHashed:
8621
 * @ctxt:  an XML parser context
8622
 * @prefix:  pointer to store the prefix part
8623
 *
8624
 * parse an XML Namespace QName
8625
 *
8626
 * [6]  QName  ::= (Prefix ':')? LocalPart
8627
 * [7]  Prefix  ::= NCName
8628
 * [8]  LocalPart  ::= NCName
8629
 *
8630
 * Returns the Name parsed or NULL
8631
 */
8632
8633
static xmlHashedString
8634
9.33M
xmlParseQNameHashed(xmlParserCtxtPtr ctxt, xmlHashedString *prefix) {
8635
9.33M
    xmlHashedString l, p;
8636
9.33M
    int start, isNCName = 0;
8637
8638
9.33M
    l.name = NULL;
8639
9.33M
    p.name = NULL;
8640
8641
9.33M
    GROW;
8642
9.33M
    start = CUR_PTR - BASE_PTR;
8643
8644
9.33M
    l = xmlParseNCName(ctxt);
8645
9.33M
    if (l.name != NULL) {
8646
4.59M
        isNCName = 1;
8647
4.59M
        if (CUR == ':') {
8648
1.26M
            NEXT;
8649
1.26M
            p = l;
8650
1.26M
            l = xmlParseNCName(ctxt);
8651
1.26M
        }
8652
4.59M
    }
8653
9.33M
    if ((l.name == NULL) || (CUR == ':')) {
8654
4.75M
        xmlChar *tmp;
8655
8656
4.75M
        l.name = NULL;
8657
4.75M
        p.name = NULL;
8658
4.75M
        if ((isNCName == 0) && (CUR != ':'))
8659
4.72M
            return(l);
8660
28.4k
        tmp = xmlParseNmtoken(ctxt);
8661
28.4k
        if (tmp != NULL)
8662
18.0k
            xmlFree(tmp);
8663
28.4k
        l = xmlDictLookupHashed(ctxt->dict, BASE_PTR + start,
8664
28.4k
                                CUR_PTR - (BASE_PTR + start));
8665
28.4k
        if (l.name == NULL) {
8666
9
            xmlErrMemory(ctxt);
8667
9
            return(l);
8668
9
        }
8669
28.4k
        xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8670
28.4k
                 "Failed to parse QName '%s'\n", l.name, NULL, NULL);
8671
28.4k
    }
8672
8673
4.60M
    *prefix = p;
8674
4.60M
    return(l);
8675
9.33M
}
8676
8677
/**
8678
 * xmlParseQName:
8679
 * @ctxt:  an XML parser context
8680
 * @prefix:  pointer to store the prefix part
8681
 *
8682
 * parse an XML Namespace QName
8683
 *
8684
 * [6]  QName  ::= (Prefix ':')? LocalPart
8685
 * [7]  Prefix  ::= NCName
8686
 * [8]  LocalPart  ::= NCName
8687
 *
8688
 * Returns the Name parsed or NULL
8689
 */
8690
8691
static const xmlChar *
8692
12.2k
xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
8693
12.2k
    xmlHashedString n, p;
8694
8695
12.2k
    n = xmlParseQNameHashed(ctxt, &p);
8696
12.2k
    if (n.name == NULL)
8697
555
        return(NULL);
8698
11.6k
    *prefix = p.name;
8699
11.6k
    return(n.name);
8700
12.2k
}
8701
8702
/**
8703
 * xmlParseQNameAndCompare:
8704
 * @ctxt:  an XML parser context
8705
 * @name:  the localname
8706
 * @prefix:  the prefix, if any.
8707
 *
8708
 * parse an XML name and compares for match
8709
 * (specialized for endtag parsing)
8710
 *
8711
 * Returns NULL for an illegal name, (xmlChar*) 1 for success
8712
 * and the name for mismatch
8713
 */
8714
8715
static const xmlChar *
8716
xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
8717
311k
                        xmlChar const *prefix) {
8718
311k
    const xmlChar *cmp;
8719
311k
    const xmlChar *in;
8720
311k
    const xmlChar *ret;
8721
311k
    const xmlChar *prefix2;
8722
8723
311k
    if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
8724
8725
311k
    GROW;
8726
311k
    in = ctxt->input->cur;
8727
8728
311k
    cmp = prefix;
8729
1.04M
    while (*in != 0 && *in == *cmp) {
8730
734k
  ++in;
8731
734k
  ++cmp;
8732
734k
    }
8733
311k
    if ((*cmp == 0) && (*in == ':')) {
8734
307k
        in++;
8735
307k
  cmp = name;
8736
2.94M
  while (*in != 0 && *in == *cmp) {
8737
2.63M
      ++in;
8738
2.63M
      ++cmp;
8739
2.63M
  }
8740
307k
  if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
8741
      /* success */
8742
299k
            ctxt->input->col += in - ctxt->input->cur;
8743
299k
      ctxt->input->cur = in;
8744
299k
      return((const xmlChar*) 1);
8745
299k
  }
8746
307k
    }
8747
    /*
8748
     * all strings coms from the dictionary, equality can be done directly
8749
     */
8750
12.2k
    ret = xmlParseQName (ctxt, &prefix2);
8751
12.2k
    if (ret == NULL)
8752
555
        return(NULL);
8753
11.6k
    if ((ret == name) && (prefix == prefix2))
8754
2.85k
  return((const xmlChar*) 1);
8755
8.79k
    return ret;
8756
11.6k
}
8757
8758
/**
8759
 * xmlParseAttribute2:
8760
 * @ctxt:  an XML parser context
8761
 * @pref:  the element prefix
8762
 * @elem:  the element name
8763
 * @prefix:  a xmlChar ** used to store the value of the attribute prefix
8764
 * @value:  a xmlChar ** used to store the value of the attribute
8765
 * @len:  an int * to save the length of the attribute
8766
 * @alloc:  an int * to indicate if the attribute was allocated
8767
 *
8768
 * parse an attribute in the new SAX2 framework.
8769
 *
8770
 * Returns the attribute name, and the value in *value, .
8771
 */
8772
8773
static xmlHashedString
8774
xmlParseAttribute2(xmlParserCtxtPtr ctxt,
8775
                   const xmlChar * pref, const xmlChar * elem,
8776
                   xmlHashedString * hprefix, xmlChar ** value,
8777
                   int *len, int *alloc)
8778
3.08M
{
8779
3.08M
    xmlHashedString hname;
8780
3.08M
    const xmlChar *prefix, *name;
8781
3.08M
    xmlChar *val = NULL, *internal_val = NULL;
8782
3.08M
    int normalize = 0;
8783
3.08M
    int isNamespace;
8784
8785
3.08M
    *value = NULL;
8786
3.08M
    GROW;
8787
3.08M
    hname = xmlParseQNameHashed(ctxt, hprefix);
8788
3.08M
    if (hname.name == NULL) {
8789
1.73M
        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8790
1.73M
                       "error parsing attribute name\n");
8791
1.73M
        return(hname);
8792
1.73M
    }
8793
1.34M
    name = hname.name;
8794
1.34M
    prefix = hprefix->name;
8795
8796
    /*
8797
     * get the type if needed
8798
     */
8799
1.34M
    if (ctxt->attsSpecial != NULL) {
8800
107k
        int type;
8801
8802
107k
        type = XML_PTR_TO_INT(xmlHashQLookup2(ctxt->attsSpecial, pref, elem,
8803
107k
                                              prefix, name));
8804
107k
        if (type != 0)
8805
5.28k
            normalize = 1;
8806
107k
    }
8807
8808
    /*
8809
     * read the value
8810
     */
8811
1.34M
    SKIP_BLANKS;
8812
1.34M
    if (RAW == '=') {
8813
1.30M
        NEXT;
8814
1.30M
        SKIP_BLANKS;
8815
1.30M
        isNamespace = (((prefix == NULL) && (name == ctxt->str_xmlns)) ||
8816
1.26M
                       (prefix == ctxt->str_xmlns));
8817
1.30M
        val = xmlParseAttValueInternal(ctxt, len, alloc, normalize,
8818
1.30M
                                       isNamespace);
8819
1.30M
        if (val == NULL)
8820
12.1k
            goto error;
8821
1.30M
    } else {
8822
45.3k
        xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8823
45.3k
                          "Specification mandates value for attribute %s\n",
8824
45.3k
                          name);
8825
45.3k
        goto error;
8826
45.3k
    }
8827
8828
1.28M
    if (prefix == ctxt->str_xml) {
8829
        /*
8830
         * Check that xml:lang conforms to the specification
8831
         * No more registered as an error, just generate a warning now
8832
         * since this was deprecated in XML second edition
8833
         */
8834
21.8k
        if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
8835
0
            internal_val = xmlStrndup(val, *len);
8836
0
            if (internal_val == NULL)
8837
0
                goto mem_error;
8838
0
            if (!xmlCheckLanguageID(internal_val)) {
8839
0
                xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8840
0
                              "Malformed value for xml:lang : %s\n",
8841
0
                              internal_val, NULL);
8842
0
            }
8843
0
        }
8844
8845
        /*
8846
         * Check that xml:space conforms to the specification
8847
         */
8848
21.8k
        if (xmlStrEqual(name, BAD_CAST "space")) {
8849
416
            internal_val = xmlStrndup(val, *len);
8850
416
            if (internal_val == NULL)
8851
1
                goto mem_error;
8852
415
            if (xmlStrEqual(internal_val, BAD_CAST "default"))
8853
89
                *(ctxt->space) = 0;
8854
326
            else if (xmlStrEqual(internal_val, BAD_CAST "preserve"))
8855
256
                *(ctxt->space) = 1;
8856
70
            else {
8857
70
                xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8858
70
                              "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
8859
70
                              internal_val, NULL);
8860
70
            }
8861
415
        }
8862
21.8k
        if (internal_val) {
8863
415
            xmlFree(internal_val);
8864
415
        }
8865
21.8k
    }
8866
8867
1.28M
    *value = val;
8868
1.28M
    return (hname);
8869
8870
1
mem_error:
8871
1
    xmlErrMemory(ctxt);
8872
57.5k
error:
8873
57.5k
    if ((val != NULL) && (*alloc != 0))
8874
1
        xmlFree(val);
8875
57.5k
    return(hname);
8876
1
}
8877
8878
/**
8879
 * xmlAttrHashInsert:
8880
 * @ctxt: parser context
8881
 * @size: size of the hash table
8882
 * @name: attribute name
8883
 * @uri: namespace uri
8884
 * @hashValue: combined hash value of name and uri
8885
 * @aindex: attribute index (this is a multiple of 5)
8886
 *
8887
 * Inserts a new attribute into the hash table.
8888
 *
8889
 * Returns INT_MAX if no existing attribute was found, the attribute
8890
 * index if an attribute was found, -1 if a memory allocation failed.
8891
 */
8892
static int
8893
xmlAttrHashInsert(xmlParserCtxtPtr ctxt, unsigned size, const xmlChar *name,
8894
1.43M
                  const xmlChar *uri, unsigned hashValue, int aindex) {
8895
1.43M
    xmlAttrHashBucket *table = ctxt->attrHash;
8896
1.43M
    xmlAttrHashBucket *bucket;
8897
1.43M
    unsigned hindex;
8898
8899
1.43M
    hindex = hashValue & (size - 1);
8900
1.43M
    bucket = &table[hindex];
8901
8902
1.76M
    while (bucket->index >= 0) {
8903
347k
        const xmlChar **atts = &ctxt->atts[bucket->index];
8904
8905
347k
        if (name == atts[0]) {
8906
22.9k
            int nsIndex = XML_PTR_TO_INT(atts[2]);
8907
8908
22.9k
            if ((nsIndex == NS_INDEX_EMPTY) ? (uri == NULL) :
8909
22.9k
                (nsIndex == NS_INDEX_XML) ? (uri == ctxt->str_xml_ns) :
8910
7.04k
                (uri == ctxt->nsTab[nsIndex * 2 + 1]))
8911
22.0k
                return(bucket->index);
8912
22.9k
        }
8913
8914
324k
        hindex++;
8915
324k
        bucket++;
8916
324k
        if (hindex >= size) {
8917
96.9k
            hindex = 0;
8918
96.9k
            bucket = table;
8919
96.9k
        }
8920
324k
    }
8921
8922
1.41M
    bucket->index = aindex;
8923
8924
1.41M
    return(INT_MAX);
8925
1.43M
}
8926
8927
static int
8928
xmlAttrHashInsertQName(xmlParserCtxtPtr ctxt, unsigned size,
8929
                       const xmlChar *name, const xmlChar *prefix,
8930
6.02k
                       unsigned hashValue, int aindex) {
8931
6.02k
    xmlAttrHashBucket *table = ctxt->attrHash;
8932
6.02k
    xmlAttrHashBucket *bucket;
8933
6.02k
    unsigned hindex;
8934
8935
6.02k
    hindex = hashValue & (size - 1);
8936
6.02k
    bucket = &table[hindex];
8937
8938
10.3k
    while (bucket->index >= 0) {
8939
6.80k
        const xmlChar **atts = &ctxt->atts[bucket->index];
8940
8941
6.80k
        if ((name == atts[0]) && (prefix == atts[1]))
8942
2.53k
            return(bucket->index);
8943
8944
4.27k
        hindex++;
8945
4.27k
        bucket++;
8946
4.27k
        if (hindex >= size) {
8947
53
            hindex = 0;
8948
53
            bucket = table;
8949
53
        }
8950
4.27k
    }
8951
8952
3.49k
    bucket->index = aindex;
8953
8954
3.49k
    return(INT_MAX);
8955
6.02k
}
8956
/**
8957
 * xmlParseStartTag2:
8958
 * @ctxt:  an XML parser context
8959
 *
8960
 * Parse a start tag. Always consumes '<'.
8961
 *
8962
 * This routine is called when running SAX2 parsing
8963
 *
8964
 * [40] STag ::= '<' Name (S Attribute)* S? '>'
8965
 *
8966
 * [ WFC: Unique Att Spec ]
8967
 * No attribute name may appear more than once in the same start-tag or
8968
 * empty-element tag.
8969
 *
8970
 * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
8971
 *
8972
 * [ WFC: Unique Att Spec ]
8973
 * No attribute name may appear more than once in the same start-tag or
8974
 * empty-element tag.
8975
 *
8976
 * With namespace:
8977
 *
8978
 * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
8979
 *
8980
 * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
8981
 *
8982
 * Returns the element name parsed
8983
 */
8984
8985
static const xmlChar *
8986
xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
8987
6.23M
                  const xmlChar **URI, int *nbNsPtr) {
8988
6.23M
    xmlHashedString hlocalname;
8989
6.23M
    xmlHashedString hprefix;
8990
6.23M
    xmlHashedString hattname;
8991
6.23M
    xmlHashedString haprefix;
8992
6.23M
    const xmlChar *localname;
8993
6.23M
    const xmlChar *prefix;
8994
6.23M
    const xmlChar *attname;
8995
6.23M
    const xmlChar *aprefix;
8996
6.23M
    const xmlChar *uri;
8997
6.23M
    xmlChar *attvalue = NULL;
8998
6.23M
    const xmlChar **atts = ctxt->atts;
8999
6.23M
    unsigned attrHashSize = 0;
9000
6.23M
    int maxatts = ctxt->maxatts;
9001
6.23M
    int nratts, nbatts, nbdef;
9002
6.23M
    int i, j, nbNs, nbTotalDef, attval, nsIndex, maxAtts;
9003
6.23M
    int alloc = 0;
9004
6.23M
    int numNsErr = 0;
9005
6.23M
    int numDupErr = 0;
9006
9007
6.23M
    if (RAW != '<') return(NULL);
9008
6.23M
    NEXT1;
9009
9010
6.23M
    nbatts = 0;
9011
6.23M
    nratts = 0;
9012
6.23M
    nbdef = 0;
9013
6.23M
    nbNs = 0;
9014
6.23M
    nbTotalDef = 0;
9015
6.23M
    attval = 0;
9016
9017
6.23M
    if (xmlParserNsStartElement(ctxt->nsdb) < 0) {
9018
0
        xmlErrMemory(ctxt);
9019
0
        return(NULL);
9020
0
    }
9021
9022
6.23M
    hlocalname = xmlParseQNameHashed(ctxt, &hprefix);
9023
6.23M
    if (hlocalname.name == NULL) {
9024
2.99M
  xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
9025
2.99M
           "StartTag: invalid element name\n");
9026
2.99M
        return(NULL);
9027
2.99M
    }
9028
3.24M
    localname = hlocalname.name;
9029
3.24M
    prefix = hprefix.name;
9030
9031
    /*
9032
     * Now parse the attributes, it ends up with the ending
9033
     *
9034
     * (S Attribute)* S?
9035
     */
9036
3.24M
    SKIP_BLANKS;
9037
3.24M
    GROW;
9038
9039
    /*
9040
     * The ctxt->atts array will be ultimately passed to the SAX callback
9041
     * containing five xmlChar pointers for each attribute:
9042
     *
9043
     * [0] attribute name
9044
     * [1] attribute prefix
9045
     * [2] namespace URI
9046
     * [3] attribute value
9047
     * [4] end of attribute value
9048
     *
9049
     * To save memory, we reuse this array temporarily and store integers
9050
     * in these pointer variables.
9051
     *
9052
     * [0] attribute name
9053
     * [1] attribute prefix
9054
     * [2] hash value of attribute prefix, and later namespace index
9055
     * [3] for non-allocated values: ptrdiff_t offset into input buffer
9056
     * [4] for non-allocated values: ptrdiff_t offset into input buffer
9057
     *
9058
     * The ctxt->attallocs array contains an additional unsigned int for
9059
     * each attribute, containing the hash value of the attribute name
9060
     * and the alloc flag in bit 31.
9061
     */
9062
9063
3.72M
    while (((RAW != '>') &&
9064
3.20M
     ((RAW != '/') || (NXT(1) != '>')) &&
9065
3.11M
     (IS_BYTE_CHAR(RAW))) && (PARSER_STOPPED(ctxt) == 0)) {
9066
3.08M
  int len = -1;
9067
9068
3.08M
  hattname = xmlParseAttribute2(ctxt, prefix, localname,
9069
3.08M
                                          &haprefix, &attvalue, &len,
9070
3.08M
                                          &alloc);
9071
3.08M
        if (hattname.name == NULL)
9072
1.73M
      break;
9073
1.34M
        if (attvalue == NULL)
9074
57.5k
            goto next_attr;
9075
1.28M
        attname = hattname.name;
9076
1.28M
        aprefix = haprefix.name;
9077
1.28M
  if (len < 0) len = xmlStrlen(attvalue);
9078
9079
1.28M
        if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9080
40.8k
            xmlHashedString huri;
9081
40.8k
            xmlURIPtr parsedUri;
9082
9083
40.8k
            huri = xmlDictLookupHashed(ctxt->dict, attvalue, len);
9084
40.8k
            uri = huri.name;
9085
40.8k
            if (uri == NULL) {
9086
1
                xmlErrMemory(ctxt);
9087
1
                goto next_attr;
9088
1
            }
9089
40.8k
            if (*uri != 0) {
9090
39.0k
                if (xmlParseURISafe((const char *) uri, &parsedUri) < 0) {
9091
3
                    xmlErrMemory(ctxt);
9092
3
                    goto next_attr;
9093
3
                }
9094
39.0k
                if (parsedUri == NULL) {
9095
26.8k
                    xmlNsErr(ctxt, XML_WAR_NS_URI,
9096
26.8k
                             "xmlns: '%s' is not a valid URI\n",
9097
26.8k
                                       uri, NULL, NULL);
9098
26.8k
                } else {
9099
12.1k
                    if (parsedUri->scheme == NULL) {
9100
10.6k
                        xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9101
10.6k
                                  "xmlns: URI %s is not absolute\n",
9102
10.6k
                                  uri, NULL, NULL);
9103
10.6k
                    }
9104
12.1k
                    xmlFreeURI(parsedUri);
9105
12.1k
                }
9106
39.0k
                if (uri == ctxt->str_xml_ns) {
9107
174
                    if (attname != ctxt->str_xml) {
9108
174
                        xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9109
174
                     "xml namespace URI cannot be the default namespace\n",
9110
174
                                 NULL, NULL, NULL);
9111
174
                    }
9112
174
                    goto next_attr;
9113
174
                }
9114
38.8k
                if ((len == 29) &&
9115
1.03k
                    (xmlStrEqual(uri,
9116
1.03k
                             BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
9117
192
                    xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9118
192
                         "reuse of the xmlns namespace name is forbidden\n",
9119
192
                             NULL, NULL, NULL);
9120
192
                    goto next_attr;
9121
192
                }
9122
38.8k
            }
9123
9124
40.4k
            if (xmlParserNsPush(ctxt, NULL, &huri, NULL, 0) > 0)
9125
39.9k
                nbNs++;
9126
1.24M
        } else if (aprefix == ctxt->str_xmlns) {
9127
202k
            xmlHashedString huri;
9128
202k
            xmlURIPtr parsedUri;
9129
9130
202k
            huri = xmlDictLookupHashed(ctxt->dict, attvalue, len);
9131
202k
            uri = huri.name;
9132
202k
            if (uri == NULL) {
9133
2
                xmlErrMemory(ctxt);
9134
2
                goto next_attr;
9135
2
            }
9136
9137
202k
            if (attname == ctxt->str_xml) {
9138
399
                if (uri != ctxt->str_xml_ns) {
9139
386
                    xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9140
386
                             "xml namespace prefix mapped to wrong URI\n",
9141
386
                             NULL, NULL, NULL);
9142
386
                }
9143
                /*
9144
                 * Do not keep a namespace definition node
9145
                 */
9146
399
                goto next_attr;
9147
399
            }
9148
202k
            if (uri == ctxt->str_xml_ns) {
9149
120
                if (attname != ctxt->str_xml) {
9150
120
                    xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9151
120
                             "xml namespace URI mapped to wrong prefix\n",
9152
120
                             NULL, NULL, NULL);
9153
120
                }
9154
120
                goto next_attr;
9155
120
            }
9156
202k
            if (attname == ctxt->str_xmlns) {
9157
131
                xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9158
131
                         "redefinition of the xmlns prefix is forbidden\n",
9159
131
                         NULL, NULL, NULL);
9160
131
                goto next_attr;
9161
131
            }
9162
202k
            if ((len == 29) &&
9163
426
                (xmlStrEqual(uri,
9164
426
                             BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
9165
44
                xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9166
44
                         "reuse of the xmlns namespace name is forbidden\n",
9167
44
                         NULL, NULL, NULL);
9168
44
                goto next_attr;
9169
44
            }
9170
202k
            if ((uri == NULL) || (uri[0] == 0)) {
9171
648
                xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9172
648
                         "xmlns:%s: Empty XML namespace is not allowed\n",
9173
648
                              attname, NULL, NULL);
9174
648
                goto next_attr;
9175
201k
            } else {
9176
201k
                if (xmlParseURISafe((const char *) uri, &parsedUri) < 0) {
9177
61
                    xmlErrMemory(ctxt);
9178
61
                    goto next_attr;
9179
61
                }
9180
201k
                if (parsedUri == NULL) {
9181
11.0k
                    xmlNsErr(ctxt, XML_WAR_NS_URI,
9182
11.0k
                         "xmlns:%s: '%s' is not a valid URI\n",
9183
11.0k
                                       attname, uri, NULL);
9184
190k
                } else {
9185
190k
                    if ((ctxt->pedantic) && (parsedUri->scheme == NULL)) {
9186
0
                        xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9187
0
                                  "xmlns:%s: URI %s is not absolute\n",
9188
0
                                  attname, uri, NULL);
9189
0
                    }
9190
190k
                    xmlFreeURI(parsedUri);
9191
190k
                }
9192
201k
            }
9193
9194
201k
            if (xmlParserNsPush(ctxt, &hattname, &huri, NULL, 0) > 0)
9195
201k
                nbNs++;
9196
1.04M
        } else {
9197
            /*
9198
             * Populate attributes array, see above for repurposing
9199
             * of xmlChar pointers.
9200
             */
9201
1.04M
            if ((atts == NULL) || (nbatts + 5 > maxatts)) {
9202
253k
                int res = xmlCtxtGrowAttrs(ctxt);
9203
9204
253k
                maxatts = ctxt->maxatts;
9205
253k
                atts = ctxt->atts;
9206
9207
253k
                if (res < 0)
9208
37
                    goto next_attr;
9209
253k
            }
9210
1.04M
            ctxt->attallocs[nratts++] = (hattname.hashValue & 0x7FFFFFFF) |
9211
1.04M
                                        ((unsigned) alloc << 31);
9212
1.04M
            atts[nbatts++] = attname;
9213
1.04M
            atts[nbatts++] = aprefix;
9214
1.04M
            atts[nbatts++] = (const xmlChar *) (size_t) haprefix.hashValue;
9215
1.04M
            if (alloc) {
9216
52.2k
                atts[nbatts++] = attvalue;
9217
52.2k
                attvalue += len;
9218
52.2k
                atts[nbatts++] = attvalue;
9219
993k
            } else {
9220
                /*
9221
                 * attvalue points into the input buffer which can be
9222
                 * reallocated. Store differences to input->base instead.
9223
                 * The pointers will be reconstructed later.
9224
                 */
9225
993k
                atts[nbatts++] = (void *) (attvalue - BASE_PTR);
9226
993k
                attvalue += len;
9227
993k
                atts[nbatts++] = (void *) (attvalue - BASE_PTR);
9228
993k
            }
9229
            /*
9230
             * tag if some deallocation is needed
9231
             */
9232
1.04M
            if (alloc != 0) attval = 1;
9233
1.04M
            attvalue = NULL; /* moved into atts */
9234
1.04M
        }
9235
9236
1.34M
next_attr:
9237
1.34M
        if ((attvalue != NULL) && (alloc != 0)) {
9238
27.7k
            xmlFree(attvalue);
9239
27.7k
            attvalue = NULL;
9240
27.7k
        }
9241
9242
1.34M
  GROW
9243
1.34M
  if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
9244
781k
      break;
9245
565k
  if (SKIP_BLANKS == 0) {
9246
87.7k
      xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9247
87.7k
         "attributes construct error\n");
9248
87.7k
      break;
9249
87.7k
  }
9250
477k
        GROW;
9251
477k
    }
9252
9253
    /*
9254
     * Namespaces from default attributes
9255
     */
9256
3.24M
    if (ctxt->attsDefault != NULL) {
9257
451k
        xmlDefAttrsPtr defaults;
9258
9259
451k
  defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
9260
451k
  if (defaults != NULL) {
9261
2.56M
      for (i = 0; i < defaults->nbAttrs; i++) {
9262
2.30M
                xmlDefAttr *attr = &defaults->attrs[i];
9263
9264
2.30M
          attname = attr->name.name;
9265
2.30M
    aprefix = attr->prefix.name;
9266
9267
2.30M
    if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9268
133k
                    xmlParserEntityCheck(ctxt, attr->expandedSize);
9269
9270
133k
                    if (xmlParserNsPush(ctxt, NULL, &attr->value, NULL, 1) > 0)
9271
130k
                        nbNs++;
9272
2.16M
    } else if (aprefix == ctxt->str_xmlns) {
9273
937k
                    xmlParserEntityCheck(ctxt, attr->expandedSize);
9274
9275
937k
                    if (xmlParserNsPush(ctxt, &attr->name, &attr->value,
9276
937k
                                      NULL, 1) > 0)
9277
937k
                        nbNs++;
9278
1.23M
    } else {
9279
1.23M
                    if (nratts + nbTotalDef >= XML_MAX_ATTRS) {
9280
0
                        xmlFatalErr(ctxt, XML_ERR_RESOURCE_LIMIT,
9281
0
                                    "Maximum number of attributes exceeded");
9282
0
                        break;
9283
0
                    }
9284
1.23M
                    nbTotalDef += 1;
9285
1.23M
                }
9286
2.30M
      }
9287
261k
  }
9288
451k
    }
9289
9290
    /*
9291
     * Resolve attribute namespaces
9292
     */
9293
4.28M
    for (i = 0; i < nbatts; i += 5) {
9294
1.04M
        attname = atts[i];
9295
1.04M
        aprefix = atts[i+1];
9296
9297
        /*
9298
  * The default namespace does not apply to attribute names.
9299
  */
9300
1.04M
  if (aprefix == NULL) {
9301
989k
            nsIndex = NS_INDEX_EMPTY;
9302
989k
        } else if (aprefix == ctxt->str_xml) {
9303
21.8k
            nsIndex = NS_INDEX_XML;
9304
33.8k
        } else {
9305
33.8k
            haprefix.name = aprefix;
9306
33.8k
            haprefix.hashValue = (size_t) atts[i+2];
9307
33.8k
            nsIndex = xmlParserNsLookup(ctxt, &haprefix, NULL);
9308
9309
33.8k
      if ((nsIndex == INT_MAX) || (nsIndex < ctxt->nsdb->minNsIndex)) {
9310
19.6k
                xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9311
19.6k
        "Namespace prefix %s for %s on %s is not defined\n",
9312
19.6k
        aprefix, attname, localname);
9313
19.6k
                nsIndex = NS_INDEX_EMPTY;
9314
19.6k
            }
9315
33.8k
        }
9316
9317
1.04M
        atts[i+2] = XML_INT_TO_PTR(nsIndex);
9318
1.04M
    }
9319
9320
    /*
9321
     * Maximum number of attributes including default attributes.
9322
     */
9323
3.24M
    maxAtts = nratts + nbTotalDef;
9324
9325
    /*
9326
     * Verify that attribute names are unique.
9327
     */
9328
3.24M
    if (maxAtts > 1) {
9329
333k
        attrHashSize = 4;
9330
745k
        while (attrHashSize / 2 < (unsigned) maxAtts)
9331
411k
            attrHashSize *= 2;
9332
9333
333k
        if (attrHashSize > ctxt->attrHashMax) {
9334
53.2k
            xmlAttrHashBucket *tmp;
9335
9336
53.2k
            tmp = xmlRealloc(ctxt->attrHash, attrHashSize * sizeof(tmp[0]));
9337
53.2k
            if (tmp == NULL) {
9338
20
                xmlErrMemory(ctxt);
9339
20
                goto done;
9340
20
            }
9341
9342
53.2k
            ctxt->attrHash = tmp;
9343
53.2k
            ctxt->attrHashMax = attrHashSize;
9344
53.2k
        }
9345
9346
333k
        memset(ctxt->attrHash, -1, attrHashSize * sizeof(ctxt->attrHash[0]));
9347
9348
579k
        for (i = 0, j = 0; j < nratts; i += 5, j++) {
9349
245k
            const xmlChar *nsuri;
9350
245k
            unsigned hashValue, nameHashValue, uriHashValue;
9351
245k
            int res;
9352
9353
245k
            attname = atts[i];
9354
245k
            aprefix = atts[i+1];
9355
245k
            nsIndex = XML_PTR_TO_INT(atts[i+2]);
9356
            /* Hash values always have bit 31 set, see dict.c */
9357
245k
            nameHashValue = ctxt->attallocs[j] | 0x80000000;
9358
9359
245k
            if (nsIndex == NS_INDEX_EMPTY) {
9360
                /*
9361
                 * Prefix with empty namespace means an undeclared
9362
                 * prefix which was already reported above.
9363
                 */
9364
211k
                if (aprefix != NULL)
9365
11.4k
                    continue;
9366
200k
                nsuri = NULL;
9367
200k
                uriHashValue = URI_HASH_EMPTY;
9368
200k
            } else if (nsIndex == NS_INDEX_XML) {
9369
20.4k
                nsuri = ctxt->str_xml_ns;
9370
20.4k
                uriHashValue = URI_HASH_XML;
9371
20.4k
            } else {
9372
13.3k
                nsuri = ctxt->nsTab[nsIndex * 2 + 1];
9373
13.3k
                uriHashValue = ctxt->nsdb->extra[nsIndex].uriHashValue;
9374
13.3k
            }
9375
9376
234k
            hashValue = xmlDictCombineHash(nameHashValue, uriHashValue);
9377
234k
            res = xmlAttrHashInsert(ctxt, attrHashSize, attname, nsuri,
9378
234k
                                    hashValue, i);
9379
234k
            if (res < 0)
9380
0
                continue;
9381
9382
            /*
9383
             * [ WFC: Unique Att Spec ]
9384
             * No attribute name may appear more than once in the same
9385
             * start-tag or empty-element tag.
9386
             * As extended by the Namespace in XML REC.
9387
             */
9388
234k
            if (res < INT_MAX) {
9389
7.56k
                if (aprefix == atts[res+1]) {
9390
3.23k
                    xmlErrAttributeDup(ctxt, aprefix, attname);
9391
3.23k
                    numDupErr += 1;
9392
4.32k
                } else {
9393
4.32k
                    xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
9394
4.32k
                             "Namespaced Attribute %s in '%s' redefined\n",
9395
4.32k
                             attname, nsuri, NULL);
9396
4.32k
                    numNsErr += 1;
9397
4.32k
                }
9398
7.56k
            }
9399
234k
        }
9400
333k
    }
9401
9402
    /*
9403
     * Default attributes
9404
     */
9405
3.24M
    if (ctxt->attsDefault != NULL) {
9406
451k
        xmlDefAttrsPtr defaults;
9407
9408
451k
  defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
9409
451k
  if (defaults != NULL) {
9410
2.56M
      for (i = 0; i < defaults->nbAttrs; i++) {
9411
2.30M
                xmlDefAttr *attr = &defaults->attrs[i];
9412
2.30M
                const xmlChar *nsuri = NULL;
9413
2.30M
                unsigned hashValue, uriHashValue = 0;
9414
2.30M
                int res;
9415
9416
2.30M
          attname = attr->name.name;
9417
2.30M
    aprefix = attr->prefix.name;
9418
9419
2.30M
    if ((attname == ctxt->str_xmlns) && (aprefix == NULL))
9420
133k
                    continue;
9421
2.16M
    if (aprefix == ctxt->str_xmlns)
9422
937k
                    continue;
9423
9424
1.23M
                if (aprefix == NULL) {
9425
624k
                    nsIndex = NS_INDEX_EMPTY;
9426
624k
                    nsuri = NULL;
9427
624k
                    uriHashValue = URI_HASH_EMPTY;
9428
624k
                } else if (aprefix == ctxt->str_xml) {
9429
87.4k
                    nsIndex = NS_INDEX_XML;
9430
87.4k
                    nsuri = ctxt->str_xml_ns;
9431
87.4k
                    uriHashValue = URI_HASH_XML;
9432
519k
                } else {
9433
519k
                    nsIndex = xmlParserNsLookup(ctxt, &attr->prefix, NULL);
9434
519k
                    if ((nsIndex == INT_MAX) ||
9435
503k
                        (nsIndex < ctxt->nsdb->minNsIndex)) {
9436
503k
                        xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9437
503k
                                 "Namespace prefix %s for %s on %s is not "
9438
503k
                                 "defined\n",
9439
503k
                                 aprefix, attname, localname);
9440
503k
                        nsIndex = NS_INDEX_EMPTY;
9441
503k
                        nsuri = NULL;
9442
503k
                        uriHashValue = URI_HASH_EMPTY;
9443
503k
                    } else {
9444
16.3k
                        nsuri = ctxt->nsTab[nsIndex * 2 + 1];
9445
16.3k
                        uriHashValue = ctxt->nsdb->extra[nsIndex].uriHashValue;
9446
16.3k
                    }
9447
519k
                }
9448
9449
                /*
9450
                 * Check whether the attribute exists
9451
                 */
9452
1.23M
                if (maxAtts > 1) {
9453
1.20M
                    hashValue = xmlDictCombineHash(attr->name.hashValue,
9454
1.20M
                                                   uriHashValue);
9455
1.20M
                    res = xmlAttrHashInsert(ctxt, attrHashSize, attname, nsuri,
9456
1.20M
                                            hashValue, nbatts);
9457
1.20M
                    if (res < 0)
9458
0
                        continue;
9459
1.20M
                    if (res < INT_MAX) {
9460
14.5k
                        if (aprefix == atts[res+1])
9461
742
                            continue;
9462
13.7k
                        xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
9463
13.7k
                                 "Namespaced Attribute %s in '%s' redefined\n",
9464
13.7k
                                 attname, nsuri, NULL);
9465
13.7k
                    }
9466
1.20M
                }
9467
9468
1.23M
                xmlParserEntityCheck(ctxt, attr->expandedSize);
9469
9470
1.23M
                if ((atts == NULL) || (nbatts + 5 > maxatts)) {
9471
6.23k
                    res = xmlCtxtGrowAttrs(ctxt);
9472
9473
6.23k
                    maxatts = ctxt->maxatts;
9474
6.23k
                    atts = ctxt->atts;
9475
9476
6.23k
                    if (res < 0) {
9477
10
                        localname = NULL;
9478
10
                        goto done;
9479
10
                    }
9480
6.23k
                }
9481
9482
1.23M
                atts[nbatts++] = attname;
9483
1.23M
                atts[nbatts++] = aprefix;
9484
1.23M
                atts[nbatts++] = XML_INT_TO_PTR(nsIndex);
9485
1.23M
                atts[nbatts++] = attr->value.name;
9486
1.23M
                atts[nbatts++] = attr->valueEnd;
9487
1.23M
                if ((ctxt->standalone == 1) && (attr->external != 0)) {
9488
0
                    xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED,
9489
0
                            "standalone: attribute %s on %s defaulted "
9490
0
                            "from external subset\n",
9491
0
                            attname, localname);
9492
0
                }
9493
1.23M
                nbdef++;
9494
1.23M
      }
9495
261k
  }
9496
451k
    }
9497
9498
    /*
9499
     * Using a single hash table for nsUri/localName pairs cannot
9500
     * detect duplicate QNames reliably. The following example will
9501
     * only result in two namespace errors.
9502
     *
9503
     * <doc xmlns:a="a" xmlns:b="a">
9504
     *   <elem a:a="" b:a="" b:a=""/>
9505
     * </doc>
9506
     *
9507
     * If we saw more than one namespace error but no duplicate QNames
9508
     * were found, we have to scan for duplicate QNames.
9509
     */
9510
3.24M
    if ((numDupErr == 0) && (numNsErr > 1)) {
9511
1.49k
        memset(ctxt->attrHash, -1,
9512
1.49k
               attrHashSize * sizeof(ctxt->attrHash[0]));
9513
9514
8.29k
        for (i = 0, j = 0; j < nratts; i += 5, j++) {
9515
6.80k
            unsigned hashValue, nameHashValue, prefixHashValue;
9516
6.80k
            int res;
9517
9518
6.80k
            aprefix = atts[i+1];
9519
6.80k
            if (aprefix == NULL)
9520
773
                continue;
9521
9522
6.02k
            attname = atts[i];
9523
            /* Hash values always have bit 31 set, see dict.c */
9524
6.02k
            nameHashValue = ctxt->attallocs[j] | 0x80000000;
9525
6.02k
            prefixHashValue = xmlDictComputeHash(ctxt->dict, aprefix);
9526
9527
6.02k
            hashValue = xmlDictCombineHash(nameHashValue, prefixHashValue);
9528
6.02k
            res = xmlAttrHashInsertQName(ctxt, attrHashSize, attname,
9529
6.02k
                                         aprefix, hashValue, i);
9530
6.02k
            if (res < INT_MAX)
9531
2.53k
                xmlErrAttributeDup(ctxt, aprefix, attname);
9532
6.02k
        }
9533
1.49k
    }
9534
9535
    /*
9536
     * Reconstruct attribute pointers
9537
     */
9538
5.52M
    for (i = 0, j = 0; i < nbatts; i += 5, j++) {
9539
        /* namespace URI */
9540
2.27M
        nsIndex = XML_PTR_TO_INT(atts[i+2]);
9541
2.27M
        if (nsIndex == INT_MAX)
9542
2.13M
            atts[i+2] = NULL;
9543
139k
        else if (nsIndex == INT_MAX - 1)
9544
108k
            atts[i+2] = ctxt->str_xml_ns;
9545
30.5k
        else
9546
30.5k
            atts[i+2] = ctxt->nsTab[nsIndex * 2 + 1];
9547
9548
2.27M
        if ((j < nratts) && (ctxt->attallocs[j] & 0x80000000) == 0) {
9549
993k
            atts[i+3] = BASE_PTR + XML_PTR_TO_INT(atts[i+3]);  /* value */
9550
993k
            atts[i+4] = BASE_PTR + XML_PTR_TO_INT(atts[i+4]);  /* valuend */
9551
993k
        }
9552
2.27M
    }
9553
9554
3.24M
    uri = xmlParserNsLookupUri(ctxt, &hprefix);
9555
3.24M
    if ((prefix != NULL) && (uri == NULL)) {
9556
150k
  xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9557
150k
           "Namespace prefix %s on %s is not defined\n",
9558
150k
     prefix, localname, NULL);
9559
150k
    }
9560
3.24M
    *pref = prefix;
9561
3.24M
    *URI = uri;
9562
9563
    /*
9564
     * SAX callback
9565
     */
9566
3.24M
    if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
9567
3.24M
  (!ctxt->disableSAX)) {
9568
2.59M
  if (nbNs > 0)
9569
188k
      ctxt->sax->startElementNs(ctxt->userData, localname, prefix, uri,
9570
188k
                          nbNs, ctxt->nsTab + 2 * (ctxt->nsNr - nbNs),
9571
188k
        nbatts / 5, nbdef, atts);
9572
2.40M
  else
9573
2.40M
      ctxt->sax->startElementNs(ctxt->userData, localname, prefix, uri,
9574
2.40M
                          0, NULL, nbatts / 5, nbdef, atts);
9575
2.59M
    }
9576
9577
3.24M
done:
9578
    /*
9579
     * Free allocated attribute values
9580
     */
9581
3.24M
    if (attval != 0) {
9582
130k
  for (i = 0, j = 0; j < nratts; i += 5, j++)
9583
79.2k
      if (ctxt->attallocs[j] & 0x80000000)
9584
52.2k
          xmlFree((xmlChar *) atts[i+3]);
9585
51.2k
    }
9586
9587
3.24M
    *nbNsPtr = nbNs;
9588
3.24M
    return(localname);
9589
3.24M
}
9590
9591
/**
9592
 * xmlParseEndTag2:
9593
 * @ctxt:  an XML parser context
9594
 * @line:  line of the start tag
9595
 * @nsNr:  number of namespaces on the start tag
9596
 *
9597
 * Parse an end tag. Always consumes '</'.
9598
 *
9599
 * [42] ETag ::= '</' Name S? '>'
9600
 *
9601
 * With namespace
9602
 *
9603
 * [NS 9] ETag ::= '</' QName S? '>'
9604
 */
9605
9606
static void
9607
496k
xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlStartTag *tag) {
9608
496k
    const xmlChar *name;
9609
9610
496k
    GROW;
9611
496k
    if ((RAW != '<') || (NXT(1) != '/')) {
9612
1.25k
  xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
9613
1.25k
  return;
9614
1.25k
    }
9615
494k
    SKIP(2);
9616
9617
494k
    if (tag->prefix == NULL)
9618
183k
        name = xmlParseNameAndCompare(ctxt, ctxt->name);
9619
311k
    else
9620
311k
        name = xmlParseQNameAndCompare(ctxt, ctxt->name, tag->prefix);
9621
9622
    /*
9623
     * We should definitely be at the ending "S? '>'" part
9624
     */
9625
494k
    GROW;
9626
494k
    SKIP_BLANKS;
9627
494k
    if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
9628
66.3k
  xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
9629
66.3k
    } else
9630
428k
  NEXT1;
9631
9632
    /*
9633
     * [ WFC: Element Type Match ]
9634
     * The Name in an element's end-tag must match the element type in the
9635
     * start-tag.
9636
     *
9637
     */
9638
494k
    if (name != (xmlChar*)1) {
9639
88.0k
        if (name == NULL) name = BAD_CAST "unparsable";
9640
88.0k
        xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
9641
88.0k
         "Opening and ending tag mismatch: %s line %d and %s\n",
9642
88.0k
                    ctxt->name, tag->line, name);
9643
88.0k
    }
9644
9645
    /*
9646
     * SAX: End of Tag
9647
     */
9648
494k
    if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9649
494k
  (!ctxt->disableSAX))
9650
419k
  ctxt->sax->endElementNs(ctxt->userData, ctxt->name, tag->prefix,
9651
419k
                                tag->URI);
9652
9653
494k
    spacePop(ctxt);
9654
494k
    if (tag->nsNr != 0)
9655
176k
  xmlParserNsPop(ctxt, tag->nsNr);
9656
494k
}
9657
9658
/**
9659
 * xmlParseCDSect:
9660
 * @ctxt:  an XML parser context
9661
 *
9662
 * DEPRECATED: Internal function, don't use.
9663
 *
9664
 * Parse escaped pure raw content. Always consumes '<!['.
9665
 *
9666
 * [18] CDSect ::= CDStart CData CDEnd
9667
 *
9668
 * [19] CDStart ::= '<![CDATA['
9669
 *
9670
 * [20] Data ::= (Char* - (Char* ']]>' Char*))
9671
 *
9672
 * [21] CDEnd ::= ']]>'
9673
 */
9674
void
9675
19.4k
xmlParseCDSect(xmlParserCtxtPtr ctxt) {
9676
19.4k
    xmlChar *buf = NULL;
9677
19.4k
    int len = 0;
9678
19.4k
    int size = XML_PARSER_BUFFER_SIZE;
9679
19.4k
    int r, rl;
9680
19.4k
    int s, sl;
9681
19.4k
    int cur, l;
9682
19.4k
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
9683
0
                    XML_MAX_HUGE_LENGTH :
9684
19.4k
                    XML_MAX_TEXT_LENGTH;
9685
9686
19.4k
    if ((CUR != '<') || (NXT(1) != '!') || (NXT(2) != '['))
9687
0
        return;
9688
19.4k
    SKIP(3);
9689
9690
19.4k
    if (!CMP6(CUR_PTR, 'C', 'D', 'A', 'T', 'A', '['))
9691
0
        return;
9692
19.4k
    SKIP(6);
9693
9694
19.4k
    r = xmlCurrentCharRecover(ctxt, &rl);
9695
19.4k
    if (!IS_CHAR(r)) {
9696
1.64k
  xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9697
1.64k
        goto out;
9698
1.64k
    }
9699
17.8k
    NEXTL(rl);
9700
17.8k
    s = xmlCurrentCharRecover(ctxt, &sl);
9701
17.8k
    if (!IS_CHAR(s)) {
9702
400
  xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9703
400
        goto out;
9704
400
    }
9705
17.4k
    NEXTL(sl);
9706
17.4k
    cur = xmlCurrentCharRecover(ctxt, &l);
9707
17.4k
    buf = xmlMalloc(size);
9708
17.4k
    if (buf == NULL) {
9709
3
  xmlErrMemory(ctxt);
9710
3
        goto out;
9711
3
    }
9712
4.46M
    while (IS_CHAR(cur) &&
9713
4.45M
           ((r != ']') || (s != ']') || (cur != '>'))) {
9714
4.44M
  if (len + 5 >= size) {
9715
11.1k
      xmlChar *tmp;
9716
11.1k
            int newSize;
9717
9718
11.1k
            newSize = xmlGrowCapacity(size, 1, 1, maxLength);
9719
11.1k
            if (newSize < 0) {
9720
0
                xmlFatalErrMsg(ctxt, XML_ERR_CDATA_NOT_FINISHED,
9721
0
                               "CData section too big found\n");
9722
0
                goto out;
9723
0
            }
9724
11.1k
      tmp = xmlRealloc(buf, newSize);
9725
11.1k
      if (tmp == NULL) {
9726
1
    xmlErrMemory(ctxt);
9727
1
                goto out;
9728
1
      }
9729
11.1k
      buf = tmp;
9730
11.1k
      size = newSize;
9731
11.1k
  }
9732
4.44M
  COPY_BUF(buf, len, r);
9733
4.44M
  r = s;
9734
4.44M
  rl = sl;
9735
4.44M
  s = cur;
9736
4.44M
  sl = l;
9737
4.44M
  NEXTL(l);
9738
4.44M
  cur = xmlCurrentCharRecover(ctxt, &l);
9739
4.44M
    }
9740
17.4k
    buf[len] = 0;
9741
17.4k
    if (cur != '>') {
9742
6.14k
  xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
9743
6.14k
                       "CData section not finished\n%.50s\n", buf);
9744
6.14k
        goto out;
9745
6.14k
    }
9746
11.2k
    NEXTL(l);
9747
9748
    /*
9749
     * OK the buffer is to be consumed as cdata.
9750
     */
9751
11.2k
    if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
9752
11.0k
        if ((ctxt->sax->cdataBlock != NULL) &&
9753
11.0k
            ((ctxt->options & XML_PARSE_NOCDATA) == 0)) {
9754
2.48k
            ctxt->sax->cdataBlock(ctxt->userData, buf, len);
9755
8.53k
        } else if (ctxt->sax->characters != NULL) {
9756
8.53k
            ctxt->sax->characters(ctxt->userData, buf, len);
9757
8.53k
        }
9758
11.0k
    }
9759
9760
19.4k
out:
9761
19.4k
    xmlFree(buf);
9762
19.4k
}
9763
9764
/**
9765
 * xmlParseContentInternal:
9766
 * @ctxt:  an XML parser context
9767
 *
9768
 * Parse a content sequence. Stops at EOF or '</'. Leaves checking of
9769
 * unexpected EOF to the caller.
9770
 */
9771
9772
static void
9773
194k
xmlParseContentInternal(xmlParserCtxtPtr ctxt) {
9774
194k
    int oldNameNr = ctxt->nameNr;
9775
194k
    int oldSpaceNr = ctxt->spaceNr;
9776
194k
    int oldNodeNr = ctxt->nodeNr;
9777
9778
194k
    GROW;
9779
152M
    while ((ctxt->input->cur < ctxt->input->end) &&
9780
152M
     (PARSER_STOPPED(ctxt) == 0)) {
9781
152M
  const xmlChar *cur = ctxt->input->cur;
9782
9783
  /*
9784
   * First case : a Processing Instruction.
9785
   */
9786
152M
  if ((*cur == '<') && (cur[1] == '?')) {
9787
17.6k
      xmlParsePI(ctxt);
9788
17.6k
  }
9789
9790
  /*
9791
   * Second case : a CDSection
9792
   */
9793
  /* 2.6.0 test was *cur not RAW */
9794
152M
  else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
9795
19.4k
      xmlParseCDSect(ctxt);
9796
19.4k
  }
9797
9798
  /*
9799
   * Third case :  a comment
9800
   */
9801
152M
  else if ((*cur == '<') && (NXT(1) == '!') &&
9802
92.7k
     (NXT(2) == '-') && (NXT(3) == '-')) {
9803
48.1k
      xmlParseComment(ctxt);
9804
48.1k
  }
9805
9806
  /*
9807
   * Fourth case :  a sub-element.
9808
   */
9809
152M
  else if (*cur == '<') {
9810
6.51M
            if (NXT(1) == '/') {
9811
495k
                if (ctxt->nameNr <= oldNameNr)
9812
174k
                    break;
9813
320k
          xmlParseElementEnd(ctxt);
9814
6.02M
            } else {
9815
6.02M
          xmlParseElementStart(ctxt);
9816
6.02M
            }
9817
6.51M
  }
9818
9819
  /*
9820
   * Fifth case : a reference. If if has not been resolved,
9821
   *    parsing returns it's Name, create the node
9822
   */
9823
9824
145M
  else if (*cur == '&') {
9825
131k
      xmlParseReference(ctxt);
9826
131k
  }
9827
9828
  /*
9829
   * Last case, text. Note that References are handled directly.
9830
   */
9831
145M
  else {
9832
145M
      xmlParseCharDataInternal(ctxt, 0);
9833
145M
  }
9834
9835
152M
  SHRINK;
9836
152M
  GROW;
9837
152M
    }
9838
9839
194k
    if ((ctxt->nameNr > oldNameNr) &&
9840
10.2k
        (ctxt->input->cur >= ctxt->input->end) &&
9841
9.67k
        (ctxt->wellFormed)) {
9842
330
        const xmlChar *name = ctxt->nameTab[ctxt->nameNr - 1];
9843
330
        int line = ctxt->pushTab[ctxt->nameNr - 1].line;
9844
330
        xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
9845
330
                "Premature end of data in tag %s line %d\n",
9846
330
                name, line, NULL);
9847
330
    }
9848
9849
    /*
9850
     * Clean up in error case
9851
     */
9852
9853
270k
    while (ctxt->nodeNr > oldNodeNr)
9854
76.7k
        nodePop(ctxt);
9855
9856
406k
    while (ctxt->nameNr > oldNameNr) {
9857
212k
        xmlStartTag *tag = &ctxt->pushTab[ctxt->nameNr - 1];
9858
9859
212k
        if (tag->nsNr != 0)
9860
59.4k
            xmlParserNsPop(ctxt, tag->nsNr);
9861
9862
212k
        namePop(ctxt);
9863
212k
    }
9864
9865
406k
    while (ctxt->spaceNr > oldSpaceNr)
9866
212k
        spacePop(ctxt);
9867
194k
}
9868
9869
/**
9870
 * xmlParseContent:
9871
 * @ctxt:  an XML parser context
9872
 *
9873
 * Parse XML element content. This is useful if you're only interested
9874
 * in custom SAX callbacks. If you want a node list, use
9875
 * xmlCtxtParseContent.
9876
 */
9877
void
9878
0
xmlParseContent(xmlParserCtxtPtr ctxt) {
9879
0
    if ((ctxt == NULL) || (ctxt->input == NULL))
9880
0
        return;
9881
9882
0
    xmlCtxtInitializeLate(ctxt);
9883
9884
0
    xmlParseContentInternal(ctxt);
9885
9886
0
    xmlParserCheckEOF(ctxt, XML_ERR_NOT_WELL_BALANCED);
9887
0
}
9888
9889
/**
9890
 * xmlParseElement:
9891
 * @ctxt:  an XML parser context
9892
 *
9893
 * DEPRECATED: Internal function, don't use.
9894
 *
9895
 * parse an XML element
9896
 *
9897
 * [39] element ::= EmptyElemTag | STag content ETag
9898
 *
9899
 * [ WFC: Element Type Match ]
9900
 * The Name in an element's end-tag must match the element type in the
9901
 * start-tag.
9902
 *
9903
 */
9904
9905
void
9906
212k
xmlParseElement(xmlParserCtxtPtr ctxt) {
9907
212k
    if (xmlParseElementStart(ctxt) != 0)
9908
21.4k
        return;
9909
9910
191k
    xmlParseContentInternal(ctxt);
9911
9912
191k
    if (ctxt->input->cur >= ctxt->input->end) {
9913
15.2k
        if (ctxt->wellFormed) {
9914
521
            const xmlChar *name = ctxt->nameTab[ctxt->nameNr - 1];
9915
521
            int line = ctxt->pushTab[ctxt->nameNr - 1].line;
9916
521
            xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
9917
521
                    "Premature end of data in tag %s line %d\n",
9918
521
                    name, line, NULL);
9919
521
        }
9920
15.2k
        return;
9921
15.2k
    }
9922
9923
175k
    xmlParseElementEnd(ctxt);
9924
175k
}
9925
9926
/**
9927
 * xmlParseElementStart:
9928
 * @ctxt:  an XML parser context
9929
 *
9930
 * Parse the start of an XML element. Returns -1 in case of error, 0 if an
9931
 * opening tag was parsed, 1 if an empty element was parsed.
9932
 *
9933
 * Always consumes '<'.
9934
 */
9935
static int
9936
6.23M
xmlParseElementStart(xmlParserCtxtPtr ctxt) {
9937
6.23M
    int maxDepth = (ctxt->options & XML_PARSE_HUGE) ? 2048 : 256;
9938
6.23M
    const xmlChar *name;
9939
6.23M
    const xmlChar *prefix = NULL;
9940
6.23M
    const xmlChar *URI = NULL;
9941
6.23M
    xmlParserNodeInfo node_info;
9942
6.23M
    int line;
9943
6.23M
    xmlNodePtr cur;
9944
6.23M
    int nbNs = 0;
9945
9946
6.23M
    if (ctxt->nameNr > maxDepth) {
9947
198
        xmlFatalErrMsgInt(ctxt, XML_ERR_RESOURCE_LIMIT,
9948
198
                "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
9949
198
                ctxt->nameNr);
9950
198
  xmlHaltParser(ctxt);
9951
198
  return(-1);
9952
198
    }
9953
9954
    /* Capture start position */
9955
6.23M
    if (ctxt->record_info) {
9956
0
        node_info.begin_pos = ctxt->input->consumed +
9957
0
                          (CUR_PTR - ctxt->input->base);
9958
0
  node_info.begin_line = ctxt->input->line;
9959
0
    }
9960
9961
6.23M
    if (ctxt->spaceNr == 0)
9962
0
  spacePush(ctxt, -1);
9963
6.23M
    else if (*ctxt->space == -2)
9964
0
  spacePush(ctxt, -1);
9965
6.23M
    else
9966
6.23M
  spacePush(ctxt, *ctxt->space);
9967
9968
6.23M
    line = ctxt->input->line;
9969
#ifdef LIBXML_SAX1_ENABLED
9970
    if (ctxt->sax2)
9971
#endif /* LIBXML_SAX1_ENABLED */
9972
6.23M
        name = xmlParseStartTag2(ctxt, &prefix, &URI, &nbNs);
9973
#ifdef LIBXML_SAX1_ENABLED
9974
    else
9975
  name = xmlParseStartTag(ctxt);
9976
#endif /* LIBXML_SAX1_ENABLED */
9977
6.23M
    if (name == NULL) {
9978
2.99M
  spacePop(ctxt);
9979
2.99M
        return(-1);
9980
2.99M
    }
9981
3.24M
    nameNsPush(ctxt, name, prefix, URI, line, nbNs);
9982
3.24M
    cur = ctxt->node;
9983
9984
#ifdef LIBXML_VALID_ENABLED
9985
    /*
9986
     * [ VC: Root Element Type ]
9987
     * The Name in the document type declaration must match the element
9988
     * type of the root element.
9989
     */
9990
    if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
9991
        ctxt->node && (ctxt->node == ctxt->myDoc->children))
9992
        ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
9993
#endif /* LIBXML_VALID_ENABLED */
9994
9995
    /*
9996
     * Check for an Empty Element.
9997
     */
9998
3.24M
    if ((RAW == '/') && (NXT(1) == '>')) {
9999
668k
        SKIP(2);
10000
668k
  if (ctxt->sax2) {
10001
668k
      if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
10002
668k
    (!ctxt->disableSAX))
10003
593k
    ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
10004
#ifdef LIBXML_SAX1_ENABLED
10005
  } else {
10006
      if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
10007
    (!ctxt->disableSAX))
10008
    ctxt->sax->endElement(ctxt->userData, name);
10009
#endif /* LIBXML_SAX1_ENABLED */
10010
668k
  }
10011
668k
  namePop(ctxt);
10012
668k
  spacePop(ctxt);
10013
668k
  if (nbNs > 0)
10014
11.0k
      xmlParserNsPop(ctxt, nbNs);
10015
668k
  if (cur != NULL && ctxt->record_info) {
10016
0
            node_info.node = cur;
10017
0
            node_info.end_pos = ctxt->input->consumed +
10018
0
                                (CUR_PTR - ctxt->input->base);
10019
0
            node_info.end_line = ctxt->input->line;
10020
0
            xmlParserAddNodeInfo(ctxt, &node_info);
10021
0
  }
10022
668k
  return(1);
10023
668k
    }
10024
2.57M
    if (RAW == '>') {
10025
724k
        NEXT1;
10026
724k
        if (cur != NULL && ctxt->record_info) {
10027
0
            node_info.node = cur;
10028
0
            node_info.end_pos = 0;
10029
0
            node_info.end_line = 0;
10030
0
            xmlParserAddNodeInfo(ctxt, &node_info);
10031
0
        }
10032
1.85M
    } else {
10033
1.85M
        xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
10034
1.85M
         "Couldn't find end of Start Tag %s line %d\n",
10035
1.85M
                    name, line, NULL);
10036
10037
  /*
10038
   * end of parsing of this node.
10039
   */
10040
1.85M
  nodePop(ctxt);
10041
1.85M
  namePop(ctxt);
10042
1.85M
  spacePop(ctxt);
10043
1.85M
  if (nbNs > 0)
10044
205k
      xmlParserNsPop(ctxt, nbNs);
10045
1.85M
  return(-1);
10046
1.85M
    }
10047
10048
724k
    return(0);
10049
2.57M
}
10050
10051
/**
10052
 * xmlParseElementEnd:
10053
 * @ctxt:  an XML parser context
10054
 *
10055
 * Parse the end of an XML element. Always consumes '</'.
10056
 */
10057
static void
10058
496k
xmlParseElementEnd(xmlParserCtxtPtr ctxt) {
10059
496k
    xmlNodePtr cur = ctxt->node;
10060
10061
496k
    if (ctxt->nameNr <= 0) {
10062
332
        if ((RAW == '<') && (NXT(1) == '/'))
10063
2
            SKIP(2);
10064
332
        return;
10065
332
    }
10066
10067
    /*
10068
     * parse the end of tag: '</' should be here.
10069
     */
10070
496k
    if (ctxt->sax2) {
10071
496k
  xmlParseEndTag2(ctxt, &ctxt->pushTab[ctxt->nameNr - 1]);
10072
496k
  namePop(ctxt);
10073
496k
    }
10074
#ifdef LIBXML_SAX1_ENABLED
10075
    else
10076
  xmlParseEndTag1(ctxt, 0);
10077
#endif /* LIBXML_SAX1_ENABLED */
10078
10079
    /*
10080
     * Capture end position
10081
     */
10082
496k
    if (cur != NULL && ctxt->record_info) {
10083
0
        xmlParserNodeInfoPtr node_info;
10084
10085
0
        node_info = (xmlParserNodeInfoPtr) xmlParserFindNodeInfo(ctxt, cur);
10086
0
        if (node_info != NULL) {
10087
0
            node_info->end_pos = ctxt->input->consumed +
10088
0
                                 (CUR_PTR - ctxt->input->base);
10089
0
            node_info->end_line = ctxt->input->line;
10090
0
        }
10091
0
    }
10092
496k
}
10093
10094
/**
10095
 * xmlParseVersionNum:
10096
 * @ctxt:  an XML parser context
10097
 *
10098
 * DEPRECATED: Internal function, don't use.
10099
 *
10100
 * parse the XML version value.
10101
 *
10102
 * [26] VersionNum ::= '1.' [0-9]+
10103
 *
10104
 * In practice allow [0-9].[0-9]+ at that level
10105
 *
10106
 * Returns the string giving the XML version number, or NULL
10107
 */
10108
xmlChar *
10109
50.2k
xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
10110
50.2k
    xmlChar *buf = NULL;
10111
50.2k
    int len = 0;
10112
50.2k
    int size = 10;
10113
50.2k
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
10114
0
                    XML_MAX_TEXT_LENGTH :
10115
50.2k
                    XML_MAX_NAME_LENGTH;
10116
50.2k
    xmlChar cur;
10117
10118
50.2k
    buf = xmlMalloc(size);
10119
50.2k
    if (buf == NULL) {
10120
3
  xmlErrMemory(ctxt);
10121
3
  return(NULL);
10122
3
    }
10123
50.2k
    cur = CUR;
10124
50.2k
    if (!((cur >= '0') && (cur <= '9'))) {
10125
329
  xmlFree(buf);
10126
329
  return(NULL);
10127
329
    }
10128
49.9k
    buf[len++] = cur;
10129
49.9k
    NEXT;
10130
49.9k
    cur=CUR;
10131
49.9k
    if (cur != '.') {
10132
89
  xmlFree(buf);
10133
89
  return(NULL);
10134
89
    }
10135
49.8k
    buf[len++] = cur;
10136
49.8k
    NEXT;
10137
49.8k
    cur=CUR;
10138
153k
    while ((cur >= '0') && (cur <= '9')) {
10139
103k
  if (len + 1 >= size) {
10140
6.82k
      xmlChar *tmp;
10141
6.82k
            int newSize;
10142
10143
6.82k
            newSize = xmlGrowCapacity(size, 1, 1, maxLength);
10144
6.82k
            if (newSize < 0) {
10145
0
                xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "VersionNum");
10146
0
                xmlFree(buf);
10147
0
                return(NULL);
10148
0
            }
10149
6.82k
      tmp = xmlRealloc(buf, newSize);
10150
6.82k
      if (tmp == NULL) {
10151
1
    xmlErrMemory(ctxt);
10152
1
          xmlFree(buf);
10153
1
    return(NULL);
10154
1
      }
10155
6.82k
      buf = tmp;
10156
6.82k
            size = newSize;
10157
6.82k
  }
10158
103k
  buf[len++] = cur;
10159
103k
  NEXT;
10160
103k
  cur=CUR;
10161
103k
    }
10162
49.8k
    buf[len] = 0;
10163
49.8k
    return(buf);
10164
49.8k
}
10165
10166
/**
10167
 * xmlParseVersionInfo:
10168
 * @ctxt:  an XML parser context
10169
 *
10170
 * DEPRECATED: Internal function, don't use.
10171
 *
10172
 * parse the XML version.
10173
 *
10174
 * [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ")
10175
 *
10176
 * [25] Eq ::= S? '=' S?
10177
 *
10178
 * Returns the version string, e.g. "1.0"
10179
 */
10180
10181
xmlChar *
10182
62.4k
xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
10183
62.4k
    xmlChar *version = NULL;
10184
10185
62.4k
    if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) {
10186
50.5k
  SKIP(7);
10187
50.5k
  SKIP_BLANKS;
10188
50.5k
  if (RAW != '=') {
10189
228
      xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10190
228
      return(NULL);
10191
228
        }
10192
50.3k
  NEXT;
10193
50.3k
  SKIP_BLANKS;
10194
50.3k
  if (RAW == '"') {
10195
48.2k
      NEXT;
10196
48.2k
      version = xmlParseVersionNum(ctxt);
10197
48.2k
      if (RAW != '"') {
10198
529
    xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10199
529
      } else
10200
47.7k
          NEXT;
10201
48.2k
  } else if (RAW == '\''){
10202
1.99k
      NEXT;
10203
1.99k
      version = xmlParseVersionNum(ctxt);
10204
1.99k
      if (RAW != '\'') {
10205
247
    xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10206
247
      } else
10207
1.74k
          NEXT;
10208
1.99k
  } else {
10209
46
      xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10210
46
  }
10211
50.3k
    }
10212
62.2k
    return(version);
10213
62.4k
}
10214
10215
/**
10216
 * xmlParseEncName:
10217
 * @ctxt:  an XML parser context
10218
 *
10219
 * DEPRECATED: Internal function, don't use.
10220
 *
10221
 * parse the XML encoding name
10222
 *
10223
 * [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
10224
 *
10225
 * Returns the encoding name value or NULL
10226
 */
10227
xmlChar *
10228
36.2k
xmlParseEncName(xmlParserCtxtPtr ctxt) {
10229
36.2k
    xmlChar *buf = NULL;
10230
36.2k
    int len = 0;
10231
36.2k
    int size = 10;
10232
36.2k
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
10233
0
                    XML_MAX_TEXT_LENGTH :
10234
36.2k
                    XML_MAX_NAME_LENGTH;
10235
36.2k
    xmlChar cur;
10236
10237
36.2k
    cur = CUR;
10238
36.2k
    if (((cur >= 'a') && (cur <= 'z')) ||
10239
36.1k
        ((cur >= 'A') && (cur <= 'Z'))) {
10240
36.1k
  buf = xmlMalloc(size);
10241
36.1k
  if (buf == NULL) {
10242
8
      xmlErrMemory(ctxt);
10243
8
      return(NULL);
10244
8
  }
10245
10246
36.1k
  buf[len++] = cur;
10247
36.1k
  NEXT;
10248
36.1k
  cur = CUR;
10249
3.34M
  while (((cur >= 'a') && (cur <= 'z')) ||
10250
259k
         ((cur >= 'A') && (cur <= 'Z')) ||
10251
240k
         ((cur >= '0') && (cur <= '9')) ||
10252
84.7k
         (cur == '.') || (cur == '_') ||
10253
3.30M
         (cur == '-')) {
10254
3.30M
      if (len + 1 >= size) {
10255
26.8k
          xmlChar *tmp;
10256
26.8k
                int newSize;
10257
10258
26.8k
                newSize = xmlGrowCapacity(size, 1, 1, maxLength);
10259
26.8k
                if (newSize < 0) {
10260
48
                    xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "EncName");
10261
48
                    xmlFree(buf);
10262
48
                    return(NULL);
10263
48
                }
10264
26.7k
    tmp = xmlRealloc(buf, newSize);
10265
26.7k
    if (tmp == NULL) {
10266
5
        xmlErrMemory(ctxt);
10267
5
        xmlFree(buf);
10268
5
        return(NULL);
10269
5
    }
10270
26.7k
    buf = tmp;
10271
26.7k
                size = newSize;
10272
26.7k
      }
10273
3.30M
      buf[len++] = cur;
10274
3.30M
      NEXT;
10275
3.30M
      cur = CUR;
10276
3.30M
        }
10277
36.1k
  buf[len] = 0;
10278
36.1k
    } else {
10279
69
  xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
10280
69
    }
10281
36.2k
    return(buf);
10282
36.2k
}
10283
10284
/**
10285
 * xmlParseEncodingDecl:
10286
 * @ctxt:  an XML parser context
10287
 *
10288
 * DEPRECATED: Internal function, don't use.
10289
 *
10290
 * parse the XML encoding declaration
10291
 *
10292
 * [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' |  "'" EncName "'")
10293
 *
10294
 * this setups the conversion filters.
10295
 *
10296
 * Returns the encoding value or NULL
10297
 */
10298
10299
const xmlChar *
10300
52.4k
xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
10301
52.4k
    xmlChar *encoding = NULL;
10302
10303
52.4k
    SKIP_BLANKS;
10304
52.4k
    if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g') == 0)
10305
15.9k
        return(NULL);
10306
10307
36.4k
    SKIP(8);
10308
36.4k
    SKIP_BLANKS;
10309
36.4k
    if (RAW != '=') {
10310
155
        xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10311
155
        return(NULL);
10312
155
    }
10313
36.2k
    NEXT;
10314
36.2k
    SKIP_BLANKS;
10315
36.2k
    if (RAW == '"') {
10316
35.7k
        NEXT;
10317
35.7k
        encoding = xmlParseEncName(ctxt);
10318
35.7k
        if (RAW != '"') {
10319
1.00k
            xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10320
1.00k
            xmlFree((xmlChar *) encoding);
10321
1.00k
            return(NULL);
10322
1.00k
        } else
10323
34.7k
            NEXT;
10324
35.7k
    } else if (RAW == '\''){
10325
492
        NEXT;
10326
492
        encoding = xmlParseEncName(ctxt);
10327
492
        if (RAW != '\'') {
10328
249
            xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10329
249
            xmlFree((xmlChar *) encoding);
10330
249
            return(NULL);
10331
249
        } else
10332
243
            NEXT;
10333
492
    } else {
10334
11
        xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10335
11
    }
10336
10337
35.0k
    if (encoding == NULL)
10338
29
        return(NULL);
10339
10340
34.9k
    xmlSetDeclaredEncoding(ctxt, encoding);
10341
10342
34.9k
    return(ctxt->encoding);
10343
35.0k
}
10344
10345
/**
10346
 * xmlParseSDDecl:
10347
 * @ctxt:  an XML parser context
10348
 *
10349
 * DEPRECATED: Internal function, don't use.
10350
 *
10351
 * parse the XML standalone declaration
10352
 *
10353
 * [32] SDDecl ::= S 'standalone' Eq
10354
 *                 (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no')'"'))
10355
 *
10356
 * [ VC: Standalone Document Declaration ]
10357
 * TODO The standalone document declaration must have the value "no"
10358
 * if any external markup declarations contain declarations of:
10359
 *  - attributes with default values, if elements to which these
10360
 *    attributes apply appear in the document without specifications
10361
 *    of values for these attributes, or
10362
 *  - entities (other than amp, lt, gt, apos, quot), if references
10363
 *    to those entities appear in the document, or
10364
 *  - attributes with values subject to normalization, where the
10365
 *    attribute appears in the document with a value which will change
10366
 *    as a result of normalization, or
10367
 *  - element types with element content, if white space occurs directly
10368
 *    within any instance of those types.
10369
 *
10370
 * Returns:
10371
 *   1 if standalone="yes"
10372
 *   0 if standalone="no"
10373
 *  -2 if standalone attribute is missing or invalid
10374
 *    (A standalone value of -2 means that the XML declaration was found,
10375
 *     but no value was specified for the standalone attribute).
10376
 */
10377
10378
int
10379
17.0k
xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
10380
17.0k
    int standalone = -2;
10381
10382
17.0k
    SKIP_BLANKS;
10383
17.0k
    if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) {
10384
4.79k
  SKIP(10);
10385
4.79k
        SKIP_BLANKS;
10386
4.79k
  if (RAW != '=') {
10387
26
      xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10388
26
      return(standalone);
10389
26
        }
10390
4.77k
  NEXT;
10391
4.77k
  SKIP_BLANKS;
10392
4.77k
        if (RAW == '\''){
10393
1.88k
      NEXT;
10394
1.88k
      if ((RAW == 'n') && (NXT(1) == 'o')) {
10395
634
          standalone = 0;
10396
634
                SKIP(2);
10397
1.25k
      } else if ((RAW == 'y') && (NXT(1) == 'e') &&
10398
702
                 (NXT(2) == 's')) {
10399
514
          standalone = 1;
10400
514
    SKIP(3);
10401
741
            } else {
10402
741
    xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10403
741
      }
10404
1.88k
      if (RAW != '\'') {
10405
1.57k
    xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10406
1.57k
      } else
10407
311
          NEXT;
10408
2.88k
  } else if (RAW == '"'){
10409
2.81k
      NEXT;
10410
2.81k
      if ((RAW == 'n') && (NXT(1) == 'o')) {
10411
1.81k
          standalone = 0;
10412
1.81k
    SKIP(2);
10413
1.81k
      } else if ((RAW == 'y') && (NXT(1) == 'e') &&
10414
675
                 (NXT(2) == 's')) {
10415
532
          standalone = 1;
10416
532
                SKIP(3);
10417
532
            } else {
10418
471
    xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10419
471
      }
10420
2.81k
      if (RAW != '"') {
10421
706
    xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10422
706
      } else
10423
2.11k
          NEXT;
10424
2.81k
  } else {
10425
65
      xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10426
65
        }
10427
4.77k
    }
10428
17.0k
    return(standalone);
10429
17.0k
}
10430
10431
/**
10432
 * xmlParseXMLDecl:
10433
 * @ctxt:  an XML parser context
10434
 *
10435
 * DEPRECATED: Internal function, don't use.
10436
 *
10437
 * parse an XML declaration header
10438
 *
10439
 * [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
10440
 */
10441
10442
void
10443
55.5k
xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
10444
55.5k
    xmlChar *version;
10445
10446
    /*
10447
     * This value for standalone indicates that the document has an
10448
     * XML declaration but it does not have a standalone attribute.
10449
     * It will be overwritten later if a standalone attribute is found.
10450
     */
10451
10452
55.5k
    ctxt->standalone = -2;
10453
10454
    /*
10455
     * We know that '<?xml' is here.
10456
     */
10457
55.5k
    SKIP(5);
10458
10459
55.5k
    if (!IS_BLANK_CH(RAW)) {
10460
0
  xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
10461
0
                 "Blank needed after '<?xml'\n");
10462
0
    }
10463
55.5k
    SKIP_BLANKS;
10464
10465
    /*
10466
     * We must have the VersionInfo here.
10467
     */
10468
55.5k
    version = xmlParseVersionInfo(ctxt);
10469
55.5k
    if (version == NULL) {
10470
7.86k
  xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
10471
47.7k
    } else {
10472
47.7k
  if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) {
10473
      /*
10474
       * Changed here for XML-1.0 5th edition
10475
       */
10476
20.5k
      if (ctxt->options & XML_PARSE_OLD10) {
10477
0
    xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10478
0
                "Unsupported version '%s'\n",
10479
0
                version);
10480
20.5k
      } else {
10481
20.5k
          if ((version[0] == '1') && ((version[1] == '.'))) {
10482
18.6k
        xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
10483
18.6k
                      "Unsupported version '%s'\n",
10484
18.6k
          version, NULL);
10485
18.6k
    } else {
10486
1.83k
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10487
1.83k
              "Unsupported version '%s'\n",
10488
1.83k
              version);
10489
1.83k
    }
10490
20.5k
      }
10491
20.5k
  }
10492
47.7k
  if (ctxt->version != NULL)
10493
0
      xmlFree((void *) ctxt->version);
10494
47.7k
  ctxt->version = version;
10495
47.7k
    }
10496
10497
    /*
10498
     * We may have the encoding declaration
10499
     */
10500
55.5k
    if (!IS_BLANK_CH(RAW)) {
10501
17.9k
        if ((RAW == '?') && (NXT(1) == '>')) {
10502
10.0k
      SKIP(2);
10503
10.0k
      return;
10504
10.0k
  }
10505
7.92k
  xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10506
7.92k
    }
10507
45.5k
    xmlParseEncodingDecl(ctxt);
10508
10509
    /*
10510
     * We may have the standalone status.
10511
     */
10512
45.5k
    if ((ctxt->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
10513
29.1k
        if ((RAW == '?') && (NXT(1) == '>')) {
10514
28.5k
      SKIP(2);
10515
28.5k
      return;
10516
28.5k
  }
10517
616
  xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10518
616
    }
10519
10520
    /*
10521
     * We can grow the input buffer freely at that point
10522
     */
10523
17.0k
    GROW;
10524
10525
17.0k
    SKIP_BLANKS;
10526
17.0k
    ctxt->standalone = xmlParseSDDecl(ctxt);
10527
10528
17.0k
    SKIP_BLANKS;
10529
17.0k
    if ((RAW == '?') && (NXT(1) == '>')) {
10530
3.73k
        SKIP(2);
10531
13.2k
    } else if (RAW == '>') {
10532
        /* Deprecated old WD ... */
10533
326
  xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10534
326
  NEXT;
10535
12.9k
    } else {
10536
12.9k
        int c;
10537
10538
12.9k
  xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10539
668k
        while ((PARSER_STOPPED(ctxt) == 0) &&
10540
668k
               ((c = CUR) != 0)) {
10541
664k
            NEXT;
10542
664k
            if (c == '>')
10543
8.36k
                break;
10544
664k
        }
10545
12.9k
    }
10546
17.0k
}
10547
10548
/**
10549
 * xmlCtxtGetVersion:
10550
 * @ctxt:  parser context
10551
 *
10552
 * Available since 2.14.0.
10553
 *
10554
 * Returns the version from the XML declaration.
10555
 */
10556
const xmlChar *
10557
0
xmlCtxtGetVersion(xmlParserCtxtPtr ctxt) {
10558
0
    if (ctxt == NULL)
10559
0
        return(NULL);
10560
10561
0
    return(ctxt->version);
10562
0
}
10563
10564
/**
10565
 * xmlCtxtGetStandalone:
10566
 * @ctxt:  parser context
10567
 *
10568
 * Available since 2.14.0.
10569
 *
10570
 * Returns the value from the standalone document declaration.
10571
 */
10572
int
10573
0
xmlCtxtGetStandalone(xmlParserCtxtPtr ctxt) {
10574
0
    if (ctxt == NULL)
10575
0
        return(0);
10576
10577
0
    return(ctxt->standalone);
10578
0
}
10579
10580
/**
10581
 * xmlParseMisc:
10582
 * @ctxt:  an XML parser context
10583
 *
10584
 * DEPRECATED: Internal function, don't use.
10585
 *
10586
 * parse an XML Misc* optional field.
10587
 *
10588
 * [27] Misc ::= Comment | PI |  S
10589
 */
10590
10591
void
10592
536k
xmlParseMisc(xmlParserCtxtPtr ctxt) {
10593
568k
    while (PARSER_STOPPED(ctxt) == 0) {
10594
551k
        SKIP_BLANKS;
10595
551k
        GROW;
10596
551k
        if ((RAW == '<') && (NXT(1) == '?')) {
10597
24.6k
      xmlParsePI(ctxt);
10598
526k
        } else if (CMP4(CUR_PTR, '<', '!', '-', '-')) {
10599
7.58k
      xmlParseComment(ctxt);
10600
518k
        } else {
10601
518k
            break;
10602
518k
        }
10603
551k
    }
10604
536k
}
10605
10606
static void
10607
266k
xmlFinishDocument(xmlParserCtxtPtr ctxt) {
10608
266k
    xmlDocPtr doc;
10609
10610
    /*
10611
     * SAX: end of the document processing.
10612
     */
10613
266k
    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10614
266k
        ctxt->sax->endDocument(ctxt->userData);
10615
10616
266k
    doc = ctxt->myDoc;
10617
266k
    if (doc != NULL) {
10618
255k
        if (ctxt->wellFormed) {
10619
177k
            doc->properties |= XML_DOC_WELLFORMED;
10620
177k
            if (ctxt->valid)
10621
177k
                doc->properties |= XML_DOC_DTDVALID;
10622
177k
            if (ctxt->nsWellFormed)
10623
131k
                doc->properties |= XML_DOC_NSVALID;
10624
177k
        }
10625
10626
255k
        if (ctxt->options & XML_PARSE_OLD10)
10627
0
            doc->properties |= XML_DOC_OLD10;
10628
10629
        /*
10630
         * Remove locally kept entity definitions if the tree was not built
10631
         */
10632
255k
  if (xmlStrEqual(doc->version, SAX_COMPAT_MODE)) {
10633
4.40k
            xmlFreeDoc(doc);
10634
4.40k
            ctxt->myDoc = NULL;
10635
4.40k
        }
10636
255k
    }
10637
266k
}
10638
10639
/**
10640
 * xmlParseDocument:
10641
 * @ctxt:  an XML parser context
10642
 *
10643
 * Parse an XML document and invoke the SAX handlers. This is useful
10644
 * if you're only interested in custom SAX callbacks. If you want a
10645
 * document tree, use xmlCtxtParseDocument.
10646
 *
10647
 * Returns 0, -1 in case of error.
10648
 */
10649
10650
int
10651
267k
xmlParseDocument(xmlParserCtxtPtr ctxt) {
10652
267k
    if ((ctxt == NULL) || (ctxt->input == NULL))
10653
0
        return(-1);
10654
10655
267k
    GROW;
10656
10657
    /*
10658
     * SAX: detecting the level.
10659
     */
10660
267k
    xmlCtxtInitializeLate(ctxt);
10661
10662
267k
    if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) {
10663
267k
        ctxt->sax->setDocumentLocator(ctxt->userData,
10664
267k
                (xmlSAXLocator *) &xmlDefaultSAXLocator);
10665
267k
    }
10666
10667
267k
    xmlDetectEncoding(ctxt);
10668
10669
267k
    if (CUR == 0) {
10670
886
  xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10671
886
  return(-1);
10672
886
    }
10673
10674
266k
    GROW;
10675
266k
    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
10676
10677
  /*
10678
   * Note that we will switch encoding on the fly.
10679
   */
10680
55.5k
  xmlParseXMLDecl(ctxt);
10681
55.5k
  SKIP_BLANKS;
10682
211k
    } else {
10683
211k
  ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10684
211k
        if (ctxt->version == NULL) {
10685
21
            xmlErrMemory(ctxt);
10686
21
            return(-1);
10687
21
        }
10688
211k
    }
10689
266k
    if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10690
251k
        ctxt->sax->startDocument(ctxt->userData);
10691
266k
    if ((ctxt->myDoc != NULL) && (ctxt->input != NULL) &&
10692
251k
        (ctxt->input->buf != NULL) && (ctxt->input->buf->compressed >= 0)) {
10693
0
  ctxt->myDoc->compression = ctxt->input->buf->compressed;
10694
0
    }
10695
10696
    /*
10697
     * The Misc part of the Prolog
10698
     */
10699
266k
    xmlParseMisc(ctxt);
10700
10701
    /*
10702
     * Then possibly doc type declaration(s) and more Misc
10703
     * (doctypedecl Misc*)?
10704
     */
10705
266k
    GROW;
10706
266k
    if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) {
10707
10708
57.1k
  ctxt->inSubset = 1;
10709
57.1k
  xmlParseDocTypeDecl(ctxt);
10710
57.1k
  if (RAW == '[') {
10711
48.3k
      xmlParseInternalSubset(ctxt);
10712
48.3k
  } else if (RAW == '>') {
10713
5.64k
            NEXT;
10714
5.64k
        }
10715
10716
  /*
10717
   * Create and update the external subset.
10718
   */
10719
57.1k
  ctxt->inSubset = 2;
10720
57.1k
  if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
10721
57.1k
      (!ctxt->disableSAX))
10722
13.9k
      ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10723
13.9k
                                ctxt->extSubSystem, ctxt->extSubURI);
10724
57.1k
  ctxt->inSubset = 0;
10725
10726
57.1k
        xmlCleanSpecialAttr(ctxt);
10727
10728
57.1k
  xmlParseMisc(ctxt);
10729
57.1k
    }
10730
10731
    /*
10732
     * Time to start parsing the tree itself
10733
     */
10734
266k
    GROW;
10735
266k
    if (RAW != '<') {
10736
54.2k
        if (ctxt->wellFormed)
10737
1.90k
            xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
10738
1.90k
                           "Start tag expected, '<' not found\n");
10739
212k
    } else {
10740
212k
  xmlParseElement(ctxt);
10741
10742
  /*
10743
   * The Misc part at the end
10744
   */
10745
212k
  xmlParseMisc(ctxt);
10746
10747
212k
        xmlParserCheckEOF(ctxt, XML_ERR_DOCUMENT_END);
10748
212k
    }
10749
10750
266k
    ctxt->instate = XML_PARSER_EOF;
10751
266k
    xmlFinishDocument(ctxt);
10752
10753
266k
    if (! ctxt->wellFormed) {
10754
89.3k
  ctxt->valid = 0;
10755
89.3k
  return(-1);
10756
89.3k
    }
10757
10758
177k
    return(0);
10759
266k
}
10760
10761
/**
10762
 * xmlParseExtParsedEnt:
10763
 * @ctxt:  an XML parser context
10764
 *
10765
 * DEPRECATED: Internal function, don't use.
10766
 *
10767
 * parse a general parsed entity
10768
 * An external general parsed entity is well-formed if it matches the
10769
 * production labeled extParsedEnt.
10770
 *
10771
 * [78] extParsedEnt ::= TextDecl? content
10772
 *
10773
 * Returns 0, -1 in case of error. the parser context is augmented
10774
 *                as a result of the parsing.
10775
 */
10776
10777
int
10778
0
xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
10779
0
    if ((ctxt == NULL) || (ctxt->input == NULL))
10780
0
        return(-1);
10781
10782
0
    xmlCtxtInitializeLate(ctxt);
10783
10784
0
    if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) {
10785
0
        ctxt->sax->setDocumentLocator(ctxt->userData,
10786
0
                (xmlSAXLocator *) &xmlDefaultSAXLocator);
10787
0
    }
10788
10789
0
    xmlDetectEncoding(ctxt);
10790
10791
0
    if (CUR == 0) {
10792
0
  xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10793
0
    }
10794
10795
    /*
10796
     * Check for the XMLDecl in the Prolog.
10797
     */
10798
0
    GROW;
10799
0
    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
10800
10801
  /*
10802
   * Note that we will switch encoding on the fly.
10803
   */
10804
0
  xmlParseXMLDecl(ctxt);
10805
0
  SKIP_BLANKS;
10806
0
    } else {
10807
0
  ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10808
0
    }
10809
0
    if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10810
0
        ctxt->sax->startDocument(ctxt->userData);
10811
10812
    /*
10813
     * Doing validity checking on chunk doesn't make sense
10814
     */
10815
0
    ctxt->options &= ~XML_PARSE_DTDVALID;
10816
0
    ctxt->validate = 0;
10817
0
    ctxt->depth = 0;
10818
10819
0
    xmlParseContentInternal(ctxt);
10820
10821
0
    if (ctxt->input->cur < ctxt->input->end)
10822
0
  xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
10823
10824
    /*
10825
     * SAX: end of the document processing.
10826
     */
10827
0
    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10828
0
        ctxt->sax->endDocument(ctxt->userData);
10829
10830
0
    if (! ctxt->wellFormed) return(-1);
10831
0
    return(0);
10832
0
}
10833
10834
#ifdef LIBXML_PUSH_ENABLED
10835
/************************************************************************
10836
 *                  *
10837
 *    Progressive parsing interfaces        *
10838
 *                  *
10839
 ************************************************************************/
10840
10841
/**
10842
 * xmlParseLookupChar:
10843
 * @ctxt:  an XML parser context
10844
 * @c:  character
10845
 *
10846
 * Check whether the input buffer contains a character.
10847
 */
10848
static int
10849
xmlParseLookupChar(xmlParserCtxtPtr ctxt, int c) {
10850
    const xmlChar *cur;
10851
10852
    if (ctxt->checkIndex == 0) {
10853
        cur = ctxt->input->cur + 1;
10854
    } else {
10855
        cur = ctxt->input->cur + ctxt->checkIndex;
10856
    }
10857
10858
    if (memchr(cur, c, ctxt->input->end - cur) == NULL) {
10859
        size_t index = ctxt->input->end - ctxt->input->cur;
10860
10861
        if (index > LONG_MAX) {
10862
            ctxt->checkIndex = 0;
10863
            return(1);
10864
        }
10865
        ctxt->checkIndex = index;
10866
        return(0);
10867
    } else {
10868
        ctxt->checkIndex = 0;
10869
        return(1);
10870
    }
10871
}
10872
10873
/**
10874
 * xmlParseLookupString:
10875
 * @ctxt:  an XML parser context
10876
 * @startDelta: delta to apply at the start
10877
 * @str:  string
10878
 * @strLen:  length of string
10879
 *
10880
 * Check whether the input buffer contains a string.
10881
 */
10882
static const xmlChar *
10883
xmlParseLookupString(xmlParserCtxtPtr ctxt, size_t startDelta,
10884
                     const char *str, size_t strLen) {
10885
    const xmlChar *cur, *term;
10886
10887
    if (ctxt->checkIndex == 0) {
10888
        cur = ctxt->input->cur + startDelta;
10889
    } else {
10890
        cur = ctxt->input->cur + ctxt->checkIndex;
10891
    }
10892
10893
    term = BAD_CAST strstr((const char *) cur, str);
10894
    if (term == NULL) {
10895
        const xmlChar *end = ctxt->input->end;
10896
        size_t index;
10897
10898
        /* Rescan (strLen - 1) characters. */
10899
        if ((size_t) (end - cur) < strLen)
10900
            end = cur;
10901
        else
10902
            end -= strLen - 1;
10903
        index = end - ctxt->input->cur;
10904
        if (index > LONG_MAX) {
10905
            ctxt->checkIndex = 0;
10906
            return(ctxt->input->end - strLen);
10907
        }
10908
        ctxt->checkIndex = index;
10909
    } else {
10910
        ctxt->checkIndex = 0;
10911
    }
10912
10913
    return(term);
10914
}
10915
10916
/**
10917
 * xmlParseLookupCharData:
10918
 * @ctxt:  an XML parser context
10919
 *
10920
 * Check whether the input buffer contains terminated char data.
10921
 */
10922
static int
10923
xmlParseLookupCharData(xmlParserCtxtPtr ctxt) {
10924
    const xmlChar *cur = ctxt->input->cur + ctxt->checkIndex;
10925
    const xmlChar *end = ctxt->input->end;
10926
    size_t index;
10927
10928
    while (cur < end) {
10929
        if ((*cur == '<') || (*cur == '&')) {
10930
            ctxt->checkIndex = 0;
10931
            return(1);
10932
        }
10933
        cur++;
10934
    }
10935
10936
    index = cur - ctxt->input->cur;
10937
    if (index > LONG_MAX) {
10938
        ctxt->checkIndex = 0;
10939
        return(1);
10940
    }
10941
    ctxt->checkIndex = index;
10942
    return(0);
10943
}
10944
10945
/**
10946
 * xmlParseLookupGt:
10947
 * @ctxt:  an XML parser context
10948
 *
10949
 * Check whether there's enough data in the input buffer to finish parsing
10950
 * a start tag. This has to take quotes into account.
10951
 */
10952
static int
10953
xmlParseLookupGt(xmlParserCtxtPtr ctxt) {
10954
    const xmlChar *cur;
10955
    const xmlChar *end = ctxt->input->end;
10956
    int state = ctxt->endCheckState;
10957
    size_t index;
10958
10959
    if (ctxt->checkIndex == 0)
10960
        cur = ctxt->input->cur + 1;
10961
    else
10962
        cur = ctxt->input->cur + ctxt->checkIndex;
10963
10964
    while (cur < end) {
10965
        if (state) {
10966
            if (*cur == state)
10967
                state = 0;
10968
        } else if (*cur == '\'' || *cur == '"') {
10969
            state = *cur;
10970
        } else if (*cur == '>') {
10971
            ctxt->checkIndex = 0;
10972
            ctxt->endCheckState = 0;
10973
            return(1);
10974
        }
10975
        cur++;
10976
    }
10977
10978
    index = cur - ctxt->input->cur;
10979
    if (index > LONG_MAX) {
10980
        ctxt->checkIndex = 0;
10981
        ctxt->endCheckState = 0;
10982
        return(1);
10983
    }
10984
    ctxt->checkIndex = index;
10985
    ctxt->endCheckState = state;
10986
    return(0);
10987
}
10988
10989
/**
10990
 * xmlParseLookupInternalSubset:
10991
 * @ctxt:  an XML parser context
10992
 *
10993
 * Check whether there's enough data in the input buffer to finish parsing
10994
 * the internal subset.
10995
 */
10996
static int
10997
xmlParseLookupInternalSubset(xmlParserCtxtPtr ctxt) {
10998
    /*
10999
     * Sorry, but progressive parsing of the internal subset is not
11000
     * supported. We first check that the full content of the internal
11001
     * subset is available and parsing is launched only at that point.
11002
     * Internal subset ends with "']' S? '>'" in an unescaped section and
11003
     * not in a ']]>' sequence which are conditional sections.
11004
     */
11005
    const xmlChar *cur, *start;
11006
    const xmlChar *end = ctxt->input->end;
11007
    int state = ctxt->endCheckState;
11008
    size_t index;
11009
11010
    if (ctxt->checkIndex == 0) {
11011
        cur = ctxt->input->cur + 1;
11012
    } else {
11013
        cur = ctxt->input->cur + ctxt->checkIndex;
11014
    }
11015
    start = cur;
11016
11017
    while (cur < end) {
11018
        if (state == '-') {
11019
            if ((*cur == '-') &&
11020
                (cur[1] == '-') &&
11021
                (cur[2] == '>')) {
11022
                state = 0;
11023
                cur += 3;
11024
                start = cur;
11025
                continue;
11026
            }
11027
        }
11028
        else if (state == ']') {
11029
            if (*cur == '>') {
11030
                ctxt->checkIndex = 0;
11031
                ctxt->endCheckState = 0;
11032
                return(1);
11033
            }
11034
            if (IS_BLANK_CH(*cur)) {
11035
                state = ' ';
11036
            } else if (*cur != ']') {
11037
                state = 0;
11038
                start = cur;
11039
                continue;
11040
            }
11041
        }
11042
        else if (state == ' ') {
11043
            if (*cur == '>') {
11044
                ctxt->checkIndex = 0;
11045
                ctxt->endCheckState = 0;
11046
                return(1);
11047
            }
11048
            if (!IS_BLANK_CH(*cur)) {
11049
                state = 0;
11050
                start = cur;
11051
                continue;
11052
            }
11053
        }
11054
        else if (state != 0) {
11055
            if (*cur == state) {
11056
                state = 0;
11057
                start = cur + 1;
11058
            }
11059
        }
11060
        else if (*cur == '<') {
11061
            if ((cur[1] == '!') &&
11062
                (cur[2] == '-') &&
11063
                (cur[3] == '-')) {
11064
                state = '-';
11065
                cur += 4;
11066
                /* Don't treat <!--> as comment */
11067
                start = cur;
11068
                continue;
11069
            }
11070
        }
11071
        else if ((*cur == '"') || (*cur == '\'') || (*cur == ']')) {
11072
            state = *cur;
11073
        }
11074
11075
        cur++;
11076
    }
11077
11078
    /*
11079
     * Rescan the three last characters to detect "<!--" and "-->"
11080
     * split across chunks.
11081
     */
11082
    if ((state == 0) || (state == '-')) {
11083
        if (cur - start < 3)
11084
            cur = start;
11085
        else
11086
            cur -= 3;
11087
    }
11088
    index = cur - ctxt->input->cur;
11089
    if (index > LONG_MAX) {
11090
        ctxt->checkIndex = 0;
11091
        ctxt->endCheckState = 0;
11092
        return(1);
11093
    }
11094
    ctxt->checkIndex = index;
11095
    ctxt->endCheckState = state;
11096
    return(0);
11097
}
11098
11099
/**
11100
 * xmlParseTryOrFinish:
11101
 * @ctxt:  an XML parser context
11102
 * @terminate:  last chunk indicator
11103
 *
11104
 * Try to progress on parsing
11105
 *
11106
 * Returns zero if no parsing was possible
11107
 */
11108
static int
11109
xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
11110
    int ret = 0;
11111
    size_t avail;
11112
    xmlChar cur, next;
11113
11114
    if (ctxt->input == NULL)
11115
        return(0);
11116
11117
    if ((ctxt->input != NULL) &&
11118
        (ctxt->input->cur - ctxt->input->base > 4096)) {
11119
        xmlParserShrink(ctxt);
11120
    }
11121
11122
    while (ctxt->disableSAX == 0) {
11123
        avail = ctxt->input->end - ctxt->input->cur;
11124
        if (avail < 1)
11125
      goto done;
11126
        switch (ctxt->instate) {
11127
            case XML_PARSER_EOF:
11128
          /*
11129
     * Document parsing is done !
11130
     */
11131
          goto done;
11132
            case XML_PARSER_START:
11133
                /*
11134
                 * Very first chars read from the document flow.
11135
                 */
11136
                if ((!terminate) && (avail < 4))
11137
                    goto done;
11138
11139
                /*
11140
                 * We need more bytes to detect EBCDIC code pages.
11141
                 * See xmlDetectEBCDIC.
11142
                 */
11143
                if ((CMP4(CUR_PTR, 0x4C, 0x6F, 0xA7, 0x94)) &&
11144
                    (!terminate) && (avail < 200))
11145
                    goto done;
11146
11147
                xmlDetectEncoding(ctxt);
11148
                ctxt->instate = XML_PARSER_XML_DECL;
11149
    break;
11150
11151
            case XML_PARSER_XML_DECL:
11152
    if ((!terminate) && (avail < 2))
11153
        goto done;
11154
    cur = ctxt->input->cur[0];
11155
    next = ctxt->input->cur[1];
11156
          if ((cur == '<') && (next == '?')) {
11157
        /* PI or XML decl */
11158
        if ((!terminate) &&
11159
                        (!xmlParseLookupString(ctxt, 2, "?>", 2)))
11160
      goto done;
11161
        if ((ctxt->input->cur[2] == 'x') &&
11162
      (ctxt->input->cur[3] == 'm') &&
11163
      (ctxt->input->cur[4] == 'l') &&
11164
      (IS_BLANK_CH(ctxt->input->cur[5]))) {
11165
      ret += 5;
11166
      xmlParseXMLDecl(ctxt);
11167
        } else {
11168
      ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11169
                        if (ctxt->version == NULL) {
11170
                            xmlErrMemory(ctxt);
11171
                            break;
11172
                        }
11173
        }
11174
    } else {
11175
        ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11176
        if (ctxt->version == NULL) {
11177
            xmlErrMemory(ctxt);
11178
      break;
11179
        }
11180
    }
11181
                if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) {
11182
                    ctxt->sax->setDocumentLocator(ctxt->userData,
11183
                            (xmlSAXLocator *) &xmlDefaultSAXLocator);
11184
                }
11185
                if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11186
                    (!ctxt->disableSAX))
11187
                    ctxt->sax->startDocument(ctxt->userData);
11188
                ctxt->instate = XML_PARSER_MISC;
11189
    break;
11190
            case XML_PARSER_START_TAG: {
11191
          const xmlChar *name;
11192
    const xmlChar *prefix = NULL;
11193
    const xmlChar *URI = NULL;
11194
                int line = ctxt->input->line;
11195
    int nbNs = 0;
11196
11197
    if ((!terminate) && (avail < 2))
11198
        goto done;
11199
    cur = ctxt->input->cur[0];
11200
          if (cur != '<') {
11201
        xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
11202
                                   "Start tag expected, '<' not found");
11203
                    ctxt->instate = XML_PARSER_EOF;
11204
                    xmlFinishDocument(ctxt);
11205
        goto done;
11206
    }
11207
    if ((!terminate) && (!xmlParseLookupGt(ctxt)))
11208
                    goto done;
11209
    if (ctxt->spaceNr == 0)
11210
        spacePush(ctxt, -1);
11211
    else if (*ctxt->space == -2)
11212
        spacePush(ctxt, -1);
11213
    else
11214
        spacePush(ctxt, *ctxt->space);
11215
#ifdef LIBXML_SAX1_ENABLED
11216
    if (ctxt->sax2)
11217
#endif /* LIBXML_SAX1_ENABLED */
11218
        name = xmlParseStartTag2(ctxt, &prefix, &URI, &nbNs);
11219
#ifdef LIBXML_SAX1_ENABLED
11220
    else
11221
        name = xmlParseStartTag(ctxt);
11222
#endif /* LIBXML_SAX1_ENABLED */
11223
    if (name == NULL) {
11224
        spacePop(ctxt);
11225
                    ctxt->instate = XML_PARSER_EOF;
11226
                    xmlFinishDocument(ctxt);
11227
        goto done;
11228
    }
11229
#ifdef LIBXML_VALID_ENABLED
11230
    /*
11231
     * [ VC: Root Element Type ]
11232
     * The Name in the document type declaration must match
11233
     * the element type of the root element.
11234
     */
11235
    if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
11236
        ctxt->node && (ctxt->node == ctxt->myDoc->children))
11237
        ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
11238
#endif /* LIBXML_VALID_ENABLED */
11239
11240
    /*
11241
     * Check for an Empty Element.
11242
     */
11243
    if ((RAW == '/') && (NXT(1) == '>')) {
11244
        SKIP(2);
11245
11246
        if (ctxt->sax2) {
11247
      if ((ctxt->sax != NULL) &&
11248
          (ctxt->sax->endElementNs != NULL) &&
11249
          (!ctxt->disableSAX))
11250
          ctxt->sax->endElementNs(ctxt->userData, name,
11251
                                  prefix, URI);
11252
      if (nbNs > 0)
11253
          xmlParserNsPop(ctxt, nbNs);
11254
#ifdef LIBXML_SAX1_ENABLED
11255
        } else {
11256
      if ((ctxt->sax != NULL) &&
11257
          (ctxt->sax->endElement != NULL) &&
11258
          (!ctxt->disableSAX))
11259
          ctxt->sax->endElement(ctxt->userData, name);
11260
#endif /* LIBXML_SAX1_ENABLED */
11261
        }
11262
        spacePop(ctxt);
11263
    } else if (RAW == '>') {
11264
        NEXT;
11265
                    nameNsPush(ctxt, name, prefix, URI, line, nbNs);
11266
    } else {
11267
        xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
11268
           "Couldn't find end of Start Tag %s\n",
11269
           name);
11270
        nodePop(ctxt);
11271
        spacePop(ctxt);
11272
                    if (nbNs > 0)
11273
                        xmlParserNsPop(ctxt, nbNs);
11274
    }
11275
11276
                if (ctxt->nameNr == 0)
11277
                    ctxt->instate = XML_PARSER_EPILOG;
11278
                else
11279
                    ctxt->instate = XML_PARSER_CONTENT;
11280
                break;
11281
      }
11282
            case XML_PARSER_CONTENT: {
11283
    cur = ctxt->input->cur[0];
11284
11285
    if (cur == '<') {
11286
                    if ((!terminate) && (avail < 2))
11287
                        goto done;
11288
        next = ctxt->input->cur[1];
11289
11290
                    if (next == '/') {
11291
                        ctxt->instate = XML_PARSER_END_TAG;
11292
                        break;
11293
                    } else if (next == '?') {
11294
                        if ((!terminate) &&
11295
                            (!xmlParseLookupString(ctxt, 2, "?>", 2)))
11296
                            goto done;
11297
                        xmlParsePI(ctxt);
11298
                        ctxt->instate = XML_PARSER_CONTENT;
11299
                        break;
11300
                    } else if (next == '!') {
11301
                        if ((!terminate) && (avail < 3))
11302
                            goto done;
11303
                        next = ctxt->input->cur[2];
11304
11305
                        if (next == '-') {
11306
                            if ((!terminate) && (avail < 4))
11307
                                goto done;
11308
                            if (ctxt->input->cur[3] == '-') {
11309
                                if ((!terminate) &&
11310
                                    (!xmlParseLookupString(ctxt, 4, "-->", 3)))
11311
                                    goto done;
11312
                                xmlParseComment(ctxt);
11313
                                ctxt->instate = XML_PARSER_CONTENT;
11314
                                break;
11315
                            }
11316
                        } else if (next == '[') {
11317
                            if ((!terminate) && (avail < 9))
11318
                                goto done;
11319
                            if ((ctxt->input->cur[2] == '[') &&
11320
                                (ctxt->input->cur[3] == 'C') &&
11321
                                (ctxt->input->cur[4] == 'D') &&
11322
                                (ctxt->input->cur[5] == 'A') &&
11323
                                (ctxt->input->cur[6] == 'T') &&
11324
                                (ctxt->input->cur[7] == 'A') &&
11325
                                (ctxt->input->cur[8] == '[')) {
11326
                                if ((!terminate) &&
11327
                                    (!xmlParseLookupString(ctxt, 9, "]]>", 3)))
11328
                                    goto done;
11329
                                ctxt->instate = XML_PARSER_CDATA_SECTION;
11330
                                xmlParseCDSect(ctxt);
11331
                                ctxt->instate = XML_PARSER_CONTENT;
11332
                                break;
11333
                            }
11334
                        }
11335
                    }
11336
    } else if (cur == '&') {
11337
        if ((!terminate) && (!xmlParseLookupChar(ctxt, ';')))
11338
      goto done;
11339
        xmlParseReference(ctxt);
11340
                    break;
11341
    } else {
11342
        /* TODO Avoid the extra copy, handle directly !!! */
11343
        /*
11344
         * Goal of the following test is:
11345
         *  - minimize calls to the SAX 'character' callback
11346
         *    when they are mergeable
11347
         *  - handle an problem for isBlank when we only parse
11348
         *    a sequence of blank chars and the next one is
11349
         *    not available to check against '<' presence.
11350
         *  - tries to homogenize the differences in SAX
11351
         *    callbacks between the push and pull versions
11352
         *    of the parser.
11353
         */
11354
        if (avail < XML_PARSER_BIG_BUFFER_SIZE) {
11355
      if ((!terminate) && (!xmlParseLookupCharData(ctxt)))
11356
          goto done;
11357
                    }
11358
                    ctxt->checkIndex = 0;
11359
        xmlParseCharDataInternal(ctxt, !terminate);
11360
                    break;
11361
    }
11362
11363
                ctxt->instate = XML_PARSER_START_TAG;
11364
    break;
11365
      }
11366
            case XML_PARSER_END_TAG:
11367
    if ((!terminate) && (!xmlParseLookupChar(ctxt, '>')))
11368
        goto done;
11369
    if (ctxt->sax2) {
11370
              xmlParseEndTag2(ctxt, &ctxt->pushTab[ctxt->nameNr - 1]);
11371
        nameNsPop(ctxt);
11372
    }
11373
#ifdef LIBXML_SAX1_ENABLED
11374
      else
11375
        xmlParseEndTag1(ctxt, 0);
11376
#endif /* LIBXML_SAX1_ENABLED */
11377
    if (ctxt->nameNr == 0) {
11378
        ctxt->instate = XML_PARSER_EPILOG;
11379
    } else {
11380
        ctxt->instate = XML_PARSER_CONTENT;
11381
    }
11382
    break;
11383
            case XML_PARSER_MISC:
11384
            case XML_PARSER_PROLOG:
11385
            case XML_PARSER_EPILOG:
11386
    SKIP_BLANKS;
11387
                avail = ctxt->input->end - ctxt->input->cur;
11388
    if (avail < 1)
11389
        goto done;
11390
    if (ctxt->input->cur[0] == '<') {
11391
                    if ((!terminate) && (avail < 2))
11392
                        goto done;
11393
                    next = ctxt->input->cur[1];
11394
                    if (next == '?') {
11395
                        if ((!terminate) &&
11396
                            (!xmlParseLookupString(ctxt, 2, "?>", 2)))
11397
                            goto done;
11398
                        xmlParsePI(ctxt);
11399
                        break;
11400
                    } else if (next == '!') {
11401
                        if ((!terminate) && (avail < 3))
11402
                            goto done;
11403
11404
                        if (ctxt->input->cur[2] == '-') {
11405
                            if ((!terminate) && (avail < 4))
11406
                                goto done;
11407
                            if (ctxt->input->cur[3] == '-') {
11408
                                if ((!terminate) &&
11409
                                    (!xmlParseLookupString(ctxt, 4, "-->", 3)))
11410
                                    goto done;
11411
                                xmlParseComment(ctxt);
11412
                                break;
11413
                            }
11414
                        } else if (ctxt->instate == XML_PARSER_MISC) {
11415
                            if ((!terminate) && (avail < 9))
11416
                                goto done;
11417
                            if ((ctxt->input->cur[2] == 'D') &&
11418
                                (ctxt->input->cur[3] == 'O') &&
11419
                                (ctxt->input->cur[4] == 'C') &&
11420
                                (ctxt->input->cur[5] == 'T') &&
11421
                                (ctxt->input->cur[6] == 'Y') &&
11422
                                (ctxt->input->cur[7] == 'P') &&
11423
                                (ctxt->input->cur[8] == 'E')) {
11424
                                if ((!terminate) && (!xmlParseLookupGt(ctxt)))
11425
                                    goto done;
11426
                                ctxt->inSubset = 1;
11427
                                xmlParseDocTypeDecl(ctxt);
11428
                                if (RAW == '[') {
11429
                                    ctxt->instate = XML_PARSER_DTD;
11430
                                } else {
11431
                                    if (RAW == '>')
11432
                                        NEXT;
11433
                                    /*
11434
                                     * Create and update the external subset.
11435
                                     */
11436
                                    ctxt->inSubset = 2;
11437
                                    if ((ctxt->sax != NULL) &&
11438
                                        (!ctxt->disableSAX) &&
11439
                                        (ctxt->sax->externalSubset != NULL))
11440
                                        ctxt->sax->externalSubset(
11441
                                                ctxt->userData,
11442
                                                ctxt->intSubName,
11443
                                                ctxt->extSubSystem,
11444
                                                ctxt->extSubURI);
11445
                                    ctxt->inSubset = 0;
11446
                                    xmlCleanSpecialAttr(ctxt);
11447
                                    ctxt->instate = XML_PARSER_PROLOG;
11448
                                }
11449
                                break;
11450
                            }
11451
                        }
11452
                    }
11453
                }
11454
11455
                if (ctxt->instate == XML_PARSER_EPILOG) {
11456
                    if (ctxt->errNo == XML_ERR_OK)
11457
                        xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
11458
        ctxt->instate = XML_PARSER_EOF;
11459
                    xmlFinishDocument(ctxt);
11460
                } else {
11461
        ctxt->instate = XML_PARSER_START_TAG;
11462
    }
11463
    break;
11464
            case XML_PARSER_DTD: {
11465
                if ((!terminate) && (!xmlParseLookupInternalSubset(ctxt)))
11466
                    goto done;
11467
    xmlParseInternalSubset(ctxt);
11468
    ctxt->inSubset = 2;
11469
    if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11470
        (ctxt->sax->externalSubset != NULL))
11471
        ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
11472
          ctxt->extSubSystem, ctxt->extSubURI);
11473
    ctxt->inSubset = 0;
11474
    xmlCleanSpecialAttr(ctxt);
11475
    ctxt->instate = XML_PARSER_PROLOG;
11476
                break;
11477
      }
11478
            default:
11479
                xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
11480
      "PP: internal error\n");
11481
    ctxt->instate = XML_PARSER_EOF;
11482
    break;
11483
  }
11484
    }
11485
done:
11486
    return(ret);
11487
}
11488
11489
/**
11490
 * xmlParseChunk:
11491
 * @ctxt:  an XML parser context
11492
 * @chunk:  chunk of memory
11493
 * @size:  size of chunk in bytes
11494
 * @terminate:  last chunk indicator
11495
 *
11496
 * Parse a chunk of memory in push parser mode.
11497
 *
11498
 * Assumes that the parser context was initialized with
11499
 * xmlCreatePushParserCtxt.
11500
 *
11501
 * The last chunk, which will often be empty, must be marked with
11502
 * the @terminate flag. With the default SAX callbacks, the resulting
11503
 * document will be available in ctxt->myDoc. This pointer will not
11504
 * be freed when calling xmlFreeParserCtxt and must be freed by the
11505
 * caller. If the document isn't well-formed, it will still be returned
11506
 * in ctxt->myDoc.
11507
 *
11508
 * As an exception, xmlCtxtResetPush will free the document in
11509
 * ctxt->myDoc. So ctxt->myDoc should be set to NULL after extracting
11510
 * the document.
11511
 *
11512
 * Returns an xmlParserErrors code (0 on success).
11513
 */
11514
int
11515
xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
11516
              int terminate) {
11517
    size_t curBase;
11518
    size_t maxLength;
11519
    size_t pos;
11520
    int end_in_lf = 0;
11521
    int res;
11522
11523
    if ((ctxt == NULL) || (size < 0))
11524
        return(XML_ERR_ARGUMENT);
11525
    if ((chunk == NULL) && (size > 0))
11526
        return(XML_ERR_ARGUMENT);
11527
    if ((ctxt->input == NULL) || (ctxt->input->buf == NULL))
11528
        return(XML_ERR_ARGUMENT);
11529
    if (ctxt->disableSAX != 0)
11530
        return(ctxt->errNo);
11531
11532
    ctxt->input->flags |= XML_INPUT_PROGRESSIVE;
11533
    if (ctxt->instate == XML_PARSER_START)
11534
        xmlCtxtInitializeLate(ctxt);
11535
    if ((size > 0) && (chunk != NULL) && (!terminate) &&
11536
        (chunk[size - 1] == '\r')) {
11537
  end_in_lf = 1;
11538
  size--;
11539
    }
11540
11541
    /*
11542
     * Also push an empty chunk to make sure that the raw buffer
11543
     * will be flushed if there is an encoder.
11544
     */
11545
    pos = ctxt->input->cur - ctxt->input->base;
11546
    res = xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
11547
    xmlBufUpdateInput(ctxt->input->buf->buffer, ctxt->input, pos);
11548
    if (res < 0) {
11549
        xmlCtxtErrIO(ctxt, ctxt->input->buf->error, NULL);
11550
        xmlHaltParser(ctxt);
11551
        return(ctxt->errNo);
11552
    }
11553
11554
    xmlParseTryOrFinish(ctxt, terminate);
11555
11556
    curBase = ctxt->input->cur - ctxt->input->base;
11557
    maxLength = (ctxt->options & XML_PARSE_HUGE) ?
11558
                XML_MAX_HUGE_LENGTH :
11559
                XML_MAX_LOOKUP_LIMIT;
11560
    if (curBase > maxLength) {
11561
        xmlFatalErr(ctxt, XML_ERR_RESOURCE_LIMIT,
11562
                    "Buffer size limit exceeded, try XML_PARSE_HUGE\n");
11563
        xmlHaltParser(ctxt);
11564
    }
11565
11566
    if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX != 0))
11567
        return(ctxt->errNo);
11568
11569
    if (end_in_lf == 1) {
11570
  pos = ctxt->input->cur - ctxt->input->base;
11571
  res = xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
11572
  xmlBufUpdateInput(ctxt->input->buf->buffer, ctxt->input, pos);
11573
        if (res < 0) {
11574
            xmlCtxtErrIO(ctxt, ctxt->input->buf->error, NULL);
11575
            xmlHaltParser(ctxt);
11576
            return(ctxt->errNo);
11577
        }
11578
    }
11579
    if (terminate) {
11580
  /*
11581
   * Check for termination
11582
   */
11583
        if ((ctxt->instate != XML_PARSER_EOF) &&
11584
            (ctxt->instate != XML_PARSER_EPILOG)) {
11585
            if (ctxt->nameNr > 0) {
11586
                const xmlChar *name = ctxt->nameTab[ctxt->nameNr - 1];
11587
                int line = ctxt->pushTab[ctxt->nameNr - 1].line;
11588
                xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
11589
                        "Premature end of data in tag %s line %d\n",
11590
                        name, line, NULL);
11591
            } else if (ctxt->instate == XML_PARSER_START) {
11592
                xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11593
            } else {
11594
                xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
11595
                               "Start tag expected, '<' not found\n");
11596
            }
11597
        } else {
11598
            xmlParserCheckEOF(ctxt, XML_ERR_DOCUMENT_END);
11599
        }
11600
  if (ctxt->instate != XML_PARSER_EOF) {
11601
            ctxt->instate = XML_PARSER_EOF;
11602
            xmlFinishDocument(ctxt);
11603
  }
11604
    }
11605
    if (ctxt->wellFormed == 0)
11606
  return((xmlParserErrors) ctxt->errNo);
11607
    else
11608
        return(0);
11609
}
11610
11611
/************************************************************************
11612
 *                  *
11613
 *    I/O front end functions to the parser     *
11614
 *                  *
11615
 ************************************************************************/
11616
11617
/**
11618
 * xmlCreatePushParserCtxt:
11619
 * @sax:  a SAX handler (optional)
11620
 * @user_data:  user data for SAX callbacks (optional)
11621
 * @chunk:  initial chunk (optional, deprecated)
11622
 * @size:  size of initial chunk in bytes
11623
 * @filename:  file name or URI (optional)
11624
 *
11625
 * Create a parser context for using the XML parser in push mode.
11626
 * See xmlParseChunk.
11627
 *
11628
 * Passing an initial chunk is useless and deprecated.
11629
 *
11630
 * The push parser doesn't support recovery mode or the
11631
 * XML_PARSE_NOBLANKS option.
11632
 *
11633
 * @filename is used as base URI to fetch external entities and for
11634
 * error reports.
11635
 *
11636
 * Returns the new parser context or NULL if a memory allocation
11637
 * failed.
11638
 */
11639
11640
xmlParserCtxtPtr
11641
xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
11642
                        const char *chunk, int size, const char *filename) {
11643
    xmlParserCtxtPtr ctxt;
11644
    xmlParserInputPtr input;
11645
11646
    ctxt = xmlNewSAXParserCtxt(sax, user_data);
11647
    if (ctxt == NULL)
11648
  return(NULL);
11649
11650
    ctxt->options &= ~XML_PARSE_NODICT;
11651
    ctxt->dictNames = 1;
11652
11653
    input = xmlNewPushInput(filename, chunk, size);
11654
    if (input == NULL) {
11655
  xmlFreeParserCtxt(ctxt);
11656
  return(NULL);
11657
    }
11658
    if (xmlCtxtPushInput(ctxt, input) < 0) {
11659
        xmlFreeInputStream(input);
11660
        xmlFreeParserCtxt(ctxt);
11661
        return(NULL);
11662
    }
11663
11664
    return(ctxt);
11665
}
11666
#endif /* LIBXML_PUSH_ENABLED */
11667
11668
/**
11669
 * xmlStopParser:
11670
 * @ctxt:  an XML parser context
11671
 *
11672
 * Blocks further parser processing
11673
 */
11674
void
11675
8.90M
xmlStopParser(xmlParserCtxtPtr ctxt) {
11676
8.90M
    if (ctxt == NULL)
11677
8.90M
        return;
11678
0
    xmlHaltParser(ctxt);
11679
0
    if (ctxt->errNo != XML_ERR_NO_MEMORY)
11680
0
        ctxt->errNo = XML_ERR_USER_STOP;
11681
0
}
11682
11683
/**
11684
 * xmlCreateIOParserCtxt:
11685
 * @sax:  a SAX handler (optional)
11686
 * @user_data:  user data for SAX callbacks (optional)
11687
 * @ioread:  an I/O read function
11688
 * @ioclose:  an I/O close function (optional)
11689
 * @ioctx:  an I/O handler
11690
 * @enc:  the charset encoding if known (deprecated)
11691
 *
11692
 * Create a parser context for using the XML parser with an existing
11693
 * I/O stream
11694
 *
11695
 * Returns the new parser context or NULL
11696
 */
11697
xmlParserCtxtPtr
11698
xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
11699
                      xmlInputReadCallback ioread,
11700
                      xmlInputCloseCallback ioclose,
11701
0
                      void *ioctx, xmlCharEncoding enc) {
11702
0
    xmlParserCtxtPtr ctxt;
11703
0
    xmlParserInputPtr input;
11704
0
    const char *encoding;
11705
11706
0
    ctxt = xmlNewSAXParserCtxt(sax, user_data);
11707
0
    if (ctxt == NULL)
11708
0
  return(NULL);
11709
11710
0
    encoding = xmlGetCharEncodingName(enc);
11711
0
    input = xmlCtxtNewInputFromIO(ctxt, NULL, ioread, ioclose, ioctx,
11712
0
                                  encoding, 0);
11713
0
    if (input == NULL) {
11714
0
  xmlFreeParserCtxt(ctxt);
11715
0
        return (NULL);
11716
0
    }
11717
0
    if (xmlCtxtPushInput(ctxt, input) < 0) {
11718
0
        xmlFreeInputStream(input);
11719
0
        xmlFreeParserCtxt(ctxt);
11720
0
        return(NULL);
11721
0
    }
11722
11723
0
    return(ctxt);
11724
0
}
11725
11726
#ifdef LIBXML_VALID_ENABLED
11727
/************************************************************************
11728
 *                  *
11729
 *    Front ends when parsing a DTD       *
11730
 *                  *
11731
 ************************************************************************/
11732
11733
/**
11734
 * xmlCtxtParseDtd:
11735
 * @ctxt:  a parser context
11736
 * @input:  a parser input
11737
 * @publicId:  public ID of the DTD (optional)
11738
 * @systemId:  system ID of the DTD (optional)
11739
 *
11740
 * Parse a DTD.
11741
 *
11742
 * Option XML_PARSE_DTDLOAD should be enabled in the parser context
11743
 * to make external entities work.
11744
 *
11745
 * Availabe since 2.14.0.
11746
 *
11747
 * Returns the resulting xmlDtdPtr or NULL in case of error.
11748
 * @input will be freed by the function in any case.
11749
 */
11750
xmlDtdPtr
11751
xmlCtxtParseDtd(xmlParserCtxtPtr ctxt, xmlParserInputPtr input,
11752
                const xmlChar *publicId, const xmlChar *systemId) {
11753
    xmlDtdPtr ret = NULL;
11754
11755
    if ((ctxt == NULL) || (input == NULL)) {
11756
        xmlFatalErr(ctxt, XML_ERR_ARGUMENT, NULL);
11757
        xmlFreeInputStream(input);
11758
        return(NULL);
11759
    }
11760
11761
    if (xmlCtxtPushInput(ctxt, input) < 0) {
11762
        xmlFreeInputStream(input);
11763
        return(NULL);
11764
    }
11765
11766
    if (publicId == NULL)
11767
        publicId = BAD_CAST "none";
11768
    if (systemId == NULL)
11769
        systemId = BAD_CAST "none";
11770
11771
    ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
11772
    if (ctxt->myDoc == NULL) {
11773
        xmlErrMemory(ctxt);
11774
        goto error;
11775
    }
11776
    ctxt->myDoc->properties = XML_DOC_INTERNAL;
11777
    ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
11778
                                       publicId, systemId);
11779
    if (ctxt->myDoc->extSubset == NULL) {
11780
        xmlErrMemory(ctxt);
11781
        xmlFreeDoc(ctxt->myDoc);
11782
        goto error;
11783
    }
11784
11785
    xmlParseExternalSubset(ctxt, publicId, systemId);
11786
11787
    if (ctxt->wellFormed) {
11788
        ret = ctxt->myDoc->extSubset;
11789
        ctxt->myDoc->extSubset = NULL;
11790
        if (ret != NULL) {
11791
            xmlNodePtr tmp;
11792
11793
            ret->doc = NULL;
11794
            tmp = ret->children;
11795
            while (tmp != NULL) {
11796
                tmp->doc = NULL;
11797
                tmp = tmp->next;
11798
            }
11799
        }
11800
    } else {
11801
        ret = NULL;
11802
    }
11803
    xmlFreeDoc(ctxt->myDoc);
11804
    ctxt->myDoc = NULL;
11805
11806
error:
11807
    xmlFreeInputStream(xmlCtxtPopInput(ctxt));
11808
11809
    return(ret);
11810
}
11811
11812
/**
11813
 * xmlIOParseDTD:
11814
 * @sax:  the SAX handler block or NULL
11815
 * @input:  an Input Buffer
11816
 * @enc:  the charset encoding if known
11817
 *
11818
 * DEPRECATED: Use xmlCtxtParseDtd.
11819
 *
11820
 * Load and parse a DTD
11821
 *
11822
 * Returns the resulting xmlDtdPtr or NULL in case of error.
11823
 * @input will be freed by the function in any case.
11824
 */
11825
11826
xmlDtdPtr
11827
xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input,
11828
        xmlCharEncoding enc) {
11829
    xmlDtdPtr ret = NULL;
11830
    xmlParserCtxtPtr ctxt;
11831
    xmlParserInputPtr pinput = NULL;
11832
11833
    if (input == NULL)
11834
  return(NULL);
11835
11836
    ctxt = xmlNewSAXParserCtxt(sax, NULL);
11837
    if (ctxt == NULL) {
11838
        xmlFreeParserInputBuffer(input);
11839
  return(NULL);
11840
    }
11841
    xmlCtxtSetOptions(ctxt, XML_PARSE_DTDLOAD);
11842
11843
    /*
11844
     * generate a parser input from the I/O handler
11845
     */
11846
11847
    pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
11848
    if (pinput == NULL) {
11849
        xmlFreeParserInputBuffer(input);
11850
  xmlFreeParserCtxt(ctxt);
11851
  return(NULL);
11852
    }
11853
11854
    if (enc != XML_CHAR_ENCODING_NONE) {
11855
        xmlSwitchEncoding(ctxt, enc);
11856
    }
11857
11858
    ret = xmlCtxtParseDtd(ctxt, pinput, NULL, NULL);
11859
11860
    xmlFreeParserCtxt(ctxt);
11861
    return(ret);
11862
}
11863
11864
/**
11865
 * xmlSAXParseDTD:
11866
 * @sax:  the SAX handler block
11867
 * @ExternalID:  a NAME* containing the External ID of the DTD
11868
 * @SystemID:  a NAME* containing the URL to the DTD
11869
 *
11870
 * DEPRECATED: Use xmlCtxtParseDtd.
11871
 *
11872
 * Load and parse an external subset.
11873
 *
11874
 * Returns the resulting xmlDtdPtr or NULL in case of error.
11875
 */
11876
11877
xmlDtdPtr
11878
xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID,
11879
                          const xmlChar *SystemID) {
11880
    xmlDtdPtr ret = NULL;
11881
    xmlParserCtxtPtr ctxt;
11882
    xmlParserInputPtr input = NULL;
11883
    xmlChar* systemIdCanonic;
11884
11885
    if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL);
11886
11887
    ctxt = xmlNewSAXParserCtxt(sax, NULL);
11888
    if (ctxt == NULL) {
11889
  return(NULL);
11890
    }
11891
    xmlCtxtSetOptions(ctxt, XML_PARSE_DTDLOAD);
11892
11893
    /*
11894
     * Canonicalise the system ID
11895
     */
11896
    systemIdCanonic = xmlCanonicPath(SystemID);
11897
    if ((SystemID != NULL) && (systemIdCanonic == NULL)) {
11898
  xmlFreeParserCtxt(ctxt);
11899
  return(NULL);
11900
    }
11901
11902
    /*
11903
     * Ask the Entity resolver to load the damn thing
11904
     */
11905
11906
    if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
11907
  input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
11908
                                   systemIdCanonic);
11909
    if (input == NULL) {
11910
  xmlFreeParserCtxt(ctxt);
11911
  if (systemIdCanonic != NULL)
11912
      xmlFree(systemIdCanonic);
11913
  return(NULL);
11914
    }
11915
11916
    if (input->filename == NULL)
11917
  input->filename = (char *) systemIdCanonic;
11918
    else
11919
  xmlFree(systemIdCanonic);
11920
11921
    ret = xmlCtxtParseDtd(ctxt, input, ExternalID, SystemID);
11922
11923
    xmlFreeParserCtxt(ctxt);
11924
    return(ret);
11925
}
11926
11927
11928
/**
11929
 * xmlParseDTD:
11930
 * @ExternalID:  a NAME* containing the External ID of the DTD
11931
 * @SystemID:  a NAME* containing the URL to the DTD
11932
 *
11933
 * Load and parse an external subset.
11934
 *
11935
 * Returns the resulting xmlDtdPtr or NULL in case of error.
11936
 */
11937
11938
xmlDtdPtr
11939
xmlParseDTD(const xmlChar *ExternalID, const xmlChar *SystemID) {
11940
    return(xmlSAXParseDTD(NULL, ExternalID, SystemID));
11941
}
11942
#endif /* LIBXML_VALID_ENABLED */
11943
11944
/************************************************************************
11945
 *                  *
11946
 *    Front ends when parsing an Entity     *
11947
 *                  *
11948
 ************************************************************************/
11949
11950
static xmlNodePtr
11951
xmlCtxtParseContentInternal(xmlParserCtxtPtr ctxt, xmlParserInputPtr input,
11952
2.89k
                            int hasTextDecl, int buildTree) {
11953
2.89k
    xmlNodePtr root = NULL;
11954
2.89k
    xmlNodePtr list = NULL;
11955
2.89k
    xmlChar *rootName = BAD_CAST "#root";
11956
2.89k
    int result;
11957
11958
2.89k
    if (buildTree) {
11959
2.89k
        root = xmlNewDocNode(ctxt->myDoc, NULL, rootName, NULL);
11960
2.89k
        if (root == NULL) {
11961
1
            xmlErrMemory(ctxt);
11962
1
            goto error;
11963
1
        }
11964
2.89k
    }
11965
11966
2.89k
    if (xmlCtxtPushInput(ctxt, input) < 0)
11967
2
        goto error;
11968
11969
2.89k
    nameNsPush(ctxt, rootName, NULL, NULL, 0, 0);
11970
2.89k
    spacePush(ctxt, -1);
11971
11972
2.89k
    if (buildTree)
11973
2.89k
        nodePush(ctxt, root);
11974
11975
2.89k
    if (hasTextDecl) {
11976
2.36k
        xmlDetectEncoding(ctxt);
11977
11978
        /*
11979
         * Parse a possible text declaration first
11980
         */
11981
2.36k
        if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
11982
762
            (IS_BLANK_CH(NXT(5)))) {
11983
634
            xmlParseTextDecl(ctxt);
11984
            /*
11985
             * An XML-1.0 document can't reference an entity not XML-1.0
11986
             */
11987
634
            if ((xmlStrEqual(ctxt->version, BAD_CAST "1.0")) &&
11988
558
                (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
11989
474
                xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH,
11990
474
                               "Version mismatch between document and "
11991
474
                               "entity\n");
11992
474
            }
11993
634
        }
11994
2.36k
    }
11995
11996
2.89k
    xmlParseContentInternal(ctxt);
11997
11998
2.89k
    if (ctxt->input->cur < ctxt->input->end)
11999
542
  xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12000
12001
2.89k
    if ((ctxt->wellFormed) ||
12002
2.44k
        ((ctxt->recovery) && (!xmlCtxtIsCatastrophicError(ctxt)))) {
12003
473
        if (root != NULL) {
12004
473
            xmlNodePtr cur;
12005
12006
            /*
12007
             * Unlink newly created node list.
12008
             */
12009
473
            list = root->children;
12010
473
            root->children = NULL;
12011
473
            root->last = NULL;
12012
1.24k
            for (cur = list; cur != NULL; cur = cur->next)
12013
768
                cur->parent = NULL;
12014
473
        }
12015
473
    }
12016
12017
    /*
12018
     * Read the rest of the stream in case of errors. We want
12019
     * to account for the whole entity size.
12020
     */
12021
2.95k
    do {
12022
2.95k
        ctxt->input->cur = ctxt->input->end;
12023
2.95k
        xmlParserShrink(ctxt);
12024
2.95k
        result = xmlParserGrow(ctxt);
12025
2.95k
    } while (result > 0);
12026
12027
2.89k
    if (buildTree)
12028
2.89k
        nodePop(ctxt);
12029
12030
2.89k
    namePop(ctxt);
12031
2.89k
    spacePop(ctxt);
12032
12033
2.89k
    xmlCtxtPopInput(ctxt);
12034
12035
2.89k
error:
12036
2.89k
    xmlFreeNode(root);
12037
12038
2.89k
    return(list);
12039
2.89k
}
12040
12041
static void
12042
3.33k
xmlCtxtParseEntity(xmlParserCtxtPtr ctxt, xmlEntityPtr ent) {
12043
3.33k
    xmlParserInputPtr input;
12044
3.33k
    xmlNodePtr list;
12045
3.33k
    unsigned long consumed;
12046
3.33k
    int isExternal;
12047
3.33k
    int buildTree;
12048
3.33k
    int oldMinNsIndex;
12049
3.33k
    int oldNodelen, oldNodemem;
12050
12051
3.33k
    isExternal = (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY);
12052
3.33k
    buildTree = (ctxt->node != NULL);
12053
12054
    /*
12055
     * Recursion check
12056
     */
12057
3.33k
    if (ent->flags & XML_ENT_EXPANDING) {
12058
249
        xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
12059
249
        xmlHaltParser(ctxt);
12060
249
        goto error;
12061
249
    }
12062
12063
    /*
12064
     * Load entity
12065
     */
12066
3.08k
    input = xmlNewEntityInputStream(ctxt, ent);
12067
3.08k
    if (input == NULL)
12068
185
        goto error;
12069
12070
    /*
12071
     * When building a tree, we need to limit the scope of namespace
12072
     * declarations, so that entities don't reference xmlNs structs
12073
     * from the parent of a reference.
12074
     */
12075
2.89k
    oldMinNsIndex = ctxt->nsdb->minNsIndex;
12076
2.89k
    if (buildTree)
12077
2.89k
        ctxt->nsdb->minNsIndex = ctxt->nsNr;
12078
12079
2.89k
    oldNodelen = ctxt->nodelen;
12080
2.89k
    oldNodemem = ctxt->nodemem;
12081
2.89k
    ctxt->nodelen = 0;
12082
2.89k
    ctxt->nodemem = 0;
12083
12084
    /*
12085
     * Parse content
12086
     *
12087
     * This initiates a recursive call chain:
12088
     *
12089
     * - xmlCtxtParseContentInternal
12090
     * - xmlParseContentInternal
12091
     * - xmlParseReference
12092
     * - xmlCtxtParseEntity
12093
     *
12094
     * The nesting depth is limited by the maximum number of inputs,
12095
     * see xmlCtxtPushInput.
12096
     *
12097
     * It's possible to make this non-recursive (minNsIndex must be
12098
     * stored in the input struct) at the expense of code readability.
12099
     */
12100
12101
2.89k
    ent->flags |= XML_ENT_EXPANDING;
12102
12103
2.89k
    list = xmlCtxtParseContentInternal(ctxt, input, isExternal, buildTree);
12104
12105
2.89k
    ent->flags &= ~XML_ENT_EXPANDING;
12106
12107
2.89k
    ctxt->nsdb->minNsIndex = oldMinNsIndex;
12108
2.89k
    ctxt->nodelen = oldNodelen;
12109
2.89k
    ctxt->nodemem = oldNodemem;
12110
12111
    /*
12112
     * Entity size accounting
12113
     */
12114
2.89k
    consumed = input->consumed;
12115
2.89k
    xmlSaturatedAddSizeT(&consumed, input->end - input->base);
12116
12117
2.89k
    if ((ent->flags & XML_ENT_CHECKED) == 0)
12118
2.53k
        xmlSaturatedAdd(&ent->expandedSize, consumed);
12119
12120
2.89k
    if ((ent->flags & XML_ENT_PARSED) == 0) {
12121
2.53k
        if (isExternal)
12122
2.35k
            xmlSaturatedAdd(&ctxt->sizeentities, consumed);
12123
12124
2.53k
        ent->children = list;
12125
12126
3.30k
        while (list != NULL) {
12127
768
            list->parent = (xmlNodePtr) ent;
12128
12129
            /*
12130
             * Downstream code like the nginx xslt module can set
12131
             * ctxt->myDoc->extSubset to a separate DTD, so the entity
12132
             * might have a different or a NULL document.
12133
             */
12134
768
            if (list->doc != ent->doc)
12135
0
                xmlSetTreeDoc(list, ent->doc);
12136
12137
768
            if (list->next == NULL)
12138
313
                ent->last = list;
12139
768
            list = list->next;
12140
768
        }
12141
2.53k
    } else {
12142
359
        xmlFreeNodeList(list);
12143
359
    }
12144
12145
2.89k
    xmlFreeInputStream(input);
12146
12147
3.33k
error:
12148
3.33k
    ent->flags |= XML_ENT_PARSED | XML_ENT_CHECKED;
12149
3.33k
}
12150
12151
/**
12152
 * xmlParseCtxtExternalEntity:
12153
 * @ctxt:  the existing parsing context
12154
 * @URL:  the URL for the entity to load
12155
 * @ID:  the System ID for the entity to load
12156
 * @listOut:  the return value for the set of parsed nodes
12157
 *
12158
 * Parse an external general entity within an existing parsing context
12159
 * An external general parsed entity is well-formed if it matches the
12160
 * production labeled extParsedEnt.
12161
 *
12162
 * [78] extParsedEnt ::= TextDecl? content
12163
 *
12164
 * Returns 0 if the entity is well formed, -1 in case of args problem and
12165
 *    the parser error code otherwise
12166
 */
12167
12168
int
12169
xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctxt, const xmlChar *URL,
12170
0
                           const xmlChar *ID, xmlNodePtr *listOut) {
12171
0
    xmlParserInputPtr input;
12172
0
    xmlNodePtr list;
12173
12174
0
    if (listOut != NULL)
12175
0
        *listOut = NULL;
12176
12177
0
    if (ctxt == NULL)
12178
0
        return(XML_ERR_ARGUMENT);
12179
12180
0
    input = xmlLoadResource(ctxt, (char *) URL, (char *) ID,
12181
0
                            XML_RESOURCE_GENERAL_ENTITY);
12182
0
    if (input == NULL)
12183
0
        return(ctxt->errNo);
12184
12185
0
    xmlCtxtInitializeLate(ctxt);
12186
12187
0
    list = xmlCtxtParseContentInternal(ctxt, input, /* hasTextDecl */ 1, 1);
12188
0
    if (listOut != NULL)
12189
0
        *listOut = list;
12190
0
    else
12191
0
        xmlFreeNodeList(list);
12192
12193
0
    xmlFreeInputStream(input);
12194
0
    return(ctxt->errNo);
12195
0
}
12196
12197
#ifdef LIBXML_SAX1_ENABLED
12198
/**
12199
 * xmlParseExternalEntity:
12200
 * @doc:  the document the chunk pertains to
12201
 * @sax:  the SAX handler block (possibly NULL)
12202
 * @user_data:  The user data returned on SAX callbacks (possibly NULL)
12203
 * @depth:  Used for loop detection, use 0
12204
 * @URL:  the URL for the entity to load
12205
 * @ID:  the System ID for the entity to load
12206
 * @list:  the return value for the set of parsed nodes
12207
 *
12208
 * DEPRECATED: Use xmlParseCtxtExternalEntity.
12209
 *
12210
 * Parse an external general entity
12211
 * An external general parsed entity is well-formed if it matches the
12212
 * production labeled extParsedEnt.
12213
 *
12214
 * [78] extParsedEnt ::= TextDecl? content
12215
 *
12216
 * Returns 0 if the entity is well formed, -1 in case of args problem and
12217
 *    the parser error code otherwise
12218
 */
12219
12220
int
12221
xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data,
12222
    int depth, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *list) {
12223
    xmlParserCtxtPtr ctxt;
12224
    int ret;
12225
12226
    if (list != NULL)
12227
        *list = NULL;
12228
12229
    if (doc == NULL)
12230
        return(XML_ERR_ARGUMENT);
12231
12232
    ctxt = xmlNewSAXParserCtxt(sax, user_data);
12233
    if (ctxt == NULL)
12234
        return(XML_ERR_NO_MEMORY);
12235
12236
    ctxt->depth = depth;
12237
    ctxt->myDoc = doc;
12238
    ret = xmlParseCtxtExternalEntity(ctxt, URL, ID, list);
12239
12240
    xmlFreeParserCtxt(ctxt);
12241
    return(ret);
12242
}
12243
12244
/**
12245
 * xmlParseBalancedChunkMemory:
12246
 * @doc:  the document the chunk pertains to (must not be NULL)
12247
 * @sax:  the SAX handler block (possibly NULL)
12248
 * @user_data:  The user data returned on SAX callbacks (possibly NULL)
12249
 * @depth:  Used for loop detection, use 0
12250
 * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
12251
 * @lst:  the return value for the set of parsed nodes
12252
 *
12253
 * Parse a well-balanced chunk of an XML document
12254
 * called by the parser
12255
 * The allowed sequence for the Well Balanced Chunk is the one defined by
12256
 * the content production in the XML grammar:
12257
 *
12258
 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
12259
 *
12260
 * Returns 0 if the chunk is well balanced, -1 in case of args problem and
12261
 *    the parser error code otherwise
12262
 */
12263
12264
int
12265
xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax,
12266
     void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst) {
12267
    return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data,
12268
                                                depth, string, lst, 0 );
12269
}
12270
#endif /* LIBXML_SAX1_ENABLED */
12271
12272
/**
12273
 * xmlCtxtParseContent:
12274
 * @ctxt:  parser context
12275
 * @input:  parser input
12276
 * @node:  target node or document
12277
 * @hasTextDecl:  whether to parse text declaration
12278
 *
12279
 * Parse a well-balanced chunk of XML matching the 'content' production.
12280
 *
12281
 * Namespaces in scope of @node and entities of @node's document are
12282
 * recognized. When validating, the DTD of @node's document is used.
12283
 *
12284
 * Always consumes @input even in error case.
12285
 *
12286
 * Available since 2.14.0.
12287
 *
12288
 * Returns a node list or NULL in case of error.
12289
 */
12290
xmlNodePtr
12291
xmlCtxtParseContent(xmlParserCtxtPtr ctxt, xmlParserInputPtr input,
12292
0
                    xmlNodePtr node, int hasTextDecl) {
12293
0
    xmlDocPtr doc;
12294
0
    xmlNodePtr cur, list = NULL;
12295
0
    int nsnr = 0;
12296
0
    xmlDictPtr oldDict;
12297
0
    int oldOptions, oldDictNames, oldLoadSubset;
12298
12299
0
    if ((ctxt == NULL) || (input == NULL) || (node == NULL)) {
12300
0
        xmlFatalErr(ctxt, XML_ERR_ARGUMENT, NULL);
12301
0
        goto exit;
12302
0
    }
12303
12304
0
    doc = node->doc;
12305
0
    if (doc == NULL) {
12306
0
        xmlFatalErr(ctxt, XML_ERR_ARGUMENT, NULL);
12307
0
        goto exit;
12308
0
    }
12309
12310
0
    switch (node->type) {
12311
0
        case XML_ELEMENT_NODE:
12312
0
        case XML_DOCUMENT_NODE:
12313
0
        case XML_HTML_DOCUMENT_NODE:
12314
0
            break;
12315
12316
0
        case XML_ATTRIBUTE_NODE:
12317
0
        case XML_TEXT_NODE:
12318
0
        case XML_CDATA_SECTION_NODE:
12319
0
        case XML_ENTITY_REF_NODE:
12320
0
        case XML_PI_NODE:
12321
0
        case XML_COMMENT_NODE:
12322
0
            for (cur = node->parent; cur != NULL; cur = node->parent) {
12323
0
                if ((cur->type == XML_ELEMENT_NODE) ||
12324
0
                    (cur->type == XML_DOCUMENT_NODE) ||
12325
0
                    (cur->type == XML_HTML_DOCUMENT_NODE)) {
12326
0
                    node = cur;
12327
0
                    break;
12328
0
                }
12329
0
            }
12330
0
            break;
12331
12332
0
        default:
12333
0
            xmlFatalErr(ctxt, XML_ERR_ARGUMENT, NULL);
12334
0
            goto exit;
12335
0
    }
12336
12337
0
#ifdef LIBXML_HTML_ENABLED
12338
0
    if (ctxt->html)
12339
0
        htmlCtxtReset(ctxt);
12340
0
    else
12341
0
#endif
12342
0
        xmlCtxtReset(ctxt);
12343
12344
0
    oldDict = ctxt->dict;
12345
0
    oldOptions = ctxt->options;
12346
0
    oldDictNames = ctxt->dictNames;
12347
0
    oldLoadSubset = ctxt->loadsubset;
12348
12349
    /*
12350
     * Use input doc's dict if present, else assure XML_PARSE_NODICT is set.
12351
     */
12352
0
    if (doc->dict != NULL) {
12353
0
        ctxt->dict = doc->dict;
12354
0
    } else {
12355
0
        ctxt->options |= XML_PARSE_NODICT;
12356
0
        ctxt->dictNames = 0;
12357
0
    }
12358
12359
    /*
12360
     * Disable IDs
12361
     */
12362
0
    ctxt->loadsubset |= XML_SKIP_IDS;
12363
12364
0
    ctxt->myDoc = doc;
12365
12366
0
#ifdef LIBXML_HTML_ENABLED
12367
0
    if (ctxt->html) {
12368
        /*
12369
         * When parsing in context, it makes no sense to add implied
12370
         * elements like html/body/etc...
12371
         */
12372
0
        ctxt->options |= HTML_PARSE_NOIMPLIED;
12373
12374
0
        list = htmlCtxtParseContentInternal(ctxt, input);
12375
0
    } else
12376
0
#endif
12377
0
    {
12378
0
        xmlCtxtInitializeLate(ctxt);
12379
12380
        /*
12381
         * initialize the SAX2 namespaces stack
12382
         */
12383
0
        cur = node;
12384
0
        while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) {
12385
0
            xmlNsPtr ns = cur->nsDef;
12386
0
            xmlHashedString hprefix, huri;
12387
12388
0
            while (ns != NULL) {
12389
0
                hprefix = xmlDictLookupHashed(ctxt->dict, ns->prefix, -1);
12390
0
                huri = xmlDictLookupHashed(ctxt->dict, ns->href, -1);
12391
0
                if (xmlParserNsPush(ctxt, &hprefix, &huri, ns, 1) > 0)
12392
0
                    nsnr++;
12393
0
                ns = ns->next;
12394
0
            }
12395
0
            cur = cur->parent;
12396
0
        }
12397
12398
0
        list = xmlCtxtParseContentInternal(ctxt, input, hasTextDecl, 1);
12399
12400
0
        if (nsnr > 0)
12401
0
            xmlParserNsPop(ctxt, nsnr);
12402
0
    }
12403
12404
0
    ctxt->dict = oldDict;
12405
0
    ctxt->options = oldOptions;
12406
0
    ctxt->dictNames = oldDictNames;
12407
0
    ctxt->loadsubset = oldLoadSubset;
12408
0
    ctxt->myDoc = NULL;
12409
0
    ctxt->node = NULL;
12410
12411
0
exit:
12412
0
    xmlFreeInputStream(input);
12413
0
    return(list);
12414
0
}
12415
12416
/**
12417
 * xmlParseInNodeContext:
12418
 * @node:  the context node
12419
 * @data:  the input string
12420
 * @datalen:  the input string length in bytes
12421
 * @options:  a combination of xmlParserOption
12422
 * @listOut:  the return value for the set of parsed nodes
12423
 *
12424
 * Parse a well-balanced chunk of an XML document
12425
 * within the context (DTD, namespaces, etc ...) of the given node.
12426
 *
12427
 * The allowed sequence for the data is a Well Balanced Chunk defined by
12428
 * the content production in the XML grammar:
12429
 *
12430
 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
12431
 *
12432
 * This function assumes the encoding of @node's document which is
12433
 * typically not what you want. A better alternative is
12434
 * xmlCtxtParseContent.
12435
 *
12436
 * Returns XML_ERR_OK if the chunk is well balanced, and the parser
12437
 * error code otherwise
12438
 */
12439
xmlParserErrors
12440
xmlParseInNodeContext(xmlNodePtr node, const char *data, int datalen,
12441
0
                      int options, xmlNodePtr *listOut) {
12442
0
    xmlParserCtxtPtr ctxt;
12443
0
    xmlParserInputPtr input;
12444
0
    xmlDocPtr doc;
12445
0
    xmlNodePtr list;
12446
0
    xmlParserErrors ret;
12447
12448
0
    if (listOut == NULL)
12449
0
        return(XML_ERR_INTERNAL_ERROR);
12450
0
    *listOut = NULL;
12451
12452
0
    if ((node == NULL) || (data == NULL) || (datalen < 0))
12453
0
        return(XML_ERR_INTERNAL_ERROR);
12454
12455
0
    doc = node->doc;
12456
0
    if (doc == NULL)
12457
0
        return(XML_ERR_INTERNAL_ERROR);
12458
12459
0
#ifdef LIBXML_HTML_ENABLED
12460
0
    if (doc->type == XML_HTML_DOCUMENT_NODE) {
12461
0
        ctxt = htmlNewParserCtxt();
12462
0
    }
12463
0
    else
12464
0
#endif
12465
0
        ctxt = xmlNewParserCtxt();
12466
12467
0
    if (ctxt == NULL)
12468
0
        return(XML_ERR_NO_MEMORY);
12469
12470
0
    input = xmlCtxtNewInputFromMemory(ctxt, NULL, data, datalen,
12471
0
                                      (const char *) doc->encoding,
12472
0
                                      XML_INPUT_BUF_STATIC);
12473
0
    if (input == NULL) {
12474
0
        xmlFreeParserCtxt(ctxt);
12475
0
        return(XML_ERR_NO_MEMORY);
12476
0
    }
12477
12478
0
    xmlCtxtUseOptions(ctxt, options);
12479
12480
0
    list = xmlCtxtParseContent(ctxt, input, node, /* hasTextDecl */ 0);
12481
12482
0
    if (list == NULL) {
12483
0
        ret = ctxt->errNo;
12484
0
        if (ret == XML_ERR_ARGUMENT)
12485
0
            ret = XML_ERR_INTERNAL_ERROR;
12486
0
    } else {
12487
0
        ret = XML_ERR_OK;
12488
0
        *listOut = list;
12489
0
    }
12490
12491
0
    xmlFreeParserCtxt(ctxt);
12492
12493
0
    return(ret);
12494
0
}
12495
12496
#ifdef LIBXML_SAX1_ENABLED
12497
/**
12498
 * xmlParseBalancedChunkMemoryRecover:
12499
 * @doc:  the document the chunk pertains to (must not be NULL)
12500
 * @sax:  the SAX handler block (possibly NULL)
12501
 * @user_data:  The user data returned on SAX callbacks (possibly NULL)
12502
 * @depth:  Used for loop detection, use 0
12503
 * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
12504
 * @listOut:  the return value for the set of parsed nodes
12505
 * @recover: return nodes even if the data is broken (use 0)
12506
 *
12507
 * Parse a well-balanced chunk of an XML document
12508
 *
12509
 * The allowed sequence for the Well Balanced Chunk is the one defined by
12510
 * the content production in the XML grammar:
12511
 *
12512
 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
12513
 *
12514
 * Returns 0 if the chunk is well balanced, or thehe parser error code
12515
 * otherwise.
12516
 *
12517
 * In case recover is set to 1, the nodelist will not be empty even if
12518
 * the parsed chunk is not well balanced, assuming the parsing succeeded to
12519
 * some extent.
12520
 */
12521
int
12522
xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax,
12523
     void *user_data, int depth, const xmlChar *string, xmlNodePtr *listOut,
12524
     int recover) {
12525
    xmlParserCtxtPtr ctxt;
12526
    xmlParserInputPtr input;
12527
    xmlNodePtr list;
12528
    int ret;
12529
12530
    if (listOut != NULL)
12531
        *listOut = NULL;
12532
12533
    if (string == NULL)
12534
        return(XML_ERR_ARGUMENT);
12535
12536
    ctxt = xmlNewSAXParserCtxt(sax, user_data);
12537
    if (ctxt == NULL)
12538
        return(XML_ERR_NO_MEMORY);
12539
12540
    xmlCtxtInitializeLate(ctxt);
12541
12542
    ctxt->depth = depth;
12543
    ctxt->myDoc = doc;
12544
    if (recover) {
12545
        ctxt->options |= XML_PARSE_RECOVER;
12546
        ctxt->recovery = 1;
12547
    }
12548
12549
    input = xmlNewStringInputStream(ctxt, string);
12550
    if (input == NULL) {
12551
        ret = ctxt->errNo;
12552
        goto error;
12553
    }
12554
12555
    list = xmlCtxtParseContentInternal(ctxt, input, /* hasTextDecl */ 0, 1);
12556
    if (listOut != NULL)
12557
        *listOut = list;
12558
    else
12559
        xmlFreeNodeList(list);
12560
12561
    if (!ctxt->wellFormed)
12562
        ret = ctxt->errNo;
12563
    else
12564
        ret = XML_ERR_OK;
12565
12566
error:
12567
    xmlFreeInputStream(input);
12568
    xmlFreeParserCtxt(ctxt);
12569
    return(ret);
12570
}
12571
12572
/**
12573
 * xmlSAXParseEntity:
12574
 * @sax:  the SAX handler block
12575
 * @filename:  the filename
12576
 *
12577
 * DEPRECATED: Don't use.
12578
 *
12579
 * parse an XML external entity out of context and build a tree.
12580
 * It use the given SAX function block to handle the parsing callback.
12581
 * If sax is NULL, fallback to the default DOM tree building routines.
12582
 *
12583
 * [78] extParsedEnt ::= TextDecl? content
12584
 *
12585
 * This correspond to a "Well Balanced" chunk
12586
 *
12587
 * Returns the resulting document tree
12588
 */
12589
12590
xmlDocPtr
12591
xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) {
12592
    xmlDocPtr ret;
12593
    xmlParserCtxtPtr ctxt;
12594
12595
    ctxt = xmlCreateFileParserCtxt(filename);
12596
    if (ctxt == NULL) {
12597
  return(NULL);
12598
    }
12599
    if (sax != NULL) {
12600
        if (sax->initialized == XML_SAX2_MAGIC) {
12601
            *ctxt->sax = *sax;
12602
        } else {
12603
            memset(ctxt->sax, 0, sizeof(*ctxt->sax));
12604
            memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12605
        }
12606
        ctxt->userData = NULL;
12607
    }
12608
12609
    xmlParseExtParsedEnt(ctxt);
12610
12611
    if (ctxt->wellFormed) {
12612
  ret = ctxt->myDoc;
12613
    } else {
12614
        ret = NULL;
12615
        xmlFreeDoc(ctxt->myDoc);
12616
    }
12617
12618
    xmlFreeParserCtxt(ctxt);
12619
12620
    return(ret);
12621
}
12622
12623
/**
12624
 * xmlParseEntity:
12625
 * @filename:  the filename
12626
 *
12627
 * parse an XML external entity out of context and build a tree.
12628
 *
12629
 * [78] extParsedEnt ::= TextDecl? content
12630
 *
12631
 * This correspond to a "Well Balanced" chunk
12632
 *
12633
 * Returns the resulting document tree
12634
 */
12635
12636
xmlDocPtr
12637
xmlParseEntity(const char *filename) {
12638
    return(xmlSAXParseEntity(NULL, filename));
12639
}
12640
#endif /* LIBXML_SAX1_ENABLED */
12641
12642
/**
12643
 * xmlCreateEntityParserCtxt:
12644
 * @URL:  the entity URL
12645
 * @ID:  the entity PUBLIC ID
12646
 * @base:  a possible base for the target URI
12647
 *
12648
 * DEPRECATED: Don't use.
12649
 *
12650
 * Create a parser context for an external entity
12651
 * Automatic support for ZLIB/Compress compressed document is provided
12652
 * by default if found at compile-time.
12653
 *
12654
 * Returns the new parser context or NULL
12655
 */
12656
xmlParserCtxtPtr
12657
xmlCreateEntityParserCtxt(const xmlChar *URL, const xmlChar *ID,
12658
0
                    const xmlChar *base) {
12659
0
    xmlParserCtxtPtr ctxt;
12660
0
    xmlParserInputPtr input;
12661
0
    xmlChar *uri = NULL;
12662
12663
0
    ctxt = xmlNewParserCtxt();
12664
0
    if (ctxt == NULL)
12665
0
  return(NULL);
12666
12667
0
    if (base != NULL) {
12668
0
        if (xmlBuildURISafe(URL, base, &uri) < 0)
12669
0
            goto error;
12670
0
        if (uri != NULL)
12671
0
            URL = uri;
12672
0
    }
12673
12674
0
    input = xmlLoadResource(ctxt, (char *) URL, (char *) ID,
12675
0
                            XML_RESOURCE_UNKNOWN);
12676
0
    if (input == NULL)
12677
0
        goto error;
12678
12679
0
    if (xmlCtxtPushInput(ctxt, input) < 0) {
12680
0
        xmlFreeInputStream(input);
12681
0
        goto error;
12682
0
    }
12683
12684
0
    xmlFree(uri);
12685
0
    return(ctxt);
12686
12687
0
error:
12688
0
    xmlFree(uri);
12689
0
    xmlFreeParserCtxt(ctxt);
12690
0
    return(NULL);
12691
0
}
12692
12693
/************************************************************************
12694
 *                  *
12695
 *    Front ends when parsing from a file     *
12696
 *                  *
12697
 ************************************************************************/
12698
12699
/**
12700
 * xmlCreateURLParserCtxt:
12701
 * @filename:  the filename or URL
12702
 * @options:  a combination of xmlParserOption
12703
 *
12704
 * DEPRECATED: Use xmlNewParserCtxt and xmlCtxtReadFile.
12705
 *
12706
 * Create a parser context for a file or URL content.
12707
 * Automatic support for ZLIB/Compress compressed document is provided
12708
 * by default if found at compile-time and for file accesses
12709
 *
12710
 * Returns the new parser context or NULL
12711
 */
12712
xmlParserCtxtPtr
12713
xmlCreateURLParserCtxt(const char *filename, int options)
12714
0
{
12715
0
    xmlParserCtxtPtr ctxt;
12716
0
    xmlParserInputPtr input;
12717
12718
0
    ctxt = xmlNewParserCtxt();
12719
0
    if (ctxt == NULL)
12720
0
  return(NULL);
12721
12722
0
    options |= XML_PARSE_UNZIP;
12723
12724
0
    xmlCtxtUseOptions(ctxt, options);
12725
0
    ctxt->linenumbers = 1;
12726
12727
0
    input = xmlLoadResource(ctxt, filename, NULL, XML_RESOURCE_MAIN_DOCUMENT);
12728
0
    if (input == NULL) {
12729
0
  xmlFreeParserCtxt(ctxt);
12730
0
  return(NULL);
12731
0
    }
12732
0
    if (xmlCtxtPushInput(ctxt, input) < 0) {
12733
0
        xmlFreeInputStream(input);
12734
0
        xmlFreeParserCtxt(ctxt);
12735
0
        return(NULL);
12736
0
    }
12737
12738
0
    return(ctxt);
12739
0
}
12740
12741
/**
12742
 * xmlCreateFileParserCtxt:
12743
 * @filename:  the filename
12744
 *
12745
 * DEPRECATED: Use xmlNewParserCtxt and xmlCtxtReadFile.
12746
 *
12747
 * Create a parser context for a file content.
12748
 * Automatic support for ZLIB/Compress compressed document is provided
12749
 * by default if found at compile-time.
12750
 *
12751
 * Returns the new parser context or NULL
12752
 */
12753
xmlParserCtxtPtr
12754
xmlCreateFileParserCtxt(const char *filename)
12755
0
{
12756
0
    return(xmlCreateURLParserCtxt(filename, 0));
12757
0
}
12758
12759
#ifdef LIBXML_SAX1_ENABLED
12760
/**
12761
 * xmlSAXParseFileWithData:
12762
 * @sax:  the SAX handler block
12763
 * @filename:  the filename
12764
 * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
12765
 *             documents
12766
 * @data:  the userdata
12767
 *
12768
 * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadFile.
12769
 *
12770
 * parse an XML file and build a tree. Automatic support for ZLIB/Compress
12771
 * compressed document is provided by default if found at compile-time.
12772
 * It use the given SAX function block to handle the parsing callback.
12773
 * If sax is NULL, fallback to the default DOM tree building routines.
12774
 *
12775
 * User data (void *) is stored within the parser context in the
12776
 * context's _private member, so it is available nearly everywhere in libxml
12777
 *
12778
 * Returns the resulting document tree
12779
 */
12780
12781
xmlDocPtr
12782
xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename,
12783
                        int recovery, void *data) {
12784
    xmlDocPtr ret = NULL;
12785
    xmlParserCtxtPtr ctxt;
12786
    xmlParserInputPtr input;
12787
12788
    ctxt = xmlNewSAXParserCtxt(sax, NULL);
12789
    if (ctxt == NULL)
12790
  return(NULL);
12791
12792
    if (data != NULL)
12793
  ctxt->_private = data;
12794
12795
    if (recovery) {
12796
        ctxt->options |= XML_PARSE_RECOVER;
12797
        ctxt->recovery = 1;
12798
    }
12799
12800
    if ((filename != NULL) && (filename[0] == '-') && (filename[1] == 0))
12801
        input = xmlCtxtNewInputFromFd(ctxt, filename, STDIN_FILENO, NULL, 0);
12802
    else
12803
        input = xmlCtxtNewInputFromUrl(ctxt, filename, NULL, NULL, 0);
12804
12805
    if (input != NULL)
12806
        ret = xmlCtxtParseDocument(ctxt, input);
12807
12808
    xmlFreeParserCtxt(ctxt);
12809
    return(ret);
12810
}
12811
12812
/**
12813
 * xmlSAXParseFile:
12814
 * @sax:  the SAX handler block
12815
 * @filename:  the filename
12816
 * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
12817
 *             documents
12818
 *
12819
 * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadFile.
12820
 *
12821
 * parse an XML file and build a tree. Automatic support for ZLIB/Compress
12822
 * compressed document is provided by default if found at compile-time.
12823
 * It use the given SAX function block to handle the parsing callback.
12824
 * If sax is NULL, fallback to the default DOM tree building routines.
12825
 *
12826
 * Returns the resulting document tree
12827
 */
12828
12829
xmlDocPtr
12830
xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename,
12831
                          int recovery) {
12832
    return(xmlSAXParseFileWithData(sax,filename,recovery,NULL));
12833
}
12834
12835
/**
12836
 * xmlRecoverDoc:
12837
 * @cur:  a pointer to an array of xmlChar
12838
 *
12839
 * DEPRECATED: Use xmlReadDoc with XML_PARSE_RECOVER.
12840
 *
12841
 * parse an XML in-memory document and build a tree.
12842
 * In the case the document is not Well Formed, a attempt to build a
12843
 * tree is tried anyway
12844
 *
12845
 * Returns the resulting document tree or NULL in case of failure
12846
 */
12847
12848
xmlDocPtr
12849
xmlRecoverDoc(const xmlChar *cur) {
12850
    return(xmlSAXParseDoc(NULL, cur, 1));
12851
}
12852
12853
/**
12854
 * xmlParseFile:
12855
 * @filename:  the filename
12856
 *
12857
 * DEPRECATED: Use xmlReadFile.
12858
 *
12859
 * parse an XML file and build a tree. Automatic support for ZLIB/Compress
12860
 * compressed document is provided by default if found at compile-time.
12861
 *
12862
 * Returns the resulting document tree if the file was wellformed,
12863
 * NULL otherwise.
12864
 */
12865
12866
xmlDocPtr
12867
xmlParseFile(const char *filename) {
12868
    return(xmlSAXParseFile(NULL, filename, 0));
12869
}
12870
12871
/**
12872
 * xmlRecoverFile:
12873
 * @filename:  the filename
12874
 *
12875
 * DEPRECATED: Use xmlReadFile with XML_PARSE_RECOVER.
12876
 *
12877
 * parse an XML file and build a tree. Automatic support for ZLIB/Compress
12878
 * compressed document is provided by default if found at compile-time.
12879
 * In the case the document is not Well Formed, it attempts to build
12880
 * a tree anyway
12881
 *
12882
 * Returns the resulting document tree or NULL in case of failure
12883
 */
12884
12885
xmlDocPtr
12886
xmlRecoverFile(const char *filename) {
12887
    return(xmlSAXParseFile(NULL, filename, 1));
12888
}
12889
12890
12891
/**
12892
 * xmlSetupParserForBuffer:
12893
 * @ctxt:  an XML parser context
12894
 * @buffer:  a xmlChar * buffer
12895
 * @filename:  a file name
12896
 *
12897
 * DEPRECATED: Don't use.
12898
 *
12899
 * Setup the parser context to parse a new buffer; Clears any prior
12900
 * contents from the parser context. The buffer parameter must not be
12901
 * NULL, but the filename parameter can be
12902
 */
12903
void
12904
xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
12905
                             const char* filename)
12906
{
12907
    xmlParserInputPtr input;
12908
12909
    if ((ctxt == NULL) || (buffer == NULL))
12910
        return;
12911
12912
    xmlClearParserCtxt(ctxt);
12913
12914
    input = xmlCtxtNewInputFromString(ctxt, filename, (const char *) buffer,
12915
                                      NULL, 0);
12916
    if (input == NULL)
12917
        return;
12918
    if (xmlCtxtPushInput(ctxt, input) < 0)
12919
        xmlFreeInputStream(input);
12920
}
12921
12922
/**
12923
 * xmlSAXUserParseFile:
12924
 * @sax:  a SAX handler
12925
 * @user_data:  The user data returned on SAX callbacks
12926
 * @filename:  a file name
12927
 *
12928
 * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadFile.
12929
 *
12930
 * parse an XML file and call the given SAX handler routines.
12931
 * Automatic support for ZLIB/Compress compressed document is provided
12932
 *
12933
 * Returns 0 in case of success or a error number otherwise
12934
 */
12935
int
12936
xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data,
12937
                    const char *filename) {
12938
    int ret = 0;
12939
    xmlParserCtxtPtr ctxt;
12940
12941
    ctxt = xmlCreateFileParserCtxt(filename);
12942
    if (ctxt == NULL) return -1;
12943
    if (sax != NULL) {
12944
        if (sax->initialized == XML_SAX2_MAGIC) {
12945
            *ctxt->sax = *sax;
12946
        } else {
12947
            memset(ctxt->sax, 0, sizeof(*ctxt->sax));
12948
            memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12949
        }
12950
  ctxt->userData = user_data;
12951
    }
12952
12953
    xmlParseDocument(ctxt);
12954
12955
    if (ctxt->wellFormed)
12956
  ret = 0;
12957
    else {
12958
        if (ctxt->errNo != 0)
12959
      ret = ctxt->errNo;
12960
  else
12961
      ret = -1;
12962
    }
12963
    if (ctxt->myDoc != NULL) {
12964
        xmlFreeDoc(ctxt->myDoc);
12965
  ctxt->myDoc = NULL;
12966
    }
12967
    xmlFreeParserCtxt(ctxt);
12968
12969
    return ret;
12970
}
12971
#endif /* LIBXML_SAX1_ENABLED */
12972
12973
/************************************************************************
12974
 *                  *
12975
 *    Front ends when parsing from memory     *
12976
 *                  *
12977
 ************************************************************************/
12978
12979
/**
12980
 * xmlCreateMemoryParserCtxt:
12981
 * @buffer:  a pointer to a char array
12982
 * @size:  the size of the array
12983
 *
12984
 * Create a parser context for an XML in-memory document. The input buffer
12985
 * must not contain a terminating null byte.
12986
 *
12987
 * Returns the new parser context or NULL
12988
 */
12989
xmlParserCtxtPtr
12990
0
xmlCreateMemoryParserCtxt(const char *buffer, int size) {
12991
0
    xmlParserCtxtPtr ctxt;
12992
0
    xmlParserInputPtr input;
12993
12994
0
    if (size < 0)
12995
0
  return(NULL);
12996
12997
0
    ctxt = xmlNewParserCtxt();
12998
0
    if (ctxt == NULL)
12999
0
  return(NULL);
13000
13001
0
    input = xmlCtxtNewInputFromMemory(ctxt, NULL, buffer, size, NULL, 0);
13002
0
    if (input == NULL) {
13003
0
  xmlFreeParserCtxt(ctxt);
13004
0
  return(NULL);
13005
0
    }
13006
0
    if (xmlCtxtPushInput(ctxt, input) < 0) {
13007
0
        xmlFreeInputStream(input);
13008
0
        xmlFreeParserCtxt(ctxt);
13009
0
        return(NULL);
13010
0
    }
13011
13012
0
    return(ctxt);
13013
0
}
13014
13015
#ifdef LIBXML_SAX1_ENABLED
13016
/**
13017
 * xmlSAXParseMemoryWithData:
13018
 * @sax:  the SAX handler block
13019
 * @buffer:  an pointer to a char array
13020
 * @size:  the size of the array
13021
 * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
13022
 *             documents
13023
 * @data:  the userdata
13024
 *
13025
 * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadMemory.
13026
 *
13027
 * parse an XML in-memory block and use the given SAX function block
13028
 * to handle the parsing callback. If sax is NULL, fallback to the default
13029
 * DOM tree building routines.
13030
 *
13031
 * User data (void *) is stored within the parser context in the
13032
 * context's _private member, so it is available nearly everywhere in libxml
13033
 *
13034
 * Returns the resulting document tree
13035
 */
13036
13037
xmlDocPtr
13038
xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer,
13039
                          int size, int recovery, void *data) {
13040
    xmlDocPtr ret = NULL;
13041
    xmlParserCtxtPtr ctxt;
13042
    xmlParserInputPtr input;
13043
13044
    if (size < 0)
13045
        return(NULL);
13046
13047
    ctxt = xmlNewSAXParserCtxt(sax, NULL);
13048
    if (ctxt == NULL)
13049
        return(NULL);
13050
13051
    if (data != NULL)
13052
  ctxt->_private=data;
13053
13054
    if (recovery) {
13055
        ctxt->options |= XML_PARSE_RECOVER;
13056
        ctxt->recovery = 1;
13057
    }
13058
13059
    input = xmlCtxtNewInputFromMemory(ctxt, NULL, buffer, size, NULL,
13060
                                      XML_INPUT_BUF_STATIC);
13061
13062
    if (input != NULL)
13063
        ret = xmlCtxtParseDocument(ctxt, input);
13064
13065
    xmlFreeParserCtxt(ctxt);
13066
    return(ret);
13067
}
13068
13069
/**
13070
 * xmlSAXParseMemory:
13071
 * @sax:  the SAX handler block
13072
 * @buffer:  an pointer to a char array
13073
 * @size:  the size of the array
13074
 * @recovery:  work in recovery mode, i.e. tries to read not Well Formed
13075
 *             documents
13076
 *
13077
 * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadMemory.
13078
 *
13079
 * parse an XML in-memory block and use the given SAX function block
13080
 * to handle the parsing callback. If sax is NULL, fallback to the default
13081
 * DOM tree building routines.
13082
 *
13083
 * Returns the resulting document tree
13084
 */
13085
xmlDocPtr
13086
xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer,
13087
            int size, int recovery) {
13088
    return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL);
13089
}
13090
13091
/**
13092
 * xmlParseMemory:
13093
 * @buffer:  an pointer to a char array
13094
 * @size:  the size of the array
13095
 *
13096
 * DEPRECATED: Use xmlReadMemory.
13097
 *
13098
 * parse an XML in-memory block and build a tree.
13099
 *
13100
 * Returns the resulting document tree
13101
 */
13102
13103
xmlDocPtr xmlParseMemory(const char *buffer, int size) {
13104
   return(xmlSAXParseMemory(NULL, buffer, size, 0));
13105
}
13106
13107
/**
13108
 * xmlRecoverMemory:
13109
 * @buffer:  an pointer to a char array
13110
 * @size:  the size of the array
13111
 *
13112
 * DEPRECATED: Use xmlReadMemory with XML_PARSE_RECOVER.
13113
 *
13114
 * parse an XML in-memory block and build a tree.
13115
 * In the case the document is not Well Formed, an attempt to
13116
 * build a tree is tried anyway
13117
 *
13118
 * Returns the resulting document tree or NULL in case of error
13119
 */
13120
13121
xmlDocPtr xmlRecoverMemory(const char *buffer, int size) {
13122
   return(xmlSAXParseMemory(NULL, buffer, size, 1));
13123
}
13124
13125
/**
13126
 * xmlSAXUserParseMemory:
13127
 * @sax:  a SAX handler
13128
 * @user_data:  The user data returned on SAX callbacks
13129
 * @buffer:  an in-memory XML document input
13130
 * @size:  the length of the XML document in bytes
13131
 *
13132
 * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadMemory.
13133
 *
13134
 * parse an XML in-memory buffer and call the given SAX handler routines.
13135
 *
13136
 * Returns 0 in case of success or a error number otherwise
13137
 */
13138
int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data,
13139
        const char *buffer, int size) {
13140
    int ret = 0;
13141
    xmlParserCtxtPtr ctxt;
13142
13143
    ctxt = xmlCreateMemoryParserCtxt(buffer, size);
13144
    if (ctxt == NULL) return -1;
13145
    if (sax != NULL) {
13146
        if (sax->initialized == XML_SAX2_MAGIC) {
13147
            *ctxt->sax = *sax;
13148
        } else {
13149
            memset(ctxt->sax, 0, sizeof(*ctxt->sax));
13150
            memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
13151
        }
13152
  ctxt->userData = user_data;
13153
    }
13154
13155
    xmlParseDocument(ctxt);
13156
13157
    if (ctxt->wellFormed)
13158
  ret = 0;
13159
    else {
13160
        if (ctxt->errNo != 0)
13161
      ret = ctxt->errNo;
13162
  else
13163
      ret = -1;
13164
    }
13165
    if (ctxt->myDoc != NULL) {
13166
        xmlFreeDoc(ctxt->myDoc);
13167
  ctxt->myDoc = NULL;
13168
    }
13169
    xmlFreeParserCtxt(ctxt);
13170
13171
    return ret;
13172
}
13173
#endif /* LIBXML_SAX1_ENABLED */
13174
13175
/**
13176
 * xmlCreateDocParserCtxt:
13177
 * @str:  a pointer to an array of xmlChar
13178
 *
13179
 * Creates a parser context for an XML in-memory document.
13180
 *
13181
 * Returns the new parser context or NULL
13182
 */
13183
xmlParserCtxtPtr
13184
0
xmlCreateDocParserCtxt(const xmlChar *str) {
13185
0
    xmlParserCtxtPtr ctxt;
13186
0
    xmlParserInputPtr input;
13187
13188
0
    ctxt = xmlNewParserCtxt();
13189
0
    if (ctxt == NULL)
13190
0
  return(NULL);
13191
13192
0
    input = xmlCtxtNewInputFromString(ctxt, NULL, (const char *) str, NULL, 0);
13193
0
    if (input == NULL) {
13194
0
  xmlFreeParserCtxt(ctxt);
13195
0
  return(NULL);
13196
0
    }
13197
0
    if (xmlCtxtPushInput(ctxt, input) < 0) {
13198
0
        xmlFreeInputStream(input);
13199
0
        xmlFreeParserCtxt(ctxt);
13200
0
        return(NULL);
13201
0
    }
13202
13203
0
    return(ctxt);
13204
0
}
13205
13206
#ifdef LIBXML_SAX1_ENABLED
13207
/**
13208
 * xmlSAXParseDoc:
13209
 * @sax:  the SAX handler block
13210
 * @cur:  a pointer to an array of xmlChar
13211
 * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
13212
 *             documents
13213
 *
13214
 * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadDoc.
13215
 *
13216
 * parse an XML in-memory document and build a tree.
13217
 * It use the given SAX function block to handle the parsing callback.
13218
 * If sax is NULL, fallback to the default DOM tree building routines.
13219
 *
13220
 * Returns the resulting document tree
13221
 */
13222
13223
xmlDocPtr
13224
xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) {
13225
    xmlDocPtr ret;
13226
    xmlParserCtxtPtr ctxt;
13227
    xmlSAXHandlerPtr oldsax = NULL;
13228
13229
    if (cur == NULL) return(NULL);
13230
13231
13232
    ctxt = xmlCreateDocParserCtxt(cur);
13233
    if (ctxt == NULL) return(NULL);
13234
    if (sax != NULL) {
13235
        oldsax = ctxt->sax;
13236
        ctxt->sax = sax;
13237
        ctxt->userData = NULL;
13238
    }
13239
13240
    xmlParseDocument(ctxt);
13241
    if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
13242
    else {
13243
       ret = NULL;
13244
       xmlFreeDoc(ctxt->myDoc);
13245
       ctxt->myDoc = NULL;
13246
    }
13247
    if (sax != NULL)
13248
  ctxt->sax = oldsax;
13249
    xmlFreeParserCtxt(ctxt);
13250
13251
    return(ret);
13252
}
13253
13254
/**
13255
 * xmlParseDoc:
13256
 * @cur:  a pointer to an array of xmlChar
13257
 *
13258
 * DEPRECATED: Use xmlReadDoc.
13259
 *
13260
 * parse an XML in-memory document and build a tree.
13261
 *
13262
 * Returns the resulting document tree
13263
 */
13264
13265
xmlDocPtr
13266
xmlParseDoc(const xmlChar *cur) {
13267
    return(xmlSAXParseDoc(NULL, cur, 0));
13268
}
13269
#endif /* LIBXML_SAX1_ENABLED */
13270
13271
/************************************************************************
13272
 *                  *
13273
 *  New set (2.6.0) of simpler and more flexible APIs   *
13274
 *                  *
13275
 ************************************************************************/
13276
13277
/**
13278
 * DICT_FREE:
13279
 * @str:  a string
13280
 *
13281
 * Free a string if it is not owned by the "dict" dictionary in the
13282
 * current scope
13283
 */
13284
#define DICT_FREE(str)            \
13285
0
  if ((str) && ((!dict) ||       \
13286
0
      (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))  \
13287
0
      xmlFree((char *)(str));
13288
13289
/**
13290
 * xmlCtxtReset:
13291
 * @ctxt: an XML parser context
13292
 *
13293
 * Reset a parser context
13294
 */
13295
void
13296
xmlCtxtReset(xmlParserCtxtPtr ctxt)
13297
0
{
13298
0
    xmlParserInputPtr input;
13299
0
    xmlDictPtr dict;
13300
13301
0
    if (ctxt == NULL)
13302
0
        return;
13303
13304
0
    dict = ctxt->dict;
13305
13306
0
    while ((input = xmlCtxtPopInput(ctxt)) != NULL) { /* Non consuming */
13307
0
        xmlFreeInputStream(input);
13308
0
    }
13309
0
    ctxt->inputNr = 0;
13310
0
    ctxt->input = NULL;
13311
13312
0
    ctxt->spaceNr = 0;
13313
0
    if (ctxt->spaceTab != NULL) {
13314
0
  ctxt->spaceTab[0] = -1;
13315
0
  ctxt->space = &ctxt->spaceTab[0];
13316
0
    } else {
13317
0
        ctxt->space = NULL;
13318
0
    }
13319
13320
13321
0
    ctxt->nodeNr = 0;
13322
0
    ctxt->node = NULL;
13323
13324
0
    ctxt->nameNr = 0;
13325
0
    ctxt->name = NULL;
13326
13327
0
    ctxt->nsNr = 0;
13328
0
    xmlParserNsReset(ctxt->nsdb);
13329
13330
0
    DICT_FREE(ctxt->version);
13331
0
    ctxt->version = NULL;
13332
0
    DICT_FREE(ctxt->encoding);
13333
0
    ctxt->encoding = NULL;
13334
0
    DICT_FREE(ctxt->extSubURI);
13335
0
    ctxt->extSubURI = NULL;
13336
0
    DICT_FREE(ctxt->extSubSystem);
13337
0
    ctxt->extSubSystem = NULL;
13338
13339
0
    if (ctxt->directory != NULL) {
13340
0
        xmlFree(ctxt->directory);
13341
0
        ctxt->directory = NULL;
13342
0
    }
13343
13344
0
    if (ctxt->myDoc != NULL)
13345
0
        xmlFreeDoc(ctxt->myDoc);
13346
0
    ctxt->myDoc = NULL;
13347
13348
0
    ctxt->standalone = -1;
13349
0
    ctxt->hasExternalSubset = 0;
13350
0
    ctxt->hasPErefs = 0;
13351
0
    ctxt->html = 0;
13352
0
    ctxt->instate = XML_PARSER_START;
13353
13354
0
    ctxt->wellFormed = 1;
13355
0
    ctxt->nsWellFormed = 1;
13356
0
    ctxt->disableSAX = 0;
13357
0
    ctxt->valid = 1;
13358
0
    ctxt->record_info = 0;
13359
0
    ctxt->checkIndex = 0;
13360
0
    ctxt->endCheckState = 0;
13361
0
    ctxt->inSubset = 0;
13362
0
    ctxt->errNo = XML_ERR_OK;
13363
0
    ctxt->depth = 0;
13364
0
    ctxt->catalogs = NULL;
13365
0
    ctxt->sizeentities = 0;
13366
0
    ctxt->sizeentcopy = 0;
13367
0
    xmlInitNodeInfoSeq(&ctxt->node_seq);
13368
13369
0
    if (ctxt->attsDefault != NULL) {
13370
0
        xmlHashFree(ctxt->attsDefault, xmlHashDefaultDeallocator);
13371
0
        ctxt->attsDefault = NULL;
13372
0
    }
13373
0
    if (ctxt->attsSpecial != NULL) {
13374
0
        xmlHashFree(ctxt->attsSpecial, NULL);
13375
0
        ctxt->attsSpecial = NULL;
13376
0
    }
13377
13378
0
#ifdef LIBXML_CATALOG_ENABLED
13379
0
    if (ctxt->catalogs != NULL)
13380
0
  xmlCatalogFreeLocal(ctxt->catalogs);
13381
0
#endif
13382
0
    ctxt->nbErrors = 0;
13383
0
    ctxt->nbWarnings = 0;
13384
0
    if (ctxt->lastError.code != XML_ERR_OK)
13385
0
        xmlResetError(&ctxt->lastError);
13386
0
}
13387
13388
/**
13389
 * xmlCtxtResetPush:
13390
 * @ctxt: an XML parser context
13391
 * @chunk:  a pointer to an array of chars
13392
 * @size:  number of chars in the array
13393
 * @filename:  an optional file name or URI
13394
 * @encoding:  the document encoding, or NULL
13395
 *
13396
 * Reset a push parser context
13397
 *
13398
 * Returns 0 in case of success and 1 in case of error
13399
 */
13400
int
13401
xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
13402
                 int size, const char *filename, const char *encoding)
13403
0
{
13404
0
    xmlParserInputPtr input;
13405
13406
0
    if (ctxt == NULL)
13407
0
        return(1);
13408
13409
0
    xmlCtxtReset(ctxt);
13410
13411
0
    input = xmlNewPushInput(filename, chunk, size);
13412
0
    if (input == NULL)
13413
0
        return(1);
13414
13415
0
    if (xmlCtxtPushInput(ctxt, input) < 0) {
13416
0
        xmlFreeInputStream(input);
13417
0
        return(1);
13418
0
    }
13419
13420
0
    if (encoding != NULL)
13421
0
        xmlSwitchEncodingName(ctxt, encoding);
13422
13423
0
    return(0);
13424
0
}
13425
13426
static int
13427
xmlCtxtSetOptionsInternal(xmlParserCtxtPtr ctxt, int options, int keepMask)
13428
312k
{
13429
312k
    int allMask;
13430
13431
312k
    if (ctxt == NULL)
13432
0
        return(-1);
13433
13434
    /*
13435
     * XInclude options aren't handled by the parser.
13436
     *
13437
     * XML_PARSE_XINCLUDE
13438
     * XML_PARSE_NOXINCNODE
13439
     * XML_PARSE_NOBASEFIX
13440
     */
13441
312k
    allMask = XML_PARSE_RECOVER |
13442
312k
              XML_PARSE_NOENT |
13443
312k
              XML_PARSE_DTDLOAD |
13444
312k
              XML_PARSE_DTDATTR |
13445
312k
              XML_PARSE_DTDVALID |
13446
312k
              XML_PARSE_NOERROR |
13447
312k
              XML_PARSE_NOWARNING |
13448
312k
              XML_PARSE_PEDANTIC |
13449
312k
              XML_PARSE_NOBLANKS |
13450
#ifdef LIBXML_SAX1_ENABLED
13451
              XML_PARSE_SAX1 |
13452
#endif
13453
312k
              XML_PARSE_NONET |
13454
312k
              XML_PARSE_NODICT |
13455
312k
              XML_PARSE_NSCLEAN |
13456
312k
              XML_PARSE_NOCDATA |
13457
312k
              XML_PARSE_COMPACT |
13458
312k
              XML_PARSE_OLD10 |
13459
312k
              XML_PARSE_HUGE |
13460
312k
              XML_PARSE_OLDSAX |
13461
312k
              XML_PARSE_IGNORE_ENC |
13462
312k
              XML_PARSE_BIG_LINES |
13463
312k
              XML_PARSE_NO_XXE |
13464
312k
              XML_PARSE_UNZIP |
13465
312k
              XML_PARSE_NO_SYS_CATALOG |
13466
312k
              XML_PARSE_CATALOG_PI;
13467
13468
312k
    ctxt->options = (ctxt->options & keepMask) | (options & allMask);
13469
13470
    /*
13471
     * For some options, struct members are historically the source
13472
     * of truth. The values are initalized from global variables and
13473
     * old code could also modify them directly. Several older API
13474
     * functions that don't take an options argument rely on these
13475
     * deprecated mechanisms.
13476
     *
13477
     * Once public access to struct members and the globals are
13478
     * disabled, we can use the options bitmask as source of
13479
     * truth, making all these struct members obsolete.
13480
     *
13481
     * The XML_DETECT_IDS flags is misnamed. It simply enables
13482
     * loading of the external subset.
13483
     */
13484
312k
    ctxt->recovery = (options & XML_PARSE_RECOVER) ? 1 : 0;
13485
312k
    ctxt->replaceEntities = (options & XML_PARSE_NOENT) ? 1 : 0;
13486
312k
    ctxt->loadsubset = (options & XML_PARSE_DTDLOAD) ? XML_DETECT_IDS : 0;
13487
312k
    ctxt->loadsubset |= (options & XML_PARSE_DTDATTR) ? XML_COMPLETE_ATTRS : 0;
13488
312k
    ctxt->validate = (options & XML_PARSE_DTDVALID) ? 1 : 0;
13489
312k
    ctxt->pedantic = (options & XML_PARSE_PEDANTIC) ? 1 : 0;
13490
312k
    ctxt->keepBlanks = (options & XML_PARSE_NOBLANKS) ? 0 : 1;
13491
312k
    ctxt->dictNames = (options & XML_PARSE_NODICT) ? 0 : 1;
13492
13493
312k
    if (options & XML_PARSE_HUGE) {
13494
0
        if (ctxt->dict != NULL)
13495
0
            xmlDictSetLimit(ctxt->dict, 0);
13496
0
    }
13497
13498
312k
    ctxt->linenumbers = 1;
13499
13500
312k
    return(options & ~allMask);
13501
312k
}
13502
13503
/**
13504
 * xmlCtxtSetOptions:
13505
 * @ctxt: an XML parser context
13506
 * @options:  a bitmask of xmlParserOption values
13507
 *
13508
 * Applies the options to the parser context. Unset options are
13509
 * cleared.
13510
 *
13511
 * Available since 2.13.0. With older versions, you can use
13512
 * xmlCtxtUseOptions.
13513
 *
13514
 * XML_PARSE_RECOVER
13515
 *
13516
 * Enable "recovery" mode which allows non-wellformed documents.
13517
 * How this mode behaves exactly is unspecified and may change
13518
 * without further notice. Use of this feature is DISCOURAGED.
13519
 *
13520
 * Not supported by the push parser.
13521
 *
13522
 * XML_PARSE_NOENT
13523
 *
13524
 * Despite the confusing name, this option enables substitution
13525
 * of entities. The resulting tree won't contain any entity
13526
 * reference nodes.
13527
 *
13528
 * This option also enables loading of external entities (both
13529
 * general and parameter entities) which is dangerous. If you
13530
 * process untrusted data, it's recommended to set the
13531
 * XML_PARSE_NO_XXE option to disable loading of external
13532
 * entities.
13533
 *
13534
 * XML_PARSE_DTDLOAD
13535
 *
13536
 * Enables loading of an external DTD and the loading and
13537
 * substitution of external parameter entities. Has no effect
13538
 * if XML_PARSE_NO_XXE is set.
13539
 *
13540
 * XML_PARSE_DTDATTR
13541
 *
13542
 * Adds default attributes from the DTD to the result document.
13543
 *
13544
 * Implies XML_PARSE_DTDLOAD, but loading of external content
13545
 * can be disabled with XML_PARSE_NO_XXE.
13546
 *
13547
 * XML_PARSE_DTDVALID
13548
 *
13549
 * This option enables DTD validation which requires to load
13550
 * external DTDs and external entities (both general and
13551
 * parameter entities) unless XML_PARSE_NO_XXE was set.
13552
 *
13553
 * XML_PARSE_NO_XXE
13554
 *
13555
 * Disables loading of external DTDs or entities.
13556
 *
13557
 * Available since 2.13.0.
13558
 *
13559
 * XML_PARSE_NOERROR
13560
 *
13561
 * Disable error and warning reports to the error handlers.
13562
 * Errors are still accessible with xmlCtxtGetLastError.
13563
 *
13564
 * XML_PARSE_NOWARNING
13565
 *
13566
 * Disable warning reports.
13567
 *
13568
 * XML_PARSE_PEDANTIC
13569
 *
13570
 * Enable some pedantic warnings.
13571
 *
13572
 * XML_PARSE_NOBLANKS
13573
 *
13574
 * Remove some whitespace from the result document. Where to
13575
 * remove whitespace depends on DTD element declarations or a
13576
 * broken heuristic with unfixable bugs. Use of this option is
13577
 * DISCOURAGED.
13578
 *
13579
 * Not supported by the push parser.
13580
 *
13581
 * XML_PARSE_SAX1
13582
 *
13583
 * Always invoke the deprecated SAX1 startElement and endElement
13584
 * handlers. This option is DEPRECATED.
13585
 *
13586
 * XML_PARSE_NONET
13587
 *
13588
 * Disable network access with the builtin HTTP client.
13589
 *
13590
 * XML_PARSE_NODICT
13591
 *
13592
 * Create a document without interned strings, making all
13593
 * strings separate memory allocations.
13594
 *
13595
 * XML_PARSE_NSCLEAN
13596
 *
13597
 * Remove redundant namespace declarations from the result
13598
 * document.
13599
 *
13600
 * XML_PARSE_NOCDATA
13601
 *
13602
 * Output normal text nodes instead of CDATA nodes.
13603
 *
13604
 * XML_PARSE_COMPACT
13605
 *
13606
 * Store small strings directly in the node struct to save
13607
 * memory.
13608
 *
13609
 * XML_PARSE_OLD10
13610
 *
13611
 * Use old Name productions from before XML 1.0 Fifth Edition.
13612
 * This options is DEPRECATED.
13613
 *
13614
 * XML_PARSE_HUGE
13615
 *
13616
 * Relax some internal limits.
13617
 *
13618
 * Maximum size of text nodes, tags, comments, processing instructions,
13619
 * CDATA sections, entity values
13620
 *
13621
 * normal: 10M
13622
 * huge:    1B
13623
 *
13624
 * Maximum size of names, system literals, pubid literals
13625
 *
13626
 * normal: 50K
13627
 * huge:   10M
13628
 *
13629
 * Maximum nesting depth of elements
13630
 *
13631
 * normal:  256
13632
 * huge:   2048
13633
 *
13634
 * Maximum nesting depth of entities
13635
 *
13636
 * normal: 20
13637
 * huge:   40
13638
 *
13639
 * XML_PARSE_OLDSAX
13640
 *
13641
 * Enable an unspecified legacy mode for SAX parsers. This
13642
 * option is DEPRECATED.
13643
 *
13644
 * XML_PARSE_IGNORE_ENC
13645
 *
13646
 * Ignore the encoding in the XML declaration. This option is
13647
 * mostly unneeded these days. The only effect is to enforce
13648
 * UTF-8 decoding of ASCII-like data.
13649
 *
13650
 * XML_PARSE_BIG_LINES
13651
 *
13652
 * Enable reporting of line numbers larger than 65535.
13653
 *
13654
 * XML_PARSE_UNZIP
13655
 *
13656
 * Enable input decompression. Setting this option is discouraged
13657
 * to avoid zip bombs.
13658
 *
13659
 * Available since 2.14.0.
13660
 *
13661
 * XML_PARSE_NO_SYS_CATALOG
13662
 *
13663
 * Disables the global system XML catalog.
13664
 *
13665
 * Available since 2.14.0.
13666
 *
13667
 * XML_PARSE_CATALOG_PI
13668
 *
13669
 * Enable XML catalog processing instructions.
13670
 *
13671
 * Available since 2.14.0.
13672
 *
13673
 * Returns 0 in case of success, the set of unknown or unimplemented options
13674
 *         in case of error.
13675
 */
13676
int
13677
xmlCtxtSetOptions(xmlParserCtxtPtr ctxt, int options)
13678
0
{
13679
0
#ifdef LIBXML_HTML_ENABLED
13680
0
    if ((ctxt != NULL) && (ctxt->html))
13681
0
        return(htmlCtxtSetOptions(ctxt, options));
13682
0
#endif
13683
13684
0
    return(xmlCtxtSetOptionsInternal(ctxt, options, 0));
13685
0
}
13686
13687
/**
13688
 * xmlCtxtGetOptions:
13689
 * @ctxt: an XML parser context
13690
 *
13691
 * Get the current options of the parser context.
13692
 *
13693
 * Available since 2.14.0.
13694
 *
13695
 * Returns the current options set in the parser context, or -1 if ctxt is NULL.
13696
 */
13697
int
13698
xmlCtxtGetOptions(xmlParserCtxtPtr ctxt)
13699
0
{
13700
0
    if (ctxt == NULL)
13701
0
        return(-1);
13702
13703
0
    return(ctxt->options);
13704
0
}
13705
13706
/**
13707
 * xmlCtxtUseOptions:
13708
 * @ctxt: an XML parser context
13709
 * @options:  a combination of xmlParserOption
13710
 *
13711
 * DEPRECATED: Use xmlCtxtSetOptions.
13712
 *
13713
 * Applies the options to the parser context. The following options
13714
 * are never cleared and can only be enabled:
13715
 *
13716
 * XML_PARSE_NOERROR
13717
 * XML_PARSE_NOWARNING
13718
 * XML_PARSE_NONET
13719
 * XML_PARSE_NSCLEAN
13720
 * XML_PARSE_NOCDATA
13721
 * XML_PARSE_COMPACT
13722
 * XML_PARSE_OLD10
13723
 * XML_PARSE_HUGE
13724
 * XML_PARSE_OLDSAX
13725
 * XML_PARSE_IGNORE_ENC
13726
 * XML_PARSE_BIG_LINES
13727
 *
13728
 * Returns 0 in case of success, the set of unknown or unimplemented options
13729
 *         in case of error.
13730
 */
13731
int
13732
xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
13733
312k
{
13734
312k
    int keepMask;
13735
13736
312k
#ifdef LIBXML_HTML_ENABLED
13737
312k
    if ((ctxt != NULL) && (ctxt->html))
13738
0
        return(htmlCtxtUseOptions(ctxt, options));
13739
312k
#endif
13740
13741
    /*
13742
     * For historic reasons, some options can only be enabled.
13743
     */
13744
312k
    keepMask = XML_PARSE_NOERROR |
13745
312k
               XML_PARSE_NOWARNING |
13746
312k
               XML_PARSE_NONET |
13747
312k
               XML_PARSE_NSCLEAN |
13748
312k
               XML_PARSE_NOCDATA |
13749
312k
               XML_PARSE_COMPACT |
13750
312k
               XML_PARSE_OLD10 |
13751
312k
               XML_PARSE_HUGE |
13752
312k
               XML_PARSE_OLDSAX |
13753
312k
               XML_PARSE_IGNORE_ENC |
13754
312k
               XML_PARSE_BIG_LINES;
13755
13756
312k
    return(xmlCtxtSetOptionsInternal(ctxt, options, keepMask));
13757
312k
}
13758
13759
/**
13760
 * xmlCtxtSetMaxAmplification:
13761
 * @ctxt: an XML parser context
13762
 * @maxAmpl:  maximum amplification factor
13763
 *
13764
 * To protect against exponential entity expansion ("billion laughs"), the
13765
 * size of serialized output is (roughly) limited to the input size
13766
 * multiplied by this factor. The default value is 5.
13767
 *
13768
 * When working with documents making heavy use of entity expansion, it can
13769
 * be necessary to increase the value. For security reasons, this should only
13770
 * be considered when processing trusted input.
13771
 */
13772
void
13773
xmlCtxtSetMaxAmplification(xmlParserCtxtPtr ctxt, unsigned maxAmpl)
13774
0
{
13775
0
    ctxt->maxAmpl = maxAmpl;
13776
0
}
13777
13778
/**
13779
 * xmlCtxtParseDocument:
13780
 * @ctxt:  an XML parser context
13781
 * @input:  parser input
13782
 *
13783
 * Parse an XML document and return the resulting document tree.
13784
 * Takes ownership of the input object.
13785
 *
13786
 * Available since 2.13.0.
13787
 *
13788
 * Returns the resulting document tree or NULL
13789
 */
13790
xmlDocPtr
13791
xmlCtxtParseDocument(xmlParserCtxtPtr ctxt, xmlParserInputPtr input)
13792
267k
{
13793
267k
    xmlDocPtr ret = NULL;
13794
13795
267k
    if ((ctxt == NULL) || (input == NULL)) {
13796
0
        xmlFatalErr(ctxt, XML_ERR_ARGUMENT, NULL);
13797
0
        xmlFreeInputStream(input);
13798
0
        return(NULL);
13799
0
    }
13800
13801
    /* assert(ctxt->inputNr == 0); */
13802
267k
    while (ctxt->inputNr > 0)
13803
0
        xmlFreeInputStream(xmlCtxtPopInput(ctxt));
13804
13805
267k
    if (xmlCtxtPushInput(ctxt, input) < 0) {
13806
0
        xmlFreeInputStream(input);
13807
0
        return(NULL);
13808
0
    }
13809
13810
267k
    xmlParseDocument(ctxt);
13811
13812
267k
    ret = xmlCtxtGetDocument(ctxt);
13813
13814
    /* assert(ctxt->inputNr == 1); */
13815
535k
    while (ctxt->inputNr > 0)
13816
267k
        xmlFreeInputStream(xmlCtxtPopInput(ctxt));
13817
13818
267k
    return(ret);
13819
267k
}
13820
13821
/**
13822
 * xmlReadDoc:
13823
 * @cur:  a pointer to a zero terminated string
13824
 * @URL:  base URL (optional)
13825
 * @encoding:  the document encoding (optional)
13826
 * @options:  a combination of xmlParserOption
13827
 *
13828
 * Convenience function to parse an XML document from a
13829
 * zero-terminated string.
13830
 *
13831
 * See xmlCtxtReadDoc for details.
13832
 *
13833
 * Returns the resulting document tree
13834
 */
13835
xmlDocPtr
13836
xmlReadDoc(const xmlChar *cur, const char *URL, const char *encoding,
13837
           int options)
13838
0
{
13839
0
    xmlParserCtxtPtr ctxt;
13840
0
    xmlParserInputPtr input;
13841
0
    xmlDocPtr doc = NULL;
13842
13843
0
    ctxt = xmlNewParserCtxt();
13844
0
    if (ctxt == NULL)
13845
0
        return(NULL);
13846
13847
0
    xmlCtxtUseOptions(ctxt, options);
13848
13849
0
    input = xmlCtxtNewInputFromString(ctxt, URL, (const char *) cur, encoding,
13850
0
                                      XML_INPUT_BUF_STATIC);
13851
13852
0
    if (input != NULL)
13853
0
        doc = xmlCtxtParseDocument(ctxt, input);
13854
13855
0
    xmlFreeParserCtxt(ctxt);
13856
0
    return(doc);
13857
0
}
13858
13859
/**
13860
 * xmlReadFile:
13861
 * @filename:  a file or URL
13862
 * @encoding:  the document encoding (optional)
13863
 * @options:  a combination of xmlParserOption
13864
 *
13865
 * Convenience function to parse an XML file from the filesystem,
13866
 * the network or a global user-define resource loader.
13867
 *
13868
 * This function always enables the XML_PARSE_UNZIP option for
13869
 * backward compatibility. If a "-" filename is passed, it will
13870
 * read from stdin. Both of these features are potentially
13871
 * insecure and might be removed from later versions.
13872
 *
13873
 * See xmlCtxtReadFile for details.
13874
 *
13875
 * Returns the resulting document tree
13876
 */
13877
xmlDocPtr
13878
xmlReadFile(const char *filename, const char *encoding, int options)
13879
0
{
13880
0
    xmlParserCtxtPtr ctxt;
13881
0
    xmlParserInputPtr input;
13882
0
    xmlDocPtr doc = NULL;
13883
13884
0
    ctxt = xmlNewParserCtxt();
13885
0
    if (ctxt == NULL)
13886
0
        return(NULL);
13887
13888
0
    options |= XML_PARSE_UNZIP;
13889
13890
0
    xmlCtxtUseOptions(ctxt, options);
13891
13892
    /*
13893
     * Backward compatibility for users of command line utilities like
13894
     * xmlstarlet expecting "-" to mean stdin. This is dangerous and
13895
     * should be removed at some point.
13896
     */
13897
0
    if ((filename != NULL) && (filename[0] == '-') && (filename[1] == 0))
13898
0
        input = xmlCtxtNewInputFromFd(ctxt, filename, STDIN_FILENO,
13899
0
                                      encoding, 0);
13900
0
    else
13901
0
        input = xmlCtxtNewInputFromUrl(ctxt, filename, NULL, encoding, 0);
13902
13903
0
    if (input != NULL)
13904
0
        doc = xmlCtxtParseDocument(ctxt, input);
13905
13906
0
    xmlFreeParserCtxt(ctxt);
13907
0
    return(doc);
13908
0
}
13909
13910
/**
13911
 * xmlReadMemory:
13912
 * @buffer:  a pointer to a char array
13913
 * @size:  the size of the array
13914
 * @url:  base URL (optional)
13915
 * @encoding:  the document encoding (optional)
13916
 * @options:  a combination of xmlParserOption
13917
 *
13918
 * Parse an XML in-memory document and build a tree. The input buffer must
13919
 * not contain a terminating null byte.
13920
 *
13921
 * See xmlCtxtReadMemory for details.
13922
 *
13923
 * Returns the resulting document tree
13924
 */
13925
xmlDocPtr
13926
xmlReadMemory(const char *buffer, int size, const char *url,
13927
              const char *encoding, int options)
13928
35.0k
{
13929
35.0k
    xmlParserCtxtPtr ctxt;
13930
35.0k
    xmlParserInputPtr input;
13931
35.0k
    xmlDocPtr doc = NULL;
13932
13933
35.0k
    if (size < 0)
13934
0
  return(NULL);
13935
13936
35.0k
    ctxt = xmlNewParserCtxt();
13937
35.0k
    if (ctxt == NULL)
13938
0
        return(NULL);
13939
13940
35.0k
    xmlCtxtUseOptions(ctxt, options);
13941
13942
35.0k
    input = xmlCtxtNewInputFromMemory(ctxt, url, buffer, size, encoding,
13943
35.0k
                                      XML_INPUT_BUF_STATIC);
13944
13945
35.0k
    if (input != NULL)
13946
35.0k
        doc = xmlCtxtParseDocument(ctxt, input);
13947
13948
35.0k
    xmlFreeParserCtxt(ctxt);
13949
35.0k
    return(doc);
13950
35.0k
}
13951
13952
/**
13953
 * xmlReadFd:
13954
 * @fd:  an open file descriptor
13955
 * @URL:  base URL (optional)
13956
 * @encoding:  the document encoding (optional)
13957
 * @options:  a combination of xmlParserOption
13958
 *
13959
 * Parse an XML from a file descriptor and build a tree.
13960
 *
13961
 * See xmlCtxtReadFd for details.
13962
 *
13963
 * NOTE that the file descriptor will not be closed when the
13964
 * context is freed or reset.
13965
 *
13966
 * Returns the resulting document tree
13967
 */
13968
xmlDocPtr
13969
xmlReadFd(int fd, const char *URL, const char *encoding, int options)
13970
0
{
13971
0
    xmlParserCtxtPtr ctxt;
13972
0
    xmlParserInputPtr input;
13973
0
    xmlDocPtr doc = NULL;
13974
13975
0
    ctxt = xmlNewParserCtxt();
13976
0
    if (ctxt == NULL)
13977
0
        return(NULL);
13978
13979
0
    xmlCtxtUseOptions(ctxt, options);
13980
13981
0
    input = xmlCtxtNewInputFromFd(ctxt, URL, fd, encoding, 0);
13982
13983
0
    if (input != NULL)
13984
0
        doc = xmlCtxtParseDocument(ctxt, input);
13985
13986
0
    xmlFreeParserCtxt(ctxt);
13987
0
    return(doc);
13988
0
}
13989
13990
/**
13991
 * xmlReadIO:
13992
 * @ioread:  an I/O read function
13993
 * @ioclose:  an I/O close function (optional)
13994
 * @ioctx:  an I/O handler
13995
 * @URL:  base URL (optional)
13996
 * @encoding:  the document encoding (optional)
13997
 * @options:  a combination of xmlParserOption
13998
 *
13999
 * Parse an XML document from I/O functions and context and build a tree.
14000
 *
14001
 * See xmlCtxtReadIO for details.
14002
 *
14003
 * Returns the resulting document tree
14004
 */
14005
xmlDocPtr
14006
xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
14007
          void *ioctx, const char *URL, const char *encoding, int options)
14008
0
{
14009
0
    xmlParserCtxtPtr ctxt;
14010
0
    xmlParserInputPtr input;
14011
0
    xmlDocPtr doc = NULL;
14012
14013
0
    ctxt = xmlNewParserCtxt();
14014
0
    if (ctxt == NULL)
14015
0
        return(NULL);
14016
14017
0
    xmlCtxtUseOptions(ctxt, options);
14018
14019
0
    input = xmlCtxtNewInputFromIO(ctxt, URL, ioread, ioclose, ioctx,
14020
0
                                  encoding, 0);
14021
14022
0
    if (input != NULL)
14023
0
        doc = xmlCtxtParseDocument(ctxt, input);
14024
14025
0
    xmlFreeParserCtxt(ctxt);
14026
0
    return(doc);
14027
0
}
14028
14029
/**
14030
 * xmlCtxtReadDoc:
14031
 * @ctxt:  an XML parser context
14032
 * @str:  a pointer to a zero terminated string
14033
 * @URL:  base URL (optional)
14034
 * @encoding:  the document encoding (optional)
14035
 * @options:  a combination of xmlParserOption
14036
 *
14037
 * Parse an XML in-memory document and build a tree.
14038
 *
14039
 * @URL is used as base to resolve external entities and for error
14040
 * reporting.
14041
 *
14042
 * See xmlCtxtUseOptions for details.
14043
 *
14044
 * Returns the resulting document tree
14045
 */
14046
xmlDocPtr
14047
xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar *str,
14048
               const char *URL, const char *encoding, int options)
14049
0
{
14050
0
    xmlParserInputPtr input;
14051
14052
0
    if (ctxt == NULL)
14053
0
        return(NULL);
14054
14055
0
    xmlCtxtReset(ctxt);
14056
0
    xmlCtxtUseOptions(ctxt, options);
14057
14058
0
    input = xmlCtxtNewInputFromString(ctxt, URL, (const char *) str, encoding,
14059
0
                                      XML_INPUT_BUF_STATIC);
14060
0
    if (input == NULL)
14061
0
        return(NULL);
14062
14063
0
    return(xmlCtxtParseDocument(ctxt, input));
14064
0
}
14065
14066
/**
14067
 * xmlCtxtReadFile:
14068
 * @ctxt:  an XML parser context
14069
 * @filename:  a file or URL
14070
 * @encoding:  the document encoding (optional)
14071
 * @options:  a combination of xmlParserOption
14072
 *
14073
 * Parse an XML file from the filesystem, the network or a user-defined
14074
 * resource loader.
14075
 *
14076
 * This function always enables the XML_PARSE_UNZIP option for
14077
 * backward compatibility. This feature is potentially insecure
14078
 * and might be removed from later versions.
14079
 *
14080
 * Returns the resulting document tree
14081
 */
14082
xmlDocPtr
14083
xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
14084
                const char *encoding, int options)
14085
0
{
14086
0
    xmlParserInputPtr input;
14087
14088
0
    if (ctxt == NULL)
14089
0
        return(NULL);
14090
14091
0
    options |= XML_PARSE_UNZIP;
14092
14093
0
    xmlCtxtReset(ctxt);
14094
0
    xmlCtxtUseOptions(ctxt, options);
14095
14096
0
    input = xmlCtxtNewInputFromUrl(ctxt, filename, NULL, encoding, 0);
14097
0
    if (input == NULL)
14098
0
        return(NULL);
14099
14100
0
    return(xmlCtxtParseDocument(ctxt, input));
14101
0
}
14102
14103
/**
14104
 * xmlCtxtReadMemory:
14105
 * @ctxt:  an XML parser context
14106
 * @buffer:  a pointer to a char array
14107
 * @size:  the size of the array
14108
 * @URL:  base URL (optional)
14109
 * @encoding:  the document encoding (optional)
14110
 * @options:  a combination of xmlParserOption
14111
 *
14112
 * Parse an XML in-memory document and build a tree. The input buffer must
14113
 * not contain a terminating null byte.
14114
 *
14115
 * @URL is used as base to resolve external entities and for error
14116
 * reporting.
14117
 *
14118
 * See xmlCtxtUseOptions for details.
14119
 *
14120
 * Returns the resulting document tree
14121
 */
14122
xmlDocPtr
14123
xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
14124
                  const char *URL, const char *encoding, int options)
14125
0
{
14126
0
    xmlParserInputPtr input;
14127
14128
0
    if ((ctxt == NULL) || (size < 0))
14129
0
        return(NULL);
14130
14131
0
    xmlCtxtReset(ctxt);
14132
0
    xmlCtxtUseOptions(ctxt, options);
14133
14134
0
    input = xmlCtxtNewInputFromMemory(ctxt, URL, buffer, size, encoding,
14135
0
                                      XML_INPUT_BUF_STATIC);
14136
0
    if (input == NULL)
14137
0
        return(NULL);
14138
14139
0
    return(xmlCtxtParseDocument(ctxt, input));
14140
0
}
14141
14142
/**
14143
 * xmlCtxtReadFd:
14144
 * @ctxt:  an XML parser context
14145
 * @fd:  an open file descriptor
14146
 * @URL:  base URL (optional)
14147
 * @encoding:  the document encoding (optional)
14148
 * @options:  a combination of xmlParserOption
14149
 *
14150
 * Parse an XML document from a file descriptor and build a tree.
14151
 *
14152
 * NOTE that the file descriptor will not be closed when the
14153
 * context is freed or reset.
14154
 *
14155
 * @URL is used as base to resolve external entities and for error
14156
 * reporting.
14157
 *
14158
 * See xmlCtxtUseOptions for details.
14159
 *
14160
 * Returns the resulting document tree
14161
 */
14162
xmlDocPtr
14163
xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
14164
              const char *URL, const char *encoding, int options)
14165
0
{
14166
0
    xmlParserInputPtr input;
14167
14168
0
    if (ctxt == NULL)
14169
0
        return(NULL);
14170
14171
0
    xmlCtxtReset(ctxt);
14172
0
    xmlCtxtUseOptions(ctxt, options);
14173
14174
0
    input = xmlCtxtNewInputFromFd(ctxt, URL, fd, encoding, 0);
14175
0
    if (input == NULL)
14176
0
        return(NULL);
14177
14178
0
    return(xmlCtxtParseDocument(ctxt, input));
14179
0
}
14180
14181
/**
14182
 * xmlCtxtReadIO:
14183
 * @ctxt:  an XML parser context
14184
 * @ioread:  an I/O read function
14185
 * @ioclose:  an I/O close function
14186
 * @ioctx:  an I/O handler
14187
 * @URL:  the base URL to use for the document
14188
 * @encoding:  the document encoding, or NULL
14189
 * @options:  a combination of xmlParserOption
14190
 *
14191
 * parse an XML document from I/O functions and source and build a tree.
14192
 * This reuses the existing @ctxt parser context
14193
 *
14194
 * @URL is used as base to resolve external entities and for error
14195
 * reporting.
14196
 *
14197
 * See xmlCtxtUseOptions for details.
14198
 *
14199
 * Returns the resulting document tree
14200
 */
14201
xmlDocPtr
14202
xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
14203
              xmlInputCloseCallback ioclose, void *ioctx,
14204
        const char *URL,
14205
              const char *encoding, int options)
14206
0
{
14207
0
    xmlParserInputPtr input;
14208
14209
0
    if (ctxt == NULL)
14210
0
        return(NULL);
14211
14212
0
    xmlCtxtReset(ctxt);
14213
0
    xmlCtxtUseOptions(ctxt, options);
14214
14215
0
    input = xmlCtxtNewInputFromIO(ctxt, URL, ioread, ioclose, ioctx,
14216
0
                                  encoding, 0);
14217
0
    if (input == NULL)
14218
0
        return(NULL);
14219
14220
0
    return(xmlCtxtParseDocument(ctxt, input));
14221
0
}
14222