Coverage Report

Created: 2024-01-20 12:30

/src/libxml2/SAX2.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * SAX2.c : Default SAX2 handler to build a tree.
3
 *
4
 * See Copyright for the status of this software.
5
 *
6
 * Daniel Veillard <daniel@veillard.com>
7
 */
8
9
10
#define IN_LIBXML
11
#include "libxml.h"
12
#include <stdlib.h>
13
#include <string.h>
14
#include <limits.h>
15
#include <stddef.h>
16
#include <libxml/xmlmemory.h>
17
#include <libxml/tree.h>
18
#include <libxml/parser.h>
19
#include <libxml/parserInternals.h>
20
#include <libxml/valid.h>
21
#include <libxml/entities.h>
22
#include <libxml/xmlerror.h>
23
#include <libxml/debugXML.h>
24
#include <libxml/xmlIO.h>
25
#include <libxml/SAX.h>
26
#include <libxml/uri.h>
27
#include <libxml/valid.h>
28
#include <libxml/HTMLtree.h>
29
#include <libxml/globals.h>
30
31
#include "private/error.h"
32
#include "private/parser.h"
33
#include "private/tree.h"
34
35
/* #define DEBUG_SAX2 */
36
/* #define DEBUG_SAX2_TREE */
37
38
/**
39
 * TODO:
40
 *
41
 * macro to flag unimplemented blocks
42
 * XML_CATALOG_PREFER user env to select between system/public preferred
43
 * option. C.f. Richard Tobin <richard@cogsci.ed.ac.uk>
44
 *> Just FYI, I am using an environment variable XML_CATALOG_PREFER with
45
 *> values "system" and "public".  I have made the default be "system" to
46
 *> match yours.
47
 */
48
#define TODO                \
49
    xmlGenericError(xmlGenericErrorContext,       \
50
      "Unimplemented block at %s:%d\n",       \
51
            __FILE__, __LINE__);
52
53
/*
54
 * xmlSAX2ErrMemory:
55
 * @ctxt:  an XML validation parser context
56
 * @msg:   a string to accompany the error message
57
 */
58
static void LIBXML_ATTR_FORMAT(2,0)
59
0
xmlSAX2ErrMemory(xmlParserCtxtPtr ctxt, const char *msg) {
60
0
    xmlStructuredErrorFunc schannel = NULL;
61
0
    const char *str1 = "out of memory\n";
62
63
0
    if (ctxt != NULL) {
64
0
  ctxt->errNo = XML_ERR_NO_MEMORY;
65
0
  if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
66
0
      schannel = ctxt->sax->serror;
67
0
  __xmlRaiseError(schannel,
68
0
      ctxt->vctxt.error, ctxt->vctxt.userData,
69
0
      ctxt, NULL, XML_FROM_PARSER, XML_ERR_NO_MEMORY,
70
0
      XML_ERR_ERROR, NULL, 0, (const char *) str1,
71
0
      NULL, NULL, 0, 0,
72
0
      msg, (const char *) str1, NULL);
73
0
  ctxt->errNo = XML_ERR_NO_MEMORY;
74
0
  ctxt->instate = XML_PARSER_EOF;
75
0
  ctxt->disableSAX = 1;
76
0
    } else {
77
0
  __xmlRaiseError(schannel,
78
0
      NULL, NULL,
79
0
      ctxt, NULL, XML_FROM_PARSER, XML_ERR_NO_MEMORY,
80
0
      XML_ERR_ERROR, NULL, 0, (const char *) str1,
81
0
      NULL, NULL, 0, 0,
82
0
      msg, (const char *) str1, NULL);
83
0
    }
84
0
}
85
86
/**
87
 * xmlValidError:
88
 * @ctxt:  an XML validation parser context
89
 * @error:  the error number
90
 * @msg:  the error message
91
 * @str1:  extra data
92
 * @str2:  extra data
93
 *
94
 * Handle a validation error
95
 */
96
static void LIBXML_ATTR_FORMAT(3,0)
97
xmlErrValid(xmlParserCtxtPtr ctxt, xmlParserErrors error,
98
            const char *msg, const char *str1, const char *str2)
99
136k
{
100
136k
    xmlStructuredErrorFunc schannel = NULL;
101
102
136k
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
103
136k
        (ctxt->instate == XML_PARSER_EOF))
104
0
  return;
105
136k
    if (ctxt != NULL) {
106
136k
  ctxt->errNo = error;
107
136k
  if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
108
72.1k
      schannel = ctxt->sax->serror;
109
136k
  __xmlRaiseError(schannel,
110
136k
      ctxt->vctxt.error, ctxt->vctxt.userData,
111
136k
      ctxt, NULL, XML_FROM_DTD, error,
112
136k
      XML_ERR_ERROR, NULL, 0, (const char *) str1,
113
136k
      (const char *) str2, NULL, 0, 0,
114
136k
      msg, (const char *) str1, (const char *) str2);
115
136k
  ctxt->valid = 0;
116
136k
    } else {
117
0
  __xmlRaiseError(schannel,
118
0
      NULL, NULL,
119
0
      ctxt, NULL, XML_FROM_DTD, error,
120
0
      XML_ERR_ERROR, NULL, 0, (const char *) str1,
121
0
      (const char *) str2, NULL, 0, 0,
122
0
      msg, (const char *) str1, (const char *) str2);
123
0
    }
124
136k
}
125
126
/**
127
 * xmlFatalErrMsg:
128
 * @ctxt:  an XML parser context
129
 * @error:  the error number
130
 * @msg:  the error message
131
 * @str1:  an error string
132
 * @str2:  an error string
133
 *
134
 * Handle a fatal parser error, i.e. violating Well-Formedness constraints
135
 */
136
static void LIBXML_ATTR_FORMAT(3,0)
137
xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
138
               const char *msg, const xmlChar *str1, const xmlChar *str2)
139
1.38k
{
140
1.38k
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
141
1.38k
        (ctxt->instate == XML_PARSER_EOF))
142
0
  return;
143
1.38k
    if (ctxt != NULL)
144
1.38k
  ctxt->errNo = error;
145
1.38k
    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
146
1.38k
                    XML_ERR_FATAL, NULL, 0,
147
1.38k
        (const char *) str1, (const char *) str2,
148
1.38k
        NULL, 0, 0, msg, str1, str2);
149
1.38k
    if (ctxt != NULL) {
150
1.38k
  ctxt->wellFormed = 0;
151
1.38k
  ctxt->valid = 0;
152
1.38k
  if (ctxt->recovery == 0)
153
943
      ctxt->disableSAX = 1;
154
1.38k
    }
155
1.38k
}
156
157
/**
158
 * xmlWarnMsg:
159
 * @ctxt:  an XML parser context
160
 * @error:  the error number
161
 * @msg:  the error message
162
 * @str1:  an error string
163
 * @str2:  an error string
164
 *
165
 * Handle a parser warning
166
 */
167
static void LIBXML_ATTR_FORMAT(3,0)
168
xmlWarnMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
169
               const char *msg, const xmlChar *str1)
170
9.82k
{
171
9.82k
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
172
9.82k
        (ctxt->instate == XML_PARSER_EOF))
173
0
  return;
174
9.82k
    if (ctxt != NULL)
175
9.82k
  ctxt->errNo = error;
176
9.82k
    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
177
9.82k
                    XML_ERR_WARNING, NULL, 0,
178
9.82k
        (const char *) str1, NULL,
179
9.82k
        NULL, 0, 0, msg, str1);
180
9.82k
}
181
182
/**
183
 * xmlNsWarnMsg:
184
 * @ctxt:  an XML parser context
185
 * @error:  the error number
186
 * @msg:  the error message
187
 * @str1:  an error string
188
 *
189
 * Handle a namespace warning
190
 */
191
static void LIBXML_ATTR_FORMAT(3,0)
192
xmlNsWarnMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
193
             const char *msg, const xmlChar *str1, const xmlChar *str2)
194
1.10M
{
195
1.10M
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
196
1.10M
        (ctxt->instate == XML_PARSER_EOF))
197
0
  return;
198
1.10M
    if (ctxt != NULL)
199
1.10M
  ctxt->errNo = error;
200
1.10M
    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
201
1.10M
                    XML_ERR_WARNING, NULL, 0,
202
1.10M
        (const char *) str1, (const char *) str2,
203
1.10M
        NULL, 0, 0, msg, str1, str2);
204
1.10M
}
205
206
/**
207
 * xmlSAX2GetPublicId:
208
 * @ctx: the user data (XML parser context)
209
 *
210
 * Provides the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN"
211
 *
212
 * Returns a xmlChar *
213
 */
214
const xmlChar *
215
xmlSAX2GetPublicId(void *ctx ATTRIBUTE_UNUSED)
216
0
{
217
    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
218
0
    return(NULL);
219
0
}
220
221
/**
222
 * xmlSAX2GetSystemId:
223
 * @ctx: the user data (XML parser context)
224
 *
225
 * Provides the system ID, basically URL or filename e.g.
226
 * http://www.sgmlsource.com/dtds/memo.dtd
227
 *
228
 * Returns a xmlChar *
229
 */
230
const xmlChar *
231
xmlSAX2GetSystemId(void *ctx)
232
0
{
233
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
234
0
    if ((ctx == NULL) || (ctxt->input == NULL)) return(NULL);
235
0
    return((const xmlChar *) ctxt->input->filename);
236
0
}
237
238
/**
239
 * xmlSAX2GetLineNumber:
240
 * @ctx: the user data (XML parser context)
241
 *
242
 * Provide the line number of the current parsing point.
243
 *
244
 * Returns an int
245
 */
246
int
247
xmlSAX2GetLineNumber(void *ctx)
248
0
{
249
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
250
0
    if ((ctx == NULL) || (ctxt->input == NULL)) return(0);
251
0
    return(ctxt->input->line);
252
0
}
253
254
/**
255
 * xmlSAX2GetColumnNumber:
256
 * @ctx: the user data (XML parser context)
257
 *
258
 * Provide the column number of the current parsing point.
259
 *
260
 * Returns an int
261
 */
262
int
263
xmlSAX2GetColumnNumber(void *ctx)
264
0
{
265
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
266
0
    if ((ctx == NULL) || (ctxt->input == NULL)) return(0);
267
0
    return(ctxt->input->col);
268
0
}
269
270
/**
271
 * xmlSAX2IsStandalone:
272
 * @ctx: the user data (XML parser context)
273
 *
274
 * Is this document tagged standalone ?
275
 *
276
 * Returns 1 if true
277
 */
278
int
279
xmlSAX2IsStandalone(void *ctx)
280
0
{
281
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
282
0
    if ((ctx == NULL) || (ctxt->myDoc == NULL)) return(0);
283
0
    return(ctxt->myDoc->standalone == 1);
284
0
}
285
286
/**
287
 * xmlSAX2HasInternalSubset:
288
 * @ctx: the user data (XML parser context)
289
 *
290
 * Does this document has an internal subset
291
 *
292
 * Returns 1 if true
293
 */
294
int
295
xmlSAX2HasInternalSubset(void *ctx)
296
0
{
297
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
298
0
    if ((ctxt == NULL) || (ctxt->myDoc == NULL)) return(0);
299
0
    return(ctxt->myDoc->intSubset != NULL);
300
0
}
301
302
/**
303
 * xmlSAX2HasExternalSubset:
304
 * @ctx: the user data (XML parser context)
305
 *
306
 * Does this document has an external subset
307
 *
308
 * Returns 1 if true
309
 */
310
int
311
xmlSAX2HasExternalSubset(void *ctx)
312
0
{
313
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
314
0
    if ((ctxt == NULL) || (ctxt->myDoc == NULL)) return(0);
315
0
    return(ctxt->myDoc->extSubset != NULL);
316
0
}
317
318
/**
319
 * xmlSAX2InternalSubset:
320
 * @ctx:  the user data (XML parser context)
321
 * @name:  the root element name
322
 * @ExternalID:  the external ID
323
 * @SystemID:  the SYSTEM ID (e.g. filename or URL)
324
 *
325
 * Callback on internal subset declaration.
326
 */
327
void
328
xmlSAX2InternalSubset(void *ctx, const xmlChar *name,
329
         const xmlChar *ExternalID, const xmlChar *SystemID)
330
442k
{
331
442k
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
332
442k
    xmlDtdPtr dtd;
333
442k
    if (ctx == NULL) return;
334
#ifdef DEBUG_SAX
335
    xmlGenericError(xmlGenericErrorContext,
336
      "SAX.xmlSAX2InternalSubset(%s, %s, %s)\n",
337
            name, ExternalID, SystemID);
338
#endif
339
340
442k
    if (ctxt->myDoc == NULL)
341
0
  return;
342
442k
    dtd = xmlGetIntSubset(ctxt->myDoc);
343
442k
    if (dtd != NULL) {
344
0
  if (ctxt->html)
345
0
      return;
346
0
  xmlUnlinkNode((xmlNodePtr) dtd);
347
0
  xmlFreeDtd(dtd);
348
0
  ctxt->myDoc->intSubset = NULL;
349
0
    }
350
442k
    ctxt->myDoc->intSubset =
351
442k
  xmlCreateIntSubset(ctxt->myDoc, name, ExternalID, SystemID);
352
442k
    if (ctxt->myDoc->intSubset == NULL)
353
0
        xmlSAX2ErrMemory(ctxt, "xmlSAX2InternalSubset");
354
442k
}
355
356
/**
357
 * xmlSAX2ExternalSubset:
358
 * @ctx: the user data (XML parser context)
359
 * @name:  the root element name
360
 * @ExternalID:  the external ID
361
 * @SystemID:  the SYSTEM ID (e.g. filename or URL)
362
 *
363
 * Callback on external subset declaration.
364
 */
365
void
366
xmlSAX2ExternalSubset(void *ctx, const xmlChar *name,
367
         const xmlChar *ExternalID, const xmlChar *SystemID)
368
334k
{
369
334k
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
370
334k
    if (ctx == NULL) return;
371
#ifdef DEBUG_SAX
372
    xmlGenericError(xmlGenericErrorContext,
373
      "SAX.xmlSAX2ExternalSubset(%s, %s, %s)\n",
374
            name, ExternalID, SystemID);
375
#endif
376
334k
    if (((ExternalID != NULL) || (SystemID != NULL)) &&
377
334k
        (((ctxt->validate) || (ctxt->loadsubset != 0)) &&
378
223k
   (ctxt->wellFormed && ctxt->myDoc))) {
379
  /*
380
   * Try to fetch and parse the external subset.
381
   */
382
197k
  xmlParserInputPtr oldinput;
383
197k
  int oldinputNr;
384
197k
  int oldinputMax;
385
197k
  xmlParserInputPtr *oldinputTab;
386
197k
  xmlParserInputPtr input = NULL;
387
197k
  xmlCharEncoding enc;
388
197k
  int oldcharset;
389
197k
  const xmlChar *oldencoding;
390
197k
  int oldprogressive;
391
197k
        unsigned long consumed;
392
197k
        size_t buffered;
393
394
  /*
395
   * Ask the Entity resolver to load the damn thing
396
   */
397
197k
  if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
398
197k
      input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
399
197k
                                          SystemID);
400
197k
  if (input == NULL) {
401
73.7k
      return;
402
73.7k
  }
403
404
123k
  xmlNewDtd(ctxt->myDoc, name, ExternalID, SystemID);
405
406
  /*
407
   * make sure we won't destroy the main document context
408
   */
409
123k
  oldinput = ctxt->input;
410
123k
  oldinputNr = ctxt->inputNr;
411
123k
  oldinputMax = ctxt->inputMax;
412
123k
  oldinputTab = ctxt->inputTab;
413
123k
  oldcharset = ctxt->charset;
414
123k
  oldencoding = ctxt->encoding;
415
123k
        oldprogressive = ctxt->progressive;
416
123k
  ctxt->encoding = NULL;
417
123k
        ctxt->progressive = 0;
418
419
123k
  ctxt->inputTab = (xmlParserInputPtr *)
420
123k
                   xmlMalloc(5 * sizeof(xmlParserInputPtr));
421
123k
  if (ctxt->inputTab == NULL) {
422
0
      xmlSAX2ErrMemory(ctxt, "xmlSAX2ExternalSubset");
423
0
            xmlFreeInputStream(input);
424
0
      ctxt->input = oldinput;
425
0
      ctxt->inputNr = oldinputNr;
426
0
      ctxt->inputMax = oldinputMax;
427
0
      ctxt->inputTab = oldinputTab;
428
0
      ctxt->charset = oldcharset;
429
0
      ctxt->encoding = oldencoding;
430
0
            ctxt->progressive = oldprogressive;
431
0
      return;
432
0
  }
433
123k
  ctxt->inputNr = 0;
434
123k
  ctxt->inputMax = 5;
435
123k
  ctxt->input = NULL;
436
123k
  xmlPushInput(ctxt, input);
437
438
  /*
439
   * On the fly encoding conversion if needed
440
   */
441
123k
  if (ctxt->input->length >= 4) {
442
0
      enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
443
0
      xmlSwitchEncoding(ctxt, enc);
444
0
  }
445
446
123k
  if (input->filename == NULL)
447
123k
      input->filename = (char *) xmlCanonicPath(SystemID);
448
123k
  input->line = 1;
449
123k
  input->col = 1;
450
123k
  input->base = ctxt->input->cur;
451
123k
  input->cur = ctxt->input->cur;
452
123k
  input->free = NULL;
453
454
  /*
455
   * let's parse that entity knowing it's an external subset.
456
   */
457
123k
  xmlParseExternalSubset(ctxt, ExternalID, SystemID);
458
459
        /*
460
   * Free up the external entities
461
   */
462
463
123k
  while (ctxt->inputNr > 1)
464
0
      xmlPopInput(ctxt);
465
466
123k
        consumed = ctxt->input->consumed;
467
123k
        buffered = ctxt->input->cur - ctxt->input->base;
468
123k
        if (buffered > ULONG_MAX - consumed)
469
0
            consumed = ULONG_MAX;
470
123k
        else
471
123k
            consumed += buffered;
472
123k
        if (consumed > ULONG_MAX - ctxt->sizeentities)
473
0
            ctxt->sizeentities = ULONG_MAX;
474
123k
        else
475
123k
            ctxt->sizeentities += consumed;
476
477
123k
  xmlFreeInputStream(ctxt->input);
478
123k
        xmlFree(ctxt->inputTab);
479
480
  /*
481
   * Restore the parsing context of the main entity
482
   */
483
123k
  ctxt->input = oldinput;
484
123k
  ctxt->inputNr = oldinputNr;
485
123k
  ctxt->inputMax = oldinputMax;
486
123k
  ctxt->inputTab = oldinputTab;
487
123k
  ctxt->charset = oldcharset;
488
123k
  if ((ctxt->encoding != NULL) &&
489
123k
      ((ctxt->dict == NULL) ||
490
12.1k
       (!xmlDictOwns(ctxt->dict, ctxt->encoding))))
491
12.1k
      xmlFree((xmlChar *) ctxt->encoding);
492
123k
  ctxt->encoding = oldencoding;
493
123k
        ctxt->progressive = oldprogressive;
494
  /* ctxt->wellFormed = oldwellFormed; */
495
123k
    }
496
334k
}
497
498
/**
499
 * xmlSAX2ResolveEntity:
500
 * @ctx: the user data (XML parser context)
501
 * @publicId: The public ID of the entity
502
 * @systemId: The system ID of the entity
503
 *
504
 * The entity loader, to control the loading of external entities,
505
 * the application can either:
506
 *    - override this xmlSAX2ResolveEntity() callback in the SAX block
507
 *    - or better use the xmlSetExternalEntityLoader() function to
508
 *      set up it's own entity resolution routine
509
 *
510
 * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
511
 */
512
xmlParserInputPtr
513
xmlSAX2ResolveEntity(void *ctx, const xmlChar *publicId, const xmlChar *systemId)
514
197k
{
515
197k
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
516
197k
    xmlParserInputPtr ret;
517
197k
    xmlChar *URI;
518
197k
    const char *base = NULL;
519
520
197k
    if (ctx == NULL) return(NULL);
521
197k
    if (ctxt->input != NULL)
522
197k
  base = ctxt->input->filename;
523
197k
    if (base == NULL)
524
65.0k
  base = ctxt->directory;
525
526
197k
    URI = xmlBuildURI(systemId, (const xmlChar *) base);
527
528
#ifdef DEBUG_SAX
529
    xmlGenericError(xmlGenericErrorContext,
530
      "SAX.xmlSAX2ResolveEntity(%s, %s)\n", publicId, systemId);
531
#endif
532
533
197k
    ret = xmlLoadExternalEntity((const char *) URI,
534
197k
        (const char *) publicId, ctxt);
535
197k
    if (URI != NULL)
536
194k
  xmlFree(URI);
537
197k
    return(ret);
538
197k
}
539
540
/**
541
 * xmlSAX2GetEntity:
542
 * @ctx: the user data (XML parser context)
543
 * @name: The entity name
544
 *
545
 * Get an entity by name
546
 *
547
 * Returns the xmlEntityPtr if found.
548
 */
549
xmlEntityPtr
550
xmlSAX2GetEntity(void *ctx, const xmlChar *name)
551
284M
{
552
284M
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
553
284M
    xmlEntityPtr ret = NULL;
554
555
284M
    if (ctx == NULL) return(NULL);
556
#ifdef DEBUG_SAX
557
    xmlGenericError(xmlGenericErrorContext,
558
      "SAX.xmlSAX2GetEntity(%s)\n", name);
559
#endif
560
561
284M
    if (ctxt->inSubset == 0) {
562
280M
  ret = xmlGetPredefinedEntity(name);
563
280M
  if (ret != NULL)
564
625k
      return(ret);
565
280M
    }
566
283M
    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->standalone == 1)) {
567
2.47M
  if (ctxt->inSubset == 2) {
568
4.78k
      ctxt->myDoc->standalone = 0;
569
4.78k
      ret = xmlGetDocEntity(ctxt->myDoc, name);
570
4.78k
      ctxt->myDoc->standalone = 1;
571
2.46M
  } else {
572
2.46M
      ret = xmlGetDocEntity(ctxt->myDoc, name);
573
2.46M
      if (ret == NULL) {
574
1.02M
    ctxt->myDoc->standalone = 0;
575
1.02M
    ret = xmlGetDocEntity(ctxt->myDoc, name);
576
1.02M
    if (ret != NULL) {
577
1.11k
        xmlFatalErrMsg(ctxt, XML_ERR_NOT_STANDALONE,
578
1.11k
   "Entity(%s) document marked standalone but requires external subset\n",
579
1.11k
           name, NULL);
580
1.11k
    }
581
1.02M
    ctxt->myDoc->standalone = 1;
582
1.02M
      }
583
2.46M
  }
584
280M
    } else {
585
280M
  ret = xmlGetDocEntity(ctxt->myDoc, name);
586
280M
    }
587
283M
    return(ret);
588
284M
}
589
590
/**
591
 * xmlSAX2GetParameterEntity:
592
 * @ctx: the user data (XML parser context)
593
 * @name: The entity name
594
 *
595
 * Get a parameter entity by name
596
 *
597
 * Returns the xmlEntityPtr if found.
598
 */
599
xmlEntityPtr
600
xmlSAX2GetParameterEntity(void *ctx, const xmlChar *name)
601
219M
{
602
219M
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
603
219M
    xmlEntityPtr ret;
604
605
219M
    if (ctx == NULL) return(NULL);
606
#ifdef DEBUG_SAX
607
    xmlGenericError(xmlGenericErrorContext,
608
      "SAX.xmlSAX2GetParameterEntity(%s)\n", name);
609
#endif
610
611
219M
    ret = xmlGetParameterEntity(ctxt->myDoc, name);
612
219M
    return(ret);
613
219M
}
614
615
616
/**
617
 * xmlSAX2EntityDecl:
618
 * @ctx: the user data (XML parser context)
619
 * @name:  the entity name
620
 * @type:  the entity type
621
 * @publicId: The public ID of the entity
622
 * @systemId: The system ID of the entity
623
 * @content: the entity value (without processing).
624
 *
625
 * An entity definition has been parsed
626
 */
627
void
628
xmlSAX2EntityDecl(void *ctx, const xmlChar *name, int type,
629
          const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
630
7.55M
{
631
7.55M
    xmlEntityPtr ent;
632
7.55M
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
633
634
7.55M
    if (ctx == NULL) return;
635
#ifdef DEBUG_SAX
636
    xmlGenericError(xmlGenericErrorContext,
637
      "SAX.xmlSAX2EntityDecl(%s, %d, %s, %s, %s)\n",
638
            name, type, publicId, systemId, content);
639
#endif
640
7.55M
    if (ctxt->inSubset == 1) {
641
2.81M
  ent = xmlAddDocEntity(ctxt->myDoc, name, type, publicId,
642
2.81M
                  systemId, content);
643
2.81M
  if ((ent == NULL) && (ctxt->pedantic))
644
9.82k
      xmlWarnMsg(ctxt, XML_WAR_ENTITY_REDEFINED,
645
9.82k
       "Entity(%s) already defined in the internal subset\n",
646
9.82k
                 name);
647
2.81M
  if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
648
178k
      xmlChar *URI;
649
178k
      const char *base = NULL;
650
651
178k
      if (ctxt->input != NULL)
652
178k
    base = ctxt->input->filename;
653
178k
      if (base == NULL)
654
57.6k
    base = ctxt->directory;
655
656
178k
      URI = xmlBuildURI(systemId, (const xmlChar *) base);
657
178k
      ent->URI = URI;
658
178k
  }
659
4.73M
    } else if (ctxt->inSubset == 2) {
660
4.73M
  ent = xmlAddDtdEntity(ctxt->myDoc, name, type, publicId,
661
4.73M
                  systemId, content);
662
4.73M
  if ((ent == NULL) && (ctxt->pedantic) &&
663
4.73M
      (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
664
2.42k
      ctxt->sax->warning(ctxt->userData,
665
2.42k
       "Entity(%s) already defined in the external subset\n", name);
666
4.73M
  if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
667
7.87k
      xmlChar *URI;
668
7.87k
      const char *base = NULL;
669
670
7.87k
      if (ctxt->input != NULL)
671
7.87k
    base = ctxt->input->filename;
672
7.87k
      if (base == NULL)
673
396
    base = ctxt->directory;
674
675
7.87k
      URI = xmlBuildURI(systemId, (const xmlChar *) base);
676
7.87k
      ent->URI = URI;
677
7.87k
  }
678
4.73M
    } else {
679
0
  xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
680
0
                 "SAX.xmlSAX2EntityDecl(%s) called while not in subset\n",
681
0
           name, NULL);
682
0
    }
683
7.55M
}
684
685
/**
686
 * xmlSAX2AttributeDecl:
687
 * @ctx: the user data (XML parser context)
688
 * @elem:  the name of the element
689
 * @fullname:  the attribute name
690
 * @type:  the attribute type
691
 * @def:  the type of default value
692
 * @defaultValue: the attribute default value
693
 * @tree:  the tree of enumerated value set
694
 *
695
 * An attribute definition has been parsed
696
 */
697
void
698
xmlSAX2AttributeDecl(void *ctx, const xmlChar *elem, const xmlChar *fullname,
699
              int type, int def, const xmlChar *defaultValue,
700
        xmlEnumerationPtr tree)
701
23.0M
{
702
23.0M
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
703
23.0M
    xmlAttributePtr attr;
704
23.0M
    xmlChar *name = NULL, *prefix = NULL;
705
706
    /* Avoid unused variable warning if features are disabled. */
707
23.0M
    (void) attr;
708
709
23.0M
    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
710
0
        return;
711
712
#ifdef DEBUG_SAX
713
    xmlGenericError(xmlGenericErrorContext,
714
      "SAX.xmlSAX2AttributeDecl(%s, %s, %d, %d, %s, ...)\n",
715
            elem, fullname, type, def, defaultValue);
716
#endif
717
23.0M
    if ((xmlStrEqual(fullname, BAD_CAST "xml:id")) &&
718
23.0M
        (type != XML_ATTRIBUTE_ID)) {
719
  /*
720
   * Raise the error but keep the validity flag
721
   */
722
297
  int tmp = ctxt->valid;
723
297
  xmlErrValid(ctxt, XML_DTD_XMLID_TYPE,
724
297
        "xml:id : attribute type should be ID\n", NULL, NULL);
725
297
  ctxt->valid = tmp;
726
297
    }
727
    /* TODO: optimize name/prefix allocation */
728
23.0M
    name = xmlSplitQName(ctxt, fullname, &prefix);
729
23.0M
    ctxt->vctxt.valid = 1;
730
23.0M
    if (ctxt->inSubset == 1)
731
7.67M
  attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, elem,
732
7.67M
         name, prefix, (xmlAttributeType) type,
733
7.67M
         (xmlAttributeDefault) def, defaultValue, tree);
734
15.4M
    else if (ctxt->inSubset == 2)
735
15.4M
  attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, elem,
736
15.4M
     name, prefix, (xmlAttributeType) type,
737
15.4M
     (xmlAttributeDefault) def, defaultValue, tree);
738
0
    else {
739
0
        xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
740
0
       "SAX.xmlSAX2AttributeDecl(%s) called while not in subset\n",
741
0
                 name, NULL);
742
0
  xmlFree(name);
743
0
  xmlFreeEnumeration(tree);
744
0
  return;
745
0
    }
746
23.0M
#ifdef LIBXML_VALID_ENABLED
747
23.0M
    if (ctxt->vctxt.valid == 0)
748
67.1k
  ctxt->valid = 0;
749
23.0M
    if ((attr != NULL) && (ctxt->validate) && (ctxt->wellFormed) &&
750
23.0M
        (ctxt->myDoc->intSubset != NULL))
751
9.49M
  ctxt->valid &= xmlValidateAttributeDecl(&ctxt->vctxt, ctxt->myDoc,
752
9.49M
                                          attr);
753
23.0M
#endif /* LIBXML_VALID_ENABLED */
754
23.0M
    if (prefix != NULL)
755
569k
  xmlFree(prefix);
756
23.0M
    if (name != NULL)
757
23.0M
  xmlFree(name);
758
23.0M
}
759
760
/**
761
 * xmlSAX2ElementDecl:
762
 * @ctx: the user data (XML parser context)
763
 * @name:  the element name
764
 * @type:  the element type
765
 * @content: the element value tree
766
 *
767
 * An element definition has been parsed
768
 */
769
void
770
xmlSAX2ElementDecl(void *ctx, const xmlChar * name, int type,
771
            xmlElementContentPtr content)
772
8.15M
{
773
8.15M
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
774
8.15M
    xmlElementPtr elem = NULL;
775
776
    /* Avoid unused variable warning if features are disabled. */
777
8.15M
    (void) elem;
778
779
8.15M
    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
780
0
        return;
781
782
#ifdef DEBUG_SAX
783
    xmlGenericError(xmlGenericErrorContext,
784
                    "SAX.xmlSAX2ElementDecl(%s, %d, ...)\n", name, type);
785
#endif
786
787
8.15M
    if (ctxt->inSubset == 1)
788
2.21M
        elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->intSubset,
789
2.21M
                                 name, (xmlElementTypeVal) type, content);
790
5.94M
    else if (ctxt->inSubset == 2)
791
5.94M
        elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->extSubset,
792
5.94M
                                 name, (xmlElementTypeVal) type, content);
793
0
    else {
794
0
        xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
795
0
       "SAX.xmlSAX2ElementDecl(%s) called while not in subset\n",
796
0
                 name, NULL);
797
0
        return;
798
0
    }
799
8.15M
#ifdef LIBXML_VALID_ENABLED
800
8.15M
    if (elem == NULL)
801
85.0k
        ctxt->valid = 0;
802
8.15M
    if (ctxt->validate && ctxt->wellFormed &&
803
8.15M
        ctxt->myDoc && ctxt->myDoc->intSubset)
804
3.74M
        ctxt->valid &=
805
3.74M
            xmlValidateElementDecl(&ctxt->vctxt, ctxt->myDoc, elem);
806
8.15M
#endif /* LIBXML_VALID_ENABLED */
807
8.15M
}
808
809
/**
810
 * xmlSAX2NotationDecl:
811
 * @ctx: the user data (XML parser context)
812
 * @name: The name of the notation
813
 * @publicId: The public ID of the entity
814
 * @systemId: The system ID of the entity
815
 *
816
 * What to do when a notation declaration has been parsed.
817
 */
818
void
819
xmlSAX2NotationDecl(void *ctx, const xmlChar *name,
820
       const xmlChar *publicId, const xmlChar *systemId)
821
15.9k
{
822
15.9k
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
823
15.9k
    xmlNotationPtr nota = NULL;
824
825
    /* Avoid unused variable warning if features are disabled. */
826
15.9k
    (void) nota;
827
828
15.9k
    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
829
0
        return;
830
831
#ifdef DEBUG_SAX
832
    xmlGenericError(xmlGenericErrorContext,
833
      "SAX.xmlSAX2NotationDecl(%s, %s, %s)\n", name, publicId, systemId);
834
#endif
835
836
15.9k
    if ((publicId == NULL) && (systemId == NULL)) {
837
270
  xmlFatalErrMsg(ctxt, XML_ERR_NOTATION_PROCESSING,
838
270
       "SAX.xmlSAX2NotationDecl(%s) externalID or PublicID missing\n",
839
270
                 name, NULL);
840
270
  return;
841
15.6k
    } else if (ctxt->inSubset == 1)
842
5.67k
  nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, name,
843
5.67k
                              publicId, systemId);
844
9.96k
    else if (ctxt->inSubset == 2)
845
9.96k
  nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, name,
846
9.96k
                              publicId, systemId);
847
0
    else {
848
0
  xmlFatalErrMsg(ctxt, XML_ERR_NOTATION_PROCESSING,
849
0
       "SAX.xmlSAX2NotationDecl(%s) called while not in subset\n",
850
0
                 name, NULL);
851
0
  return;
852
0
    }
853
15.6k
#ifdef LIBXML_VALID_ENABLED
854
15.6k
    if (nota == NULL) ctxt->valid = 0;
855
15.6k
    if ((ctxt->validate) && (ctxt->wellFormed) &&
856
15.6k
        (ctxt->myDoc->intSubset != NULL))
857
2.26k
  ctxt->valid &= xmlValidateNotationDecl(&ctxt->vctxt, ctxt->myDoc,
858
2.26k
                                         nota);
859
15.6k
#endif /* LIBXML_VALID_ENABLED */
860
15.6k
}
861
862
/**
863
 * xmlSAX2UnparsedEntityDecl:
864
 * @ctx: the user data (XML parser context)
865
 * @name: The name of the entity
866
 * @publicId: The public ID of the entity
867
 * @systemId: The system ID of the entity
868
 * @notationName: the name of the notation
869
 *
870
 * What to do when an unparsed entity declaration is parsed
871
 */
872
void
873
xmlSAX2UnparsedEntityDecl(void *ctx, const xmlChar *name,
874
       const xmlChar *publicId, const xmlChar *systemId,
875
       const xmlChar *notationName)
876
36.6k
{
877
36.6k
    xmlEntityPtr ent;
878
36.6k
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
879
36.6k
    if (ctx == NULL) return;
880
#ifdef DEBUG_SAX
881
    xmlGenericError(xmlGenericErrorContext,
882
      "SAX.xmlSAX2UnparsedEntityDecl(%s, %s, %s, %s)\n",
883
            name, publicId, systemId, notationName);
884
#endif
885
36.6k
    if (ctxt->inSubset == 1) {
886
12.0k
  ent = xmlAddDocEntity(ctxt->myDoc, name,
887
12.0k
      XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
888
12.0k
      publicId, systemId, notationName);
889
12.0k
  if ((ent == NULL) && (ctxt->pedantic) &&
890
12.0k
      (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
891
94
      ctxt->sax->warning(ctxt->userData,
892
94
       "Entity(%s) already defined in the internal subset\n", name);
893
12.0k
  if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
894
10.2k
      xmlChar *URI;
895
10.2k
      const char *base = NULL;
896
897
10.2k
      if (ctxt->input != NULL)
898
10.2k
    base = ctxt->input->filename;
899
10.2k
      if (base == NULL)
900
3.44k
    base = ctxt->directory;
901
902
10.2k
      URI = xmlBuildURI(systemId, (const xmlChar *) base);
903
10.2k
      ent->URI = URI;
904
10.2k
  }
905
24.6k
    } else if (ctxt->inSubset == 2) {
906
24.6k
  ent = xmlAddDtdEntity(ctxt->myDoc, name,
907
24.6k
      XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
908
24.6k
      publicId, systemId, notationName);
909
24.6k
  if ((ent == NULL) && (ctxt->pedantic) &&
910
24.6k
      (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
911
1.22k
      ctxt->sax->warning(ctxt->userData,
912
1.22k
       "Entity(%s) already defined in the external subset\n", name);
913
24.6k
  if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
914
1.81k
      xmlChar *URI;
915
1.81k
      const char *base = NULL;
916
917
1.81k
      if (ctxt->input != NULL)
918
1.81k
    base = ctxt->input->filename;
919
1.81k
      if (base == NULL)
920
813
    base = ctxt->directory;
921
922
1.81k
      URI = xmlBuildURI(systemId, (const xmlChar *) base);
923
1.81k
      ent->URI = URI;
924
1.81k
  }
925
24.6k
    } else {
926
0
        xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
927
0
       "SAX.xmlSAX2UnparsedEntityDecl(%s) called while not in subset\n",
928
0
                 name, NULL);
929
0
    }
930
36.6k
}
931
932
/**
933
 * xmlSAX2SetDocumentLocator:
934
 * @ctx: the user data (XML parser context)
935
 * @loc: A SAX Locator
936
 *
937
 * Receive the document locator at startup, actually xmlDefaultSAXLocator
938
 * Everything is available on the context, so this is useless in our case.
939
 */
940
void
941
xmlSAX2SetDocumentLocator(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
942
805k
{
943
    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
944
#ifdef DEBUG_SAX
945
    xmlGenericError(xmlGenericErrorContext,
946
      "SAX.xmlSAX2SetDocumentLocator()\n");
947
#endif
948
805k
}
949
950
/**
951
 * xmlSAX2StartDocument:
952
 * @ctx: the user data (XML parser context)
953
 *
954
 * called when the document start being processed.
955
 */
956
void
957
xmlSAX2StartDocument(void *ctx)
958
723k
{
959
723k
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
960
723k
    xmlDocPtr doc;
961
962
723k
    if (ctx == NULL) return;
963
964
#ifdef DEBUG_SAX
965
    xmlGenericError(xmlGenericErrorContext,
966
      "SAX.xmlSAX2StartDocument()\n");
967
#endif
968
723k
    if (ctxt->html) {
969
0
#ifdef LIBXML_HTML_ENABLED
970
0
  if (ctxt->myDoc == NULL)
971
0
      ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL);
972
0
  if (ctxt->myDoc == NULL) {
973
0
      xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
974
0
      return;
975
0
  }
976
0
  ctxt->myDoc->properties = XML_DOC_HTML;
977
0
  ctxt->myDoc->parseFlags = ctxt->options;
978
#else
979
        xmlGenericError(xmlGenericErrorContext,
980
    "libxml2 built without HTML support\n");
981
  ctxt->errNo = XML_ERR_INTERNAL_ERROR;
982
  ctxt->instate = XML_PARSER_EOF;
983
  ctxt->disableSAX = 1;
984
  return;
985
#endif
986
723k
    } else {
987
723k
  doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
988
723k
  if (doc != NULL) {
989
723k
      doc->properties = 0;
990
723k
      if (ctxt->options & XML_PARSE_OLD10)
991
148k
          doc->properties |= XML_DOC_OLD10;
992
723k
      doc->parseFlags = ctxt->options;
993
723k
      if (ctxt->encoding != NULL)
994
139k
    doc->encoding = xmlStrdup(ctxt->encoding);
995
583k
      else
996
583k
    doc->encoding = NULL;
997
723k
      doc->standalone = ctxt->standalone;
998
723k
  } else {
999
0
      xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
1000
0
      return;
1001
0
  }
1002
723k
  if ((ctxt->dictNames) && (doc != NULL)) {
1003
519k
      doc->dict = ctxt->dict;
1004
519k
      xmlDictReference(doc->dict);
1005
519k
  }
1006
723k
    }
1007
723k
    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->URL == NULL) &&
1008
723k
  (ctxt->input != NULL) && (ctxt->input->filename != NULL)) {
1009
484k
  ctxt->myDoc->URL = xmlPathToURI((const xmlChar *)ctxt->input->filename);
1010
484k
  if (ctxt->myDoc->URL == NULL)
1011
0
      xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
1012
484k
    }
1013
723k
}
1014
1015
/**
1016
 * xmlSAX2EndDocument:
1017
 * @ctx: the user data (XML parser context)
1018
 *
1019
 * called when the document end has been detected.
1020
 */
1021
void
1022
xmlSAX2EndDocument(void *ctx)
1023
406k
{
1024
406k
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1025
#ifdef DEBUG_SAX
1026
    xmlGenericError(xmlGenericErrorContext,
1027
      "SAX.xmlSAX2EndDocument()\n");
1028
#endif
1029
406k
    if (ctx == NULL) return;
1030
406k
#ifdef LIBXML_VALID_ENABLED
1031
406k
    if (ctxt->validate && ctxt->wellFormed &&
1032
406k
        ctxt->myDoc && ctxt->myDoc->intSubset)
1033
8.39k
  ctxt->valid &= xmlValidateDocumentFinal(&ctxt->vctxt, ctxt->myDoc);
1034
406k
#endif /* LIBXML_VALID_ENABLED */
1035
1036
    /*
1037
     * Grab the encoding if it was added on-the-fly
1038
     */
1039
406k
    if ((ctxt->encoding != NULL) && (ctxt->myDoc != NULL) &&
1040
406k
  (ctxt->myDoc->encoding == NULL)) {
1041
83
  ctxt->myDoc->encoding = ctxt->encoding;
1042
83
  ctxt->encoding = NULL;
1043
83
    }
1044
406k
    if ((ctxt->inputTab != NULL) &&
1045
406k
        (ctxt->inputNr > 0) && (ctxt->inputTab[0] != NULL) &&
1046
406k
        (ctxt->inputTab[0]->encoding != NULL) && (ctxt->myDoc != NULL) &&
1047
406k
  (ctxt->myDoc->encoding == NULL)) {
1048
32.4k
  ctxt->myDoc->encoding = xmlStrdup(ctxt->inputTab[0]->encoding);
1049
32.4k
    }
1050
406k
    if ((ctxt->charset != XML_CHAR_ENCODING_NONE) && (ctxt->myDoc != NULL) &&
1051
406k
  (ctxt->myDoc->charset == XML_CHAR_ENCODING_NONE)) {
1052
0
  ctxt->myDoc->charset = ctxt->charset;
1053
0
    }
1054
406k
}
1055
1056
#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
1057
/**
1058
 * xmlNsErrMsg:
1059
 * @ctxt:  an XML parser context
1060
 * @error:  the error number
1061
 * @msg:  the error message
1062
 * @str1:  an error string
1063
 * @str2:  an error string
1064
 *
1065
 * Handle a namespace error
1066
 */
1067
static void LIBXML_ATTR_FORMAT(3,0)
1068
xmlNsErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
1069
            const char *msg, const xmlChar *str1, const xmlChar *str2)
1070
214k
{
1071
214k
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
1072
214k
        (ctxt->instate == XML_PARSER_EOF))
1073
0
  return;
1074
214k
    if (ctxt != NULL)
1075
214k
  ctxt->errNo = error;
1076
214k
    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
1077
214k
                    XML_ERR_ERROR, NULL, 0,
1078
214k
        (const char *) str1, (const char *) str2,
1079
214k
        NULL, 0, 0, msg, str1, str2);
1080
214k
}
1081
1082
/**
1083
 * xmlSAX2AttributeInternal:
1084
 * @ctx: the user data (XML parser context)
1085
 * @fullname:  The attribute name, including namespace prefix
1086
 * @value:  The attribute value
1087
 * @prefix: the prefix on the element node
1088
 *
1089
 * Handle an attribute that has been read by the parser.
1090
 * The default handling is to convert the attribute into an
1091
 * DOM subtree and past it in a new xmlAttr element added to
1092
 * the element.
1093
 */
1094
static void
1095
xmlSAX2AttributeInternal(void *ctx, const xmlChar *fullname,
1096
             const xmlChar *value, const xmlChar *prefix ATTRIBUTE_UNUSED)
1097
15.9M
{
1098
15.9M
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1099
15.9M
    xmlAttrPtr ret;
1100
15.9M
    xmlChar *name;
1101
15.9M
    xmlChar *ns;
1102
15.9M
    xmlChar *nval;
1103
15.9M
    xmlNsPtr namespace;
1104
1105
15.9M
    if (ctxt->html) {
1106
0
  name = xmlStrdup(fullname);
1107
0
  ns = NULL;
1108
0
  namespace = NULL;
1109
15.9M
    } else {
1110
  /*
1111
   * Split the full name into a namespace prefix and the tag name
1112
   */
1113
15.9M
  name = xmlSplitQName(ctxt, fullname, &ns);
1114
15.9M
  if ((name != NULL) && (name[0] == 0)) {
1115
0
      if (xmlStrEqual(ns, BAD_CAST "xmlns")) {
1116
0
    xmlNsErrMsg(ctxt, XML_ERR_NS_DECL_ERROR,
1117
0
          "invalid namespace declaration '%s'\n",
1118
0
          fullname, NULL);
1119
0
      } else {
1120
0
    xmlNsWarnMsg(ctxt, XML_WAR_NS_COLUMN,
1121
0
           "Avoid attribute ending with ':' like '%s'\n",
1122
0
           fullname, NULL);
1123
0
      }
1124
0
      if (ns != NULL)
1125
0
    xmlFree(ns);
1126
0
      ns = NULL;
1127
0
      xmlFree(name);
1128
0
      name = xmlStrdup(fullname);
1129
0
  }
1130
15.9M
    }
1131
15.9M
    if (name == NULL) {
1132
0
        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1133
0
  if (ns != NULL)
1134
0
      xmlFree(ns);
1135
0
  return;
1136
0
    }
1137
1138
15.9M
#ifdef LIBXML_HTML_ENABLED
1139
15.9M
    if ((ctxt->html) &&
1140
15.9M
        (value == NULL) && (htmlIsBooleanAttr(fullname))) {
1141
0
            nval = xmlStrdup(fullname);
1142
0
            value = (const xmlChar *) nval;
1143
0
    } else
1144
15.9M
#endif
1145
15.9M
    {
1146
15.9M
#ifdef LIBXML_VALID_ENABLED
1147
        /*
1148
         * Do the last stage of the attribute normalization
1149
         * Needed for HTML too:
1150
         *   http://www.w3.org/TR/html4/types.html#h-6.2
1151
         */
1152
15.9M
        ctxt->vctxt.valid = 1;
1153
15.9M
        nval = xmlValidCtxtNormalizeAttributeValue(&ctxt->vctxt,
1154
15.9M
                                               ctxt->myDoc, ctxt->node,
1155
15.9M
                                               fullname, value);
1156
15.9M
        if (ctxt->vctxt.valid != 1) {
1157
245
            ctxt->valid = 0;
1158
245
        }
1159
15.9M
        if (nval != NULL)
1160
3.97M
            value = nval;
1161
#else
1162
        nval = NULL;
1163
#endif /* LIBXML_VALID_ENABLED */
1164
15.9M
    }
1165
1166
    /*
1167
     * Check whether it's a namespace definition
1168
     */
1169
15.9M
    if ((!ctxt->html) && (ns == NULL) &&
1170
15.9M
        (name[0] == 'x') && (name[1] == 'm') && (name[2] == 'l') &&
1171
15.9M
        (name[3] == 'n') && (name[4] == 's') && (name[5] == 0)) {
1172
120k
  xmlNsPtr nsret;
1173
120k
  xmlChar *val;
1174
1175
        /* Avoid unused variable warning if features are disabled. */
1176
120k
        (void) nsret;
1177
1178
120k
        if (!ctxt->replaceEntities) {
1179
59.9k
      ctxt->depth++;
1180
59.9k
      val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
1181
59.9k
                              0,0,0);
1182
59.9k
      ctxt->depth--;
1183
59.9k
      if (val == NULL) {
1184
0
          xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1185
0
    if (name != NULL)
1186
0
        xmlFree(name);
1187
0
                if (nval != NULL)
1188
0
                    xmlFree(nval);
1189
0
    return;
1190
0
      }
1191
60.7k
  } else {
1192
60.7k
      val = (xmlChar *) value;
1193
60.7k
  }
1194
1195
120k
  if (val[0] != 0) {
1196
112k
      xmlURIPtr uri;
1197
1198
112k
      uri = xmlParseURI((const char *)val);
1199
112k
      if (uri == NULL) {
1200
51.1k
    if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
1201
16.5k
        ctxt->sax->warning(ctxt->userData,
1202
16.5k
       "xmlns: %s not a valid URI\n", val);
1203
61.4k
      } else {
1204
61.4k
    if (uri->scheme == NULL) {
1205
15.3k
        if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
1206
6.36k
      ctxt->sax->warning(ctxt->userData,
1207
6.36k
           "xmlns: URI %s is not absolute\n", val);
1208
15.3k
    }
1209
61.4k
    xmlFreeURI(uri);
1210
61.4k
      }
1211
112k
  }
1212
1213
  /* a default namespace definition */
1214
120k
  nsret = xmlNewNs(ctxt->node, val, NULL);
1215
1216
120k
#ifdef LIBXML_VALID_ENABLED
1217
  /*
1218
   * Validate also for namespace decls, they are attributes from
1219
   * an XML-1.0 perspective
1220
   */
1221
120k
        if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
1222
120k
      ctxt->myDoc && ctxt->myDoc->intSubset)
1223
1.35k
      ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
1224
1.35k
             ctxt->node, prefix, nsret, val);
1225
120k
#endif /* LIBXML_VALID_ENABLED */
1226
120k
  if (name != NULL)
1227
120k
      xmlFree(name);
1228
120k
  if (nval != NULL)
1229
0
      xmlFree(nval);
1230
120k
  if (val != value)
1231
59.9k
      xmlFree(val);
1232
120k
  return;
1233
120k
    }
1234
15.8M
    if ((!ctxt->html) &&
1235
15.8M
  (ns != NULL) && (ns[0] == 'x') && (ns[1] == 'm') && (ns[2] == 'l') &&
1236
15.8M
        (ns[3] == 'n') && (ns[4] == 's') && (ns[5] == 0)) {
1237
108k
  xmlNsPtr nsret;
1238
108k
  xmlChar *val;
1239
1240
        /* Avoid unused variable warning if features are disabled. */
1241
108k
        (void) nsret;
1242
1243
108k
        if (!ctxt->replaceEntities) {
1244
55.7k
      ctxt->depth++;
1245
55.7k
      val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
1246
55.7k
                              0,0,0);
1247
55.7k
      ctxt->depth--;
1248
55.7k
      if (val == NULL) {
1249
0
          xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1250
0
          xmlFree(ns);
1251
0
    if (name != NULL)
1252
0
        xmlFree(name);
1253
0
                if (nval != NULL)
1254
0
                    xmlFree(nval);
1255
0
    return;
1256
0
      }
1257
55.7k
  } else {
1258
52.7k
      val = (xmlChar *) value;
1259
52.7k
  }
1260
1261
108k
  if (val[0] == 0) {
1262
3.19k
      xmlNsErrMsg(ctxt, XML_NS_ERR_EMPTY,
1263
3.19k
            "Empty namespace name for prefix %s\n", name, NULL);
1264
3.19k
  }
1265
108k
  if ((ctxt->pedantic != 0) && (val[0] != 0)) {
1266
51.0k
      xmlURIPtr uri;
1267
1268
51.0k
      uri = xmlParseURI((const char *)val);
1269
51.0k
      if (uri == NULL) {
1270
16.2k
          xmlNsWarnMsg(ctxt, XML_WAR_NS_URI,
1271
16.2k
       "xmlns:%s: %s not a valid URI\n", name, value);
1272
34.7k
      } else {
1273
34.7k
    if (uri->scheme == NULL) {
1274
17.0k
        xmlNsWarnMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
1275
17.0k
         "xmlns:%s: URI %s is not absolute\n", name, value);
1276
17.0k
    }
1277
34.7k
    xmlFreeURI(uri);
1278
34.7k
      }
1279
51.0k
  }
1280
1281
  /* a standard namespace definition */
1282
108k
  nsret = xmlNewNs(ctxt->node, val, name);
1283
108k
  xmlFree(ns);
1284
108k
#ifdef LIBXML_VALID_ENABLED
1285
  /*
1286
   * Validate also for namespace decls, they are attributes from
1287
   * an XML-1.0 perspective
1288
   */
1289
108k
        if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
1290
108k
      ctxt->myDoc && ctxt->myDoc->intSubset)
1291
6.54k
      ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
1292
6.54k
             ctxt->node, prefix, nsret, value);
1293
108k
#endif /* LIBXML_VALID_ENABLED */
1294
108k
  if (name != NULL)
1295
108k
      xmlFree(name);
1296
108k
  if (nval != NULL)
1297
824
      xmlFree(nval);
1298
108k
  if (val != value)
1299
55.7k
      xmlFree(val);
1300
108k
  return;
1301
108k
    }
1302
1303
15.6M
    if (ns != NULL) {
1304
597k
  namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, ns);
1305
1306
597k
  if (namespace == NULL) {
1307
210k
      xmlNsErrMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
1308
210k
        "Namespace prefix %s of attribute %s is not defined\n",
1309
210k
                 ns, name);
1310
386k
  } else {
1311
386k
            xmlAttrPtr prop;
1312
1313
386k
            prop = ctxt->node->properties;
1314
500k
            while (prop != NULL) {
1315
113k
                if (prop->ns != NULL) {
1316
39.4k
                    if ((xmlStrEqual(name, prop->name)) &&
1317
39.4k
                        ((namespace == prop->ns) ||
1318
335
                         (xmlStrEqual(namespace->href, prop->ns->href)))) {
1319
151
                            xmlNsErrMsg(ctxt, XML_ERR_ATTRIBUTE_REDEFINED,
1320
151
                                    "Attribute %s in %s redefined\n",
1321
151
                                             name, namespace->href);
1322
151
                        ctxt->wellFormed = 0;
1323
151
                        if (ctxt->recovery == 0) ctxt->disableSAX = 1;
1324
151
                        if (name != NULL)
1325
151
                            xmlFree(name);
1326
151
                        goto error;
1327
151
                    }
1328
39.4k
                }
1329
113k
                prop = prop->next;
1330
113k
            }
1331
386k
        }
1332
15.0M
    } else {
1333
15.0M
  namespace = NULL;
1334
15.0M
    }
1335
1336
    /* !!!!!! <a toto:arg="" xmlns:toto="http://toto.com"> */
1337
15.6M
    ret = xmlNewNsPropEatName(ctxt->node, namespace, name, NULL);
1338
15.6M
    if (ret == NULL)
1339
0
        goto error;
1340
1341
15.6M
    if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
1342
9.46M
        xmlNodePtr tmp;
1343
1344
9.46M
        ret->children = xmlStringGetNodeList(ctxt->myDoc, value);
1345
9.46M
        tmp = ret->children;
1346
19.3M
        while (tmp != NULL) {
1347
9.84M
            tmp->parent = (xmlNodePtr) ret;
1348
9.84M
            if (tmp->next == NULL)
1349
9.43M
                ret->last = tmp;
1350
9.84M
            tmp = tmp->next;
1351
9.84M
        }
1352
9.46M
    } else if (value != NULL) {
1353
6.23M
        ret->children = xmlNewDocText(ctxt->myDoc, value);
1354
6.23M
        ret->last = ret->children;
1355
6.23M
        if (ret->children != NULL)
1356
6.23M
            ret->children->parent = (xmlNodePtr) ret;
1357
6.23M
    }
1358
1359
15.6M
#ifdef LIBXML_VALID_ENABLED
1360
15.6M
    if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
1361
15.6M
        ctxt->myDoc && ctxt->myDoc->intSubset) {
1362
1363
  /*
1364
   * If we don't substitute entities, the validation should be
1365
   * done on a value with replaced entities anyway.
1366
   */
1367
2.64M
        if (!ctxt->replaceEntities) {
1368
1.66M
      xmlChar *val;
1369
1370
1.66M
      ctxt->depth++;
1371
1.66M
      val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
1372
1.66M
                              0,0,0);
1373
1.66M
      ctxt->depth--;
1374
1375
1.66M
      if (val == NULL)
1376
0
    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
1377
0
        ctxt->myDoc, ctxt->node, ret, value);
1378
1.66M
      else {
1379
1.66M
    xmlChar *nvalnorm;
1380
1381
    /*
1382
     * Do the last stage of the attribute normalization
1383
     * It need to be done twice ... it's an extra burden related
1384
     * to the ability to keep xmlSAX2References in attributes
1385
     */
1386
1.66M
    nvalnorm = xmlValidNormalizeAttributeValue(ctxt->myDoc,
1387
1.66M
              ctxt->node, fullname, val);
1388
1.66M
    if (nvalnorm != NULL) {
1389
963k
        xmlFree(val);
1390
963k
        val = nvalnorm;
1391
963k
    }
1392
1393
1.66M
    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
1394
1.66M
              ctxt->myDoc, ctxt->node, ret, val);
1395
1.66M
                xmlFree(val);
1396
1.66M
      }
1397
1.66M
  } else {
1398
976k
      ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc,
1399
976k
                 ctxt->node, ret, value);
1400
976k
  }
1401
2.64M
    } else
1402
13.0M
#endif /* LIBXML_VALID_ENABLED */
1403
13.0M
           if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
1404
13.0M
         (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
1405
13.0M
          ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0))) &&
1406
               /* Don't create IDs containing entity references */
1407
13.0M
               (ret->children != NULL) &&
1408
13.0M
               (ret->children->type == XML_TEXT_NODE) &&
1409
13.0M
               (ret->children->next == NULL)) {
1410
12.9M
        xmlChar *content = ret->children->content;
1411
        /*
1412
   * when validating, the ID registration is done at the attribute
1413
   * validation level. Otherwise we have to do specific handling here.
1414
   */
1415
12.9M
  if (xmlStrEqual(fullname, BAD_CAST "xml:id")) {
1416
      /*
1417
       * Add the xml:id value
1418
       *
1419
       * Open issue: normalization of the value.
1420
       */
1421
45.7k
      if (xmlValidateNCName(content, 1) != 0) {
1422
26.8k
          xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
1423
26.8k
          "xml:id : attribute value %s is not an NCName\n",
1424
26.8k
          (const char *) content, NULL);
1425
26.8k
      }
1426
45.7k
      xmlAddID(&ctxt->vctxt, ctxt->myDoc, content, ret);
1427
12.8M
  } else if (xmlIsID(ctxt->myDoc, ctxt->node, ret))
1428
735k
      xmlAddID(&ctxt->vctxt, ctxt->myDoc, content, ret);
1429
12.1M
  else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret))
1430
1.58M
      xmlAddRef(&ctxt->vctxt, ctxt->myDoc, content, ret);
1431
12.9M
    }
1432
1433
15.6M
error:
1434
15.6M
    if (nval != NULL)
1435
3.97M
  xmlFree(nval);
1436
15.6M
    if (ns != NULL)
1437
597k
  xmlFree(ns);
1438
15.6M
}
1439
1440
/*
1441
 * xmlCheckDefaultedAttributes:
1442
 *
1443
 * Check defaulted attributes from the DTD
1444
 */
1445
static void
1446
xmlCheckDefaultedAttributes(xmlParserCtxtPtr ctxt, const xmlChar *name,
1447
18.6M
  const xmlChar *prefix, const xmlChar **atts) {
1448
18.6M
    xmlElementPtr elemDecl;
1449
18.6M
    const xmlChar *att;
1450
18.6M
    int internal = 1;
1451
18.6M
    int i;
1452
1453
18.6M
    elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->intSubset, name, prefix);
1454
18.6M
    if (elemDecl == NULL) {
1455
18.4M
  elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset, name, prefix);
1456
18.4M
  internal = 0;
1457
18.4M
    }
1458
1459
18.8M
process_external_subset:
1460
1461
18.8M
    if (elemDecl != NULL) {
1462
10.4M
  xmlAttributePtr attr = elemDecl->attributes;
1463
  /*
1464
   * Check against defaulted attributes from the external subset
1465
   * if the document is stamped as standalone
1466
   */
1467
10.4M
  if ((ctxt->myDoc->standalone == 1) &&
1468
10.4M
      (ctxt->myDoc->extSubset != NULL) &&
1469
10.4M
      (ctxt->validate)) {
1470
40.8k
      while (attr != NULL) {
1471
27.8k
    if ((attr->defaultValue != NULL) &&
1472
27.8k
        (xmlGetDtdQAttrDesc(ctxt->myDoc->extSubset,
1473
3.31k
          attr->elem, attr->name,
1474
3.31k
          attr->prefix) == attr) &&
1475
27.8k
        (xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
1476
3.31k
          attr->elem, attr->name,
1477
3.31k
          attr->prefix) == NULL)) {
1478
3.31k
        xmlChar *fulln;
1479
1480
3.31k
        if (attr->prefix != NULL) {
1481
1.27k
      fulln = xmlStrdup(attr->prefix);
1482
1.27k
      fulln = xmlStrcat(fulln, BAD_CAST ":");
1483
1.27k
      fulln = xmlStrcat(fulln, attr->name);
1484
2.04k
        } else {
1485
2.04k
      fulln = xmlStrdup(attr->name);
1486
2.04k
        }
1487
3.31k
                    if (fulln == NULL) {
1488
0
                        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1489
0
                        break;
1490
0
                    }
1491
1492
        /*
1493
         * Check that the attribute is not declared in the
1494
         * serialization
1495
         */
1496
3.31k
        att = NULL;
1497
3.31k
        if (atts != NULL) {
1498
2.82k
      i = 0;
1499
2.82k
      att = atts[i];
1500
5.98k
      while (att != NULL) {
1501
3.15k
          if (xmlStrEqual(att, fulln))
1502
0
        break;
1503
3.15k
          i += 2;
1504
3.15k
          att = atts[i];
1505
3.15k
      }
1506
2.82k
        }
1507
3.31k
        if (att == NULL) {
1508
3.31k
            xmlErrValid(ctxt, XML_DTD_STANDALONE_DEFAULTED,
1509
3.31k
      "standalone: attribute %s on %s defaulted from external subset\n",
1510
3.31k
            (const char *)fulln,
1511
3.31k
            (const char *)attr->elem);
1512
3.31k
        }
1513
3.31k
                    xmlFree(fulln);
1514
3.31k
    }
1515
27.8k
    attr = attr->nexth;
1516
27.8k
      }
1517
12.9k
  }
1518
1519
  /*
1520
   * Actually insert defaulted values when needed
1521
   */
1522
10.4M
  attr = elemDecl->attributes;
1523
36.4M
  while (attr != NULL) {
1524
      /*
1525
       * Make sure that attributes redefinition occurring in the
1526
       * internal subset are not overridden by definitions in the
1527
       * external subset.
1528
       */
1529
26.0M
      if (attr->defaultValue != NULL) {
1530
    /*
1531
     * the element should be instantiated in the tree if:
1532
     *  - this is a namespace prefix
1533
     *  - the user required for completion in the tree
1534
     *    like XSLT
1535
     *  - there isn't already an attribute definition
1536
     *    in the internal subset overriding it.
1537
     */
1538
1.38M
    if (((attr->prefix != NULL) &&
1539
1.38M
         (xmlStrEqual(attr->prefix, BAD_CAST "xmlns"))) ||
1540
1.38M
        ((attr->prefix == NULL) &&
1541
1.38M
         (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) ||
1542
1.38M
        (ctxt->loadsubset & XML_COMPLETE_ATTRS)) {
1543
667k
        xmlAttributePtr tst;
1544
1545
667k
        tst = xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
1546
667k
               attr->elem, attr->name,
1547
667k
               attr->prefix);
1548
667k
        if ((tst == attr) || (tst == NULL)) {
1549
667k
            xmlChar fn[50];
1550
667k
      xmlChar *fulln;
1551
1552
667k
                        fulln = xmlBuildQName(attr->name, attr->prefix, fn, 50);
1553
667k
      if (fulln == NULL) {
1554
0
          xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1555
0
          return;
1556
0
      }
1557
1558
      /*
1559
       * Check that the attribute is not declared in the
1560
       * serialization
1561
       */
1562
667k
      att = NULL;
1563
667k
      if (atts != NULL) {
1564
584k
          i = 0;
1565
584k
          att = atts[i];
1566
1.23M
          while (att != NULL) {
1567
671k
        if (xmlStrEqual(att, fulln))
1568
16.5k
            break;
1569
654k
        i += 2;
1570
654k
        att = atts[i];
1571
654k
          }
1572
584k
      }
1573
667k
      if (att == NULL) {
1574
651k
          xmlSAX2AttributeInternal(ctxt, fulln,
1575
651k
             attr->defaultValue, prefix);
1576
651k
      }
1577
667k
      if ((fulln != fn) && (fulln != attr->name))
1578
512
          xmlFree(fulln);
1579
667k
        }
1580
667k
    }
1581
1.38M
      }
1582
26.0M
      attr = attr->nexth;
1583
26.0M
  }
1584
10.4M
  if (internal == 1) {
1585
163k
      elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset,
1586
163k
                                 name, prefix);
1587
163k
      internal = 0;
1588
163k
      goto process_external_subset;
1589
163k
  }
1590
10.4M
    }
1591
18.8M
}
1592
1593
/**
1594
 * xmlSAX2StartElement:
1595
 * @ctx: the user data (XML parser context)
1596
 * @fullname:  The element name, including namespace prefix
1597
 * @atts:  An array of name/value attributes pairs, NULL terminated
1598
 *
1599
 * called when an opening tag has been processed.
1600
 */
1601
void
1602
xmlSAX2StartElement(void *ctx, const xmlChar *fullname, const xmlChar **atts)
1603
22.5M
{
1604
22.5M
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1605
22.5M
    xmlNodePtr ret;
1606
22.5M
    xmlNodePtr parent;
1607
22.5M
    xmlNsPtr ns;
1608
22.5M
    xmlChar *name;
1609
22.5M
    xmlChar *prefix;
1610
22.5M
    const xmlChar *att;
1611
22.5M
    const xmlChar *value;
1612
22.5M
    int i;
1613
1614
22.5M
    if ((ctx == NULL) || (fullname == NULL) || (ctxt->myDoc == NULL)) return;
1615
22.5M
    parent = ctxt->node;
1616
#ifdef DEBUG_SAX
1617
    xmlGenericError(xmlGenericErrorContext,
1618
      "SAX.xmlSAX2StartElement(%s)\n", fullname);
1619
#endif
1620
1621
    /*
1622
     * First check on validity:
1623
     */
1624
22.5M
    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
1625
22.5M
        ((ctxt->myDoc->intSubset == NULL) ||
1626
3.13M
   ((ctxt->myDoc->intSubset->notations == NULL) &&
1627
3.10M
    (ctxt->myDoc->intSubset->elements == NULL) &&
1628
3.10M
    (ctxt->myDoc->intSubset->attributes == NULL) &&
1629
3.10M
    (ctxt->myDoc->intSubset->entities == NULL)))) {
1630
34.1k
  xmlErrValid(ctxt, XML_ERR_NO_DTD,
1631
34.1k
    "Validation failed: no DTD found !", NULL, NULL);
1632
34.1k
  ctxt->validate = 0;
1633
34.1k
    }
1634
1635
1636
    /*
1637
     * Split the full name into a namespace prefix and the tag name
1638
     */
1639
22.5M
    name = xmlSplitQName(ctxt, fullname, &prefix);
1640
1641
1642
    /*
1643
     * Note : the namespace resolution is deferred until the end of the
1644
     *        attributes parsing, since local namespace can be defined as
1645
     *        an attribute at this level.
1646
     */
1647
22.5M
    ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL, name, NULL);
1648
22.5M
    if (ret == NULL) {
1649
0
        if (prefix != NULL)
1650
0
      xmlFree(prefix);
1651
0
  xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1652
0
        return;
1653
0
    }
1654
22.5M
    if (ctxt->myDoc->children == NULL) {
1655
#ifdef DEBUG_SAX_TREE
1656
  xmlGenericError(xmlGenericErrorContext, "Setting %s as root\n", name);
1657
#endif
1658
56.2k
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
1659
22.4M
    } else if (parent == NULL) {
1660
541k
        parent = ctxt->myDoc->children;
1661
541k
    }
1662
22.5M
    ctxt->nodemem = -1;
1663
22.5M
    if (ctxt->linenumbers) {
1664
22.5M
  if (ctxt->input != NULL) {
1665
22.5M
      if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
1666
22.5M
    ret->line = ctxt->input->line;
1667
1.76k
      else
1668
1.76k
          ret->line = USHRT_MAX;
1669
22.5M
  }
1670
22.5M
    }
1671
1672
    /*
1673
     * We are parsing a new node.
1674
     */
1675
#ifdef DEBUG_SAX_TREE
1676
    xmlGenericError(xmlGenericErrorContext, "pushing(%s)\n", name);
1677
#endif
1678
22.5M
    if (nodePush(ctxt, ret) < 0) {
1679
41
        xmlUnlinkNode(ret);
1680
41
        xmlFreeNode(ret);
1681
41
        if (prefix != NULL)
1682
10
            xmlFree(prefix);
1683
41
        return;
1684
41
    }
1685
1686
    /*
1687
     * Link the child element
1688
     */
1689
22.5M
    if (parent != NULL) {
1690
22.4M
        if (parent->type == XML_ELEMENT_NODE) {
1691
#ifdef DEBUG_SAX_TREE
1692
      xmlGenericError(xmlGenericErrorContext,
1693
        "adding child %s to %s\n", name, parent->name);
1694
#endif
1695
22.2M
      xmlAddChild(parent, ret);
1696
22.2M
  } else {
1697
#ifdef DEBUG_SAX_TREE
1698
      xmlGenericError(xmlGenericErrorContext,
1699
        "adding sibling %s to ", name);
1700
      xmlDebugDumpOneNode(stderr, parent, 0);
1701
#endif
1702
208k
      xmlAddSibling(parent, ret);
1703
208k
  }
1704
22.4M
    }
1705
1706
22.5M
    if (!ctxt->html) {
1707
        /*
1708
         * Insert all the defaulted attributes from the DTD especially
1709
         * namespaces
1710
         */
1711
22.5M
        if ((ctxt->myDoc->intSubset != NULL) ||
1712
22.5M
            (ctxt->myDoc->extSubset != NULL)) {
1713
18.6M
            xmlCheckDefaultedAttributes(ctxt, name, prefix, atts);
1714
18.6M
        }
1715
1716
        /*
1717
         * process all the attributes whose name start with "xmlns"
1718
         */
1719
22.5M
        if (atts != NULL) {
1720
11.2M
            i = 0;
1721
11.2M
            att = atts[i++];
1722
11.2M
            value = atts[i++];
1723
26.4M
      while ((att != NULL) && (value != NULL)) {
1724
15.2M
    if ((att[0] == 'x') && (att[1] == 'm') && (att[2] == 'l') &&
1725
15.2M
        (att[3] == 'n') && (att[4] == 's'))
1726
223k
        xmlSAX2AttributeInternal(ctxt, att, value, prefix);
1727
1728
15.2M
    att = atts[i++];
1729
15.2M
    value = atts[i++];
1730
15.2M
      }
1731
11.2M
        }
1732
1733
        /*
1734
         * Search the namespace, note that since the attributes have been
1735
         * processed, the local namespaces are available.
1736
         */
1737
22.5M
        ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
1738
22.5M
        if ((ns == NULL) && (parent != NULL))
1739
21.7M
            ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
1740
22.5M
        if ((prefix != NULL) && (ns == NULL)) {
1741
433k
            ns = xmlNewNs(ret, NULL, prefix);
1742
433k
            xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
1743
433k
                         "Namespace prefix %s is not defined\n",
1744
433k
                         prefix, NULL);
1745
433k
        }
1746
1747
        /*
1748
         * set the namespace node, making sure that if the default namespace
1749
         * is unbound on a parent we simply keep it NULL
1750
         */
1751
22.5M
        if ((ns != NULL) && (ns->href != NULL) &&
1752
22.5M
            ((ns->href[0] != 0) || (ns->prefix != NULL)))
1753
704k
            xmlSetNs(ret, ns);
1754
22.5M
    }
1755
1756
    /*
1757
     * process all the other attributes
1758
     */
1759
22.5M
    if (atts != NULL) {
1760
11.2M
        i = 0;
1761
11.2M
  att = atts[i++];
1762
11.2M
  value = atts[i++];
1763
11.2M
  if (ctxt->html) {
1764
0
      while (att != NULL) {
1765
0
    xmlSAX2AttributeInternal(ctxt, att, value, NULL);
1766
0
    att = atts[i++];
1767
0
    value = atts[i++];
1768
0
      }
1769
11.2M
  } else {
1770
26.4M
      while ((att != NULL) && (value != NULL)) {
1771
15.2M
    if ((att[0] != 'x') || (att[1] != 'm') || (att[2] != 'l') ||
1772
15.2M
        (att[3] != 'n') || (att[4] != 's'))
1773
15.0M
        xmlSAX2AttributeInternal(ctxt, att, value, NULL);
1774
1775
    /*
1776
     * Next ones
1777
     */
1778
15.2M
    att = atts[i++];
1779
15.2M
    value = atts[i++];
1780
15.2M
      }
1781
11.2M
  }
1782
11.2M
    }
1783
1784
22.5M
#ifdef LIBXML_VALID_ENABLED
1785
    /*
1786
     * If it's the Document root, finish the DTD validation and
1787
     * check the document root element for validity
1788
     */
1789
22.5M
    if ((ctxt->validate) &&
1790
22.5M
        ((ctxt->vctxt.flags & XML_VCTXT_DTD_VALIDATED) == 0)) {
1791
43.3k
  int chk;
1792
1793
43.3k
  chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
1794
43.3k
  if (chk <= 0)
1795
2.05k
      ctxt->valid = 0;
1796
43.3k
  if (chk < 0)
1797
0
      ctxt->wellFormed = 0;
1798
43.3k
  ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
1799
43.3k
  ctxt->vctxt.flags |= XML_VCTXT_DTD_VALIDATED;
1800
43.3k
    }
1801
22.5M
#endif /* LIBXML_VALID_ENABLED */
1802
1803
22.5M
    if (prefix != NULL)
1804
672k
  xmlFree(prefix);
1805
1806
22.5M
}
1807
1808
/**
1809
 * xmlSAX2EndElement:
1810
 * @ctx: the user data (XML parser context)
1811
 * @name:  The element name
1812
 *
1813
 * called when the end of an element has been detected.
1814
 */
1815
void
1816
xmlSAX2EndElement(void *ctx, const xmlChar *name ATTRIBUTE_UNUSED)
1817
21.4M
{
1818
21.4M
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1819
21.4M
    xmlNodePtr cur;
1820
1821
21.4M
    if (ctx == NULL) return;
1822
21.4M
    cur = ctxt->node;
1823
#ifdef DEBUG_SAX
1824
    if (name == NULL)
1825
        xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(NULL)\n");
1826
    else
1827
  xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(%s)\n", name);
1828
#endif
1829
1830
    /* Capture end position and add node */
1831
21.4M
    if (cur != NULL && ctxt->record_info) {
1832
0
      ctxt->nodeInfo->end_pos = ctxt->input->cur - ctxt->input->base;
1833
0
      ctxt->nodeInfo->end_line = ctxt->input->line;
1834
0
      ctxt->nodeInfo->node = cur;
1835
0
      xmlParserAddNodeInfo(ctxt, ctxt->nodeInfo);
1836
0
    }
1837
21.4M
    ctxt->nodemem = -1;
1838
1839
21.4M
#ifdef LIBXML_VALID_ENABLED
1840
21.4M
    if (ctxt->validate && ctxt->wellFormed &&
1841
21.4M
        ctxt->myDoc && ctxt->myDoc->intSubset)
1842
4.95M
        ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc,
1843
4.95M
               cur);
1844
21.4M
#endif /* LIBXML_VALID_ENABLED */
1845
1846
1847
    /*
1848
     * end of parsing of this node.
1849
     */
1850
#ifdef DEBUG_SAX_TREE
1851
    xmlGenericError(xmlGenericErrorContext, "popping(%s)\n", cur->name);
1852
#endif
1853
21.4M
    nodePop(ctxt);
1854
21.4M
}
1855
#endif /* LIBXML_SAX1_ENABLED || LIBXML_HTML_ENABLED || LIBXML_LEGACY_ENABLED */
1856
1857
/*
1858
 * xmlSAX2TextNode:
1859
 * @ctxt:  the parser context
1860
 * @str:  the input string
1861
 * @len: the string length
1862
 *
1863
 * Callback for a text node
1864
 *
1865
 * Returns the newly allocated string or NULL if not needed or error
1866
 */
1867
static xmlNodePtr
1868
123M
xmlSAX2TextNode(xmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
1869
123M
    xmlNodePtr ret;
1870
123M
    const xmlChar *intern = NULL;
1871
1872
    /*
1873
     * Allocate
1874
     */
1875
123M
    if (ctxt->freeElems != NULL) {
1876
816k
  ret = ctxt->freeElems;
1877
816k
  ctxt->freeElems = ret->next;
1878
816k
  ctxt->freeElemsNr--;
1879
122M
    } else {
1880
122M
  ret = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
1881
122M
    }
1882
123M
    if (ret == NULL) {
1883
0
        xmlErrMemory(ctxt, "xmlSAX2Characters");
1884
0
  return(NULL);
1885
0
    }
1886
123M
    memset(ret, 0, sizeof(xmlNode));
1887
    /*
1888
     * intern the formatting blanks found between tags, or the
1889
     * very short strings
1890
     */
1891
123M
    if (ctxt->dictNames) {
1892
92.6M
        xmlChar cur = str[len];
1893
1894
92.6M
  if ((len < (int) (2 * sizeof(void *))) &&
1895
92.6M
      (ctxt->options & XML_PARSE_COMPACT)) {
1896
      /* store the string in the node overriding properties and nsDef */
1897
20.8M
      xmlChar *tmp = (xmlChar *) &(ret->properties);
1898
20.8M
      memcpy(tmp, str, len);
1899
20.8M
      tmp[len] = 0;
1900
20.8M
      intern = tmp;
1901
71.8M
  } else if ((len <= 3) && ((cur == '"') || (cur == '\'') ||
1902
23.4M
      ((cur == '<') && (str[len + 1] != '!')))) {
1903
22.0M
      intern = xmlDictLookup(ctxt->dict, str, len);
1904
49.8M
  } else if (IS_BLANK_CH(*str) && (len < 60) && (cur == '<') &&
1905
49.8M
             (str[len + 1] != '!')) {
1906
7.19M
      int i;
1907
1908
24.0M
      for (i = 1;i < len;i++) {
1909
20.8M
    if (!IS_BLANK_CH(str[i])) goto skip;
1910
20.8M
      }
1911
3.14M
      intern = xmlDictLookup(ctxt->dict, str, len);
1912
3.14M
  }
1913
92.6M
    }
1914
123M
skip:
1915
123M
    ret->type = XML_TEXT_NODE;
1916
1917
123M
    ret->name = xmlStringText;
1918
123M
    if (intern == NULL) {
1919
77.4M
  ret->content = xmlStrndup(str, len);
1920
77.4M
  if (ret->content == NULL) {
1921
0
      xmlSAX2ErrMemory(ctxt, "xmlSAX2TextNode");
1922
0
      xmlFree(ret);
1923
0
      return(NULL);
1924
0
  }
1925
77.4M
    } else
1926
45.9M
  ret->content = (xmlChar *) intern;
1927
1928
123M
    if (ctxt->linenumbers) {
1929
122M
  if (ctxt->input != NULL) {
1930
122M
      if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
1931
122M
    ret->line = ctxt->input->line;
1932
1.66k
      else {
1933
1.66k
          ret->line = USHRT_MAX;
1934
1.66k
    if (ctxt->options & XML_PARSE_BIG_LINES)
1935
887
        ret->psvi = (void *) (ptrdiff_t) ctxt->input->line;
1936
1.66k
      }
1937
122M
  }
1938
122M
    }
1939
1940
123M
    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
1941
0
  xmlRegisterNodeDefaultValue(ret);
1942
123M
    return(ret);
1943
123M
}
1944
1945
#ifdef LIBXML_VALID_ENABLED
1946
/*
1947
 * xmlSAX2DecodeAttrEntities:
1948
 * @ctxt:  the parser context
1949
 * @str:  the input string
1950
 * @len: the string length
1951
 *
1952
 * Remove the entities from an attribute value
1953
 *
1954
 * Returns the newly allocated string or NULL if not needed or error
1955
 */
1956
static xmlChar *
1957
xmlSAX2DecodeAttrEntities(xmlParserCtxtPtr ctxt, const xmlChar *str,
1958
3.37M
                          const xmlChar *end) {
1959
3.37M
    const xmlChar *in;
1960
3.37M
    xmlChar *ret;
1961
1962
3.37M
    in = str;
1963
36.5M
    while (in < end)
1964
33.2M
        if (*in++ == '&')
1965
91.8k
      goto decode;
1966
3.28M
    return(NULL);
1967
91.8k
decode:
1968
91.8k
    ctxt->depth++;
1969
91.8k
    ret = xmlStringLenDecodeEntities(ctxt, str, end - str,
1970
91.8k
             XML_SUBSTITUTE_REF, 0,0,0);
1971
91.8k
    ctxt->depth--;
1972
91.8k
    return(ret);
1973
3.37M
}
1974
#endif /* LIBXML_VALID_ENABLED */
1975
1976
/**
1977
 * xmlSAX2AttributeNs:
1978
 * @ctx: the user data (XML parser context)
1979
 * @localname:  the local name of the attribute
1980
 * @prefix:  the attribute namespace prefix if available
1981
 * @URI:  the attribute namespace name if available
1982
 * @value:  Start of the attribute value
1983
 * @valueend: end of the attribute value
1984
 *
1985
 * Handle an attribute that has been read by the parser.
1986
 * The default handling is to convert the attribute into an
1987
 * DOM subtree and past it in a new xmlAttr element added to
1988
 * the element.
1989
 */
1990
static void
1991
xmlSAX2AttributeNs(xmlParserCtxtPtr ctxt,
1992
                   const xmlChar * localname,
1993
                   const xmlChar * prefix,
1994
       const xmlChar * value,
1995
       const xmlChar * valueend)
1996
29.2M
{
1997
29.2M
    xmlAttrPtr ret;
1998
29.2M
    xmlNsPtr namespace = NULL;
1999
29.2M
    xmlChar *dup = NULL;
2000
2001
    /*
2002
     * Note: if prefix == NULL, the attribute is not in the default namespace
2003
     */
2004
29.2M
    if (prefix != NULL)
2005
592k
  namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, prefix);
2006
2007
    /*
2008
     * allocate the node
2009
     */
2010
29.2M
    if (ctxt->freeAttrs != NULL) {
2011
734k
        ret = ctxt->freeAttrs;
2012
734k
  ctxt->freeAttrs = ret->next;
2013
734k
  ctxt->freeAttrsNr--;
2014
734k
  memset(ret, 0, sizeof(xmlAttr));
2015
734k
  ret->type = XML_ATTRIBUTE_NODE;
2016
2017
734k
  ret->parent = ctxt->node;
2018
734k
  ret->doc = ctxt->myDoc;
2019
734k
  ret->ns = namespace;
2020
2021
734k
  if (ctxt->dictNames)
2022
655k
      ret->name = localname;
2023
78.6k
  else
2024
78.6k
      ret->name = xmlStrdup(localname);
2025
2026
        /* link at the end to preserve order, TODO speed up with a last */
2027
734k
  if (ctxt->node->properties == NULL) {
2028
734k
      ctxt->node->properties = ret;
2029
734k
  } else {
2030
0
      xmlAttrPtr prev = ctxt->node->properties;
2031
2032
0
      while (prev->next != NULL) prev = prev->next;
2033
0
      prev->next = ret;
2034
0
      ret->prev = prev;
2035
0
  }
2036
2037
734k
  if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
2038
0
      xmlRegisterNodeDefaultValue((xmlNodePtr)ret);
2039
28.5M
    } else {
2040
28.5M
  if (ctxt->dictNames)
2041
23.9M
      ret = xmlNewNsPropEatName(ctxt->node, namespace,
2042
23.9M
                                (xmlChar *) localname, NULL);
2043
4.56M
  else
2044
4.56M
      ret = xmlNewNsProp(ctxt->node, namespace, localname, NULL);
2045
28.5M
  if (ret == NULL) {
2046
0
      xmlErrMemory(ctxt, "xmlSAX2AttributeNs");
2047
0
      return;
2048
0
  }
2049
28.5M
    }
2050
2051
29.2M
    if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
2052
13.0M
  xmlNodePtr tmp;
2053
2054
  /*
2055
   * We know that if there is an entity reference, then
2056
   * the string has been dup'ed and terminates with 0
2057
   * otherwise with ' or "
2058
   */
2059
13.0M
  if (*valueend != 0) {
2060
11.9M
      tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
2061
11.9M
      ret->children = tmp;
2062
11.9M
      ret->last = tmp;
2063
11.9M
      if (tmp != NULL) {
2064
11.9M
    tmp->doc = ret->doc;
2065
11.9M
    tmp->parent = (xmlNodePtr) ret;
2066
11.9M
      }
2067
11.9M
  } else {
2068
1.06M
      ret->children = xmlStringLenGetNodeList(ctxt->myDoc, value,
2069
1.06M
                valueend - value);
2070
1.06M
      tmp = ret->children;
2071
2.85M
      while (tmp != NULL) {
2072
1.79M
          tmp->doc = ret->doc;
2073
1.79M
    tmp->parent = (xmlNodePtr) ret;
2074
1.79M
    if (tmp->next == NULL)
2075
1.06M
        ret->last = tmp;
2076
1.79M
    tmp = tmp->next;
2077
1.79M
      }
2078
1.06M
  }
2079
16.2M
    } else if (value != NULL) {
2080
16.2M
  xmlNodePtr tmp;
2081
2082
16.2M
  tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
2083
16.2M
  ret->children = tmp;
2084
16.2M
  ret->last = tmp;
2085
16.2M
  if (tmp != NULL) {
2086
16.2M
      tmp->doc = ret->doc;
2087
16.2M
      tmp->parent = (xmlNodePtr) ret;
2088
16.2M
  }
2089
16.2M
    }
2090
2091
29.2M
#ifdef LIBXML_VALID_ENABLED
2092
29.2M
    if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
2093
29.2M
        ctxt->myDoc && ctxt->myDoc->intSubset) {
2094
  /*
2095
   * If we don't substitute entities, the validation should be
2096
   * done on a value with replaced entities anyway.
2097
   */
2098
6.22M
        if (!ctxt->replaceEntities) {
2099
3.37M
      dup = xmlSAX2DecodeAttrEntities(ctxt, value, valueend);
2100
3.37M
      if (dup == NULL) {
2101
3.28M
          if (*valueend == 0) {
2102
336k
        ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2103
336k
            ctxt->myDoc, ctxt->node, ret, value);
2104
2.94M
    } else {
2105
        /*
2106
         * That should already be normalized.
2107
         * cheaper to finally allocate here than duplicate
2108
         * entry points in the full validation code
2109
         */
2110
2.94M
        dup = xmlStrndup(value, valueend - value);
2111
2112
2.94M
        ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2113
2.94M
            ctxt->myDoc, ctxt->node, ret, dup);
2114
2.94M
    }
2115
3.28M
      } else {
2116
          /*
2117
     * dup now contains a string of the flattened attribute
2118
     * content with entities substituted. Check if we need to
2119
     * apply an extra layer of normalization.
2120
     * It need to be done twice ... it's an extra burden related
2121
     * to the ability to keep references in attributes
2122
     */
2123
91.8k
    if (ctxt->attsSpecial != NULL) {
2124
78.0k
        xmlChar *nvalnorm;
2125
78.0k
        xmlChar fn[50];
2126
78.0k
        xmlChar *fullname;
2127
2128
78.0k
        fullname = xmlBuildQName(localname, prefix, fn, 50);
2129
78.0k
        if (fullname != NULL) {
2130
78.0k
      ctxt->vctxt.valid = 1;
2131
78.0k
            nvalnorm = xmlValidCtxtNormalizeAttributeValue(
2132
78.0k
                       &ctxt->vctxt, ctxt->myDoc,
2133
78.0k
           ctxt->node, fullname, dup);
2134
78.0k
      if (ctxt->vctxt.valid != 1)
2135
0
          ctxt->valid = 0;
2136
2137
78.0k
      if ((fullname != fn) && (fullname != localname))
2138
0
          xmlFree(fullname);
2139
78.0k
      if (nvalnorm != NULL) {
2140
2.07k
          xmlFree(dup);
2141
2.07k
          dup = nvalnorm;
2142
2.07k
      }
2143
78.0k
        }
2144
78.0k
    }
2145
2146
91.8k
    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2147
91.8k
              ctxt->myDoc, ctxt->node, ret, dup);
2148
91.8k
      }
2149
3.37M
  } else {
2150
      /*
2151
       * if entities already have been substituted, then
2152
       * the attribute as passed is already normalized
2153
       */
2154
2.85M
      dup = xmlStrndup(value, valueend - value);
2155
2156
2.85M
      ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2157
2.85M
                               ctxt->myDoc, ctxt->node, ret, dup);
2158
2.85M
  }
2159
6.22M
    } else
2160
23.0M
#endif /* LIBXML_VALID_ENABLED */
2161
23.0M
           if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
2162
23.0M
         (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
2163
23.0M
          ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0))) &&
2164
               /* Don't create IDs containing entity references */
2165
23.0M
               (ret->children != NULL) &&
2166
23.0M
               (ret->children->type == XML_TEXT_NODE) &&
2167
23.0M
               (ret->children->next == NULL)) {
2168
22.9M
        xmlChar *content = ret->children->content;
2169
        /*
2170
   * when validating, the ID registration is done at the attribute
2171
   * validation level. Otherwise we have to do specific handling here.
2172
   */
2173
22.9M
        if ((prefix == ctxt->str_xml) &&
2174
22.9M
             (localname[0] == 'i') && (localname[1] == 'd') &&
2175
22.9M
       (localname[2] == 0)) {
2176
      /*
2177
       * Add the xml:id value
2178
       *
2179
       * Open issue: normalization of the value.
2180
       */
2181
55.5k
#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
2182
55.5k
#ifdef LIBXML_VALID_ENABLED
2183
55.5k
      if (xmlValidateNCName(content, 1) != 0) {
2184
30.6k
          xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
2185
30.6k
          "xml:id : attribute value %s is not an NCName\n",
2186
30.6k
          (const char *) content, NULL);
2187
30.6k
      }
2188
55.5k
#endif
2189
55.5k
#endif
2190
55.5k
      xmlAddID(&ctxt->vctxt, ctxt->myDoc, content, ret);
2191
22.8M
  } else if (xmlIsID(ctxt->myDoc, ctxt->node, ret)) {
2192
2.01M
      xmlAddID(&ctxt->vctxt, ctxt->myDoc, content, ret);
2193
20.8M
  } else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret)) {
2194
4.65M
      xmlAddRef(&ctxt->vctxt, ctxt->myDoc, content, ret);
2195
4.65M
  }
2196
22.9M
    }
2197
29.2M
    if (dup != NULL)
2198
5.88M
  xmlFree(dup);
2199
29.2M
}
2200
2201
/**
2202
 * xmlSAX2StartElementNs:
2203
 * @ctx:  the user data (XML parser context)
2204
 * @localname:  the local name of the element
2205
 * @prefix:  the element namespace prefix if available
2206
 * @URI:  the element namespace name if available
2207
 * @nb_namespaces:  number of namespace definitions on that node
2208
 * @namespaces:  pointer to the array of prefix/URI pairs namespace definitions
2209
 * @nb_attributes:  the number of attributes on that node
2210
 * @nb_defaulted:  the number of defaulted attributes.
2211
 * @attributes:  pointer to the array of (localname/prefix/URI/value/end)
2212
 *               attribute values.
2213
 *
2214
 * SAX2 callback when an element start has been detected by the parser.
2215
 * It provides the namespace information for the element, as well as
2216
 * the new namespace declarations on the element.
2217
 */
2218
void
2219
xmlSAX2StartElementNs(void *ctx,
2220
                      const xmlChar *localname,
2221
          const xmlChar *prefix,
2222
          const xmlChar *URI,
2223
          int nb_namespaces,
2224
          const xmlChar **namespaces,
2225
          int nb_attributes,
2226
          int nb_defaulted,
2227
          const xmlChar **attributes)
2228
44.7M
{
2229
44.7M
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2230
44.7M
    xmlNodePtr ret;
2231
44.7M
    xmlNodePtr parent;
2232
44.7M
    xmlNsPtr last = NULL, ns;
2233
44.7M
    const xmlChar *uri, *pref;
2234
44.7M
    xmlChar *lname = NULL;
2235
44.7M
    int i, j;
2236
2237
44.7M
    if (ctx == NULL) return;
2238
44.7M
    parent = ctxt->node;
2239
    /*
2240
     * First check on validity:
2241
     */
2242
44.7M
    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
2243
44.7M
        ((ctxt->myDoc->intSubset == NULL) ||
2244
4.76M
   ((ctxt->myDoc->intSubset->notations == NULL) &&
2245
4.73M
    (ctxt->myDoc->intSubset->elements == NULL) &&
2246
4.73M
    (ctxt->myDoc->intSubset->attributes == NULL) &&
2247
4.73M
    (ctxt->myDoc->intSubset->entities == NULL)))) {
2248
41.2k
  xmlErrValid(ctxt, XML_DTD_NO_DTD,
2249
41.2k
    "Validation failed: no DTD found !", NULL, NULL);
2250
41.2k
  ctxt->validate = 0;
2251
41.2k
    }
2252
2253
    /*
2254
     * Take care of the rare case of an undefined namespace prefix
2255
     */
2256
44.7M
    if ((prefix != NULL) && (URI == NULL)) {
2257
734k
        if (ctxt->dictNames) {
2258
634k
      const xmlChar *fullname;
2259
2260
634k
      fullname = xmlDictQLookup(ctxt->dict, prefix, localname);
2261
634k
      if (fullname != NULL)
2262
634k
          localname = fullname;
2263
634k
  } else {
2264
100k
      lname = xmlBuildQName(localname, prefix, NULL, 0);
2265
100k
  }
2266
734k
    }
2267
    /*
2268
     * allocate the node
2269
     */
2270
44.7M
    if (ctxt->freeElems != NULL) {
2271
213k
        ret = ctxt->freeElems;
2272
213k
  ctxt->freeElems = ret->next;
2273
213k
  ctxt->freeElemsNr--;
2274
213k
  memset(ret, 0, sizeof(xmlNode));
2275
213k
        ret->doc = ctxt->myDoc;
2276
213k
  ret->type = XML_ELEMENT_NODE;
2277
2278
213k
  if (ctxt->dictNames)
2279
189k
      ret->name = localname;
2280
23.6k
  else {
2281
23.6k
      if (lname == NULL)
2282
23.5k
    ret->name = xmlStrdup(localname);
2283
157
      else
2284
157
          ret->name = lname;
2285
23.6k
      if (ret->name == NULL) {
2286
0
          xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
2287
0
    return;
2288
0
      }
2289
23.6k
  }
2290
213k
  if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
2291
0
      xmlRegisterNodeDefaultValue(ret);
2292
44.5M
    } else {
2293
44.5M
  if (ctxt->dictNames)
2294
38.7M
      ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
2295
38.7M
                                 (xmlChar *) localname, NULL);
2296
5.79M
  else if (lname == NULL)
2297
5.69M
      ret = xmlNewDocNode(ctxt->myDoc, NULL, localname, NULL);
2298
100k
  else
2299
100k
      ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
2300
100k
                                 (xmlChar *) lname, NULL);
2301
44.5M
  if (ret == NULL) {
2302
0
      xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
2303
0
      return;
2304
0
  }
2305
44.5M
    }
2306
44.7M
    if (ctxt->linenumbers) {
2307
44.6M
  if (ctxt->input != NULL) {
2308
44.6M
      if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
2309
44.6M
    ret->line = ctxt->input->line;
2310
146
      else
2311
146
          ret->line = USHRT_MAX;
2312
44.6M
  }
2313
44.6M
    }
2314
2315
44.7M
    if (parent == NULL) {
2316
1.06M
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
2317
1.06M
    }
2318
    /*
2319
     * Build the namespace list
2320
     */
2321
45.0M
    for (i = 0,j = 0;j < nb_namespaces;j++) {
2322
315k
        pref = namespaces[i++];
2323
315k
  uri = namespaces[i++];
2324
315k
  ns = xmlNewNs(NULL, uri, pref);
2325
315k
  if (ns != NULL) {
2326
315k
      if (last == NULL) {
2327
238k
          ret->nsDef = last = ns;
2328
238k
      } else {
2329
76.9k
          last->next = ns;
2330
76.9k
    last = ns;
2331
76.9k
      }
2332
315k
      if ((URI != NULL) && (prefix == pref))
2333
143k
    ret->ns = ns;
2334
315k
  } else {
2335
            /*
2336
             * any out of memory error would already have been raised
2337
             * but we can't be guaranteed it's the actual error due to the
2338
             * API, best is to skip in this case
2339
             */
2340
0
      continue;
2341
0
  }
2342
315k
#ifdef LIBXML_VALID_ENABLED
2343
315k
  if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
2344
315k
      ctxt->myDoc && ctxt->myDoc->intSubset) {
2345
12.4k
      ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
2346
12.4k
                                             ret, prefix, ns, uri);
2347
12.4k
  }
2348
315k
#endif /* LIBXML_VALID_ENABLED */
2349
315k
    }
2350
44.7M
    ctxt->nodemem = -1;
2351
2352
    /*
2353
     * We are parsing a new node.
2354
     */
2355
44.7M
    if (nodePush(ctxt, ret) < 0) {
2356
75
        xmlUnlinkNode(ret);
2357
75
        xmlFreeNode(ret);
2358
75
        return;
2359
75
    }
2360
2361
    /*
2362
     * Link the child element
2363
     */
2364
44.7M
    if (parent != NULL) {
2365
43.6M
        if (parent->type == XML_ELEMENT_NODE) {
2366
43.6M
      xmlAddChild(parent, ret);
2367
43.6M
  } else {
2368
0
      xmlAddSibling(parent, ret);
2369
0
  }
2370
43.6M
    }
2371
2372
    /*
2373
     * Insert the defaulted attributes from the DTD only if requested:
2374
     */
2375
44.7M
    if ((nb_defaulted != 0) &&
2376
44.7M
        ((ctxt->loadsubset & XML_COMPLETE_ATTRS) == 0))
2377
990k
  nb_attributes -= nb_defaulted;
2378
2379
    /*
2380
     * Search the namespace if it wasn't already found
2381
     * Note that, if prefix is NULL, this searches for the default Ns
2382
     */
2383
44.7M
    if ((URI != NULL) && (ret->ns == NULL)) {
2384
1.21M
        ret->ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
2385
1.21M
  if ((ret->ns == NULL) && (xmlStrEqual(prefix, BAD_CAST "xml"))) {
2386
728
      ret->ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
2387
728
  }
2388
1.21M
  if (ret->ns == NULL) {
2389
643k
      ns = xmlNewNs(ret, NULL, prefix);
2390
643k
      if (ns == NULL) {
2391
2392
0
          xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
2393
0
    return;
2394
0
      }
2395
643k
            if (prefix != NULL)
2396
130k
                xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
2397
130k
                             "Namespace prefix %s was not found\n",
2398
130k
                             prefix, NULL);
2399
512k
            else
2400
512k
                xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
2401
512k
                             "Namespace default prefix was not found\n",
2402
512k
                             NULL, NULL);
2403
643k
  }
2404
1.21M
    }
2405
2406
    /*
2407
     * process all the other attributes
2408
     */
2409
44.7M
    if (nb_attributes > 0) {
2410
50.9M
        for (j = 0,i = 0;i < nb_attributes;i++,j+=5) {
2411
      /*
2412
       * Handle the rare case of an undefined attribute prefix
2413
       */
2414
29.2M
      if ((attributes[j+1] != NULL) && (attributes[j+2] == NULL)) {
2415
291k
    if (ctxt->dictNames) {
2416
246k
        const xmlChar *fullname;
2417
2418
246k
        fullname = xmlDictQLookup(ctxt->dict, attributes[j+1],
2419
246k
                                  attributes[j]);
2420
246k
        if (fullname != NULL) {
2421
246k
      xmlSAX2AttributeNs(ctxt, fullname, NULL,
2422
246k
                         attributes[j+3], attributes[j+4]);
2423
246k
            continue;
2424
246k
        }
2425
246k
    } else {
2426
44.4k
        lname = xmlBuildQName(attributes[j], attributes[j+1],
2427
44.4k
                              NULL, 0);
2428
44.4k
        if (lname != NULL) {
2429
44.4k
      xmlSAX2AttributeNs(ctxt, lname, NULL,
2430
44.4k
                         attributes[j+3], attributes[j+4]);
2431
44.4k
      xmlFree(lname);
2432
44.4k
            continue;
2433
44.4k
        }
2434
44.4k
    }
2435
291k
      }
2436
28.9M
      xmlSAX2AttributeNs(ctxt, attributes[j], attributes[j+1],
2437
28.9M
             attributes[j+3], attributes[j+4]);
2438
28.9M
  }
2439
21.6M
    }
2440
2441
44.7M
#ifdef LIBXML_VALID_ENABLED
2442
    /*
2443
     * If it's the Document root, finish the DTD validation and
2444
     * check the document root element for validity
2445
     */
2446
44.7M
    if ((ctxt->validate) &&
2447
44.7M
        ((ctxt->vctxt.flags & XML_VCTXT_DTD_VALIDATED) == 0)) {
2448
61.1k
  int chk;
2449
2450
61.1k
  chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
2451
61.1k
  if (chk <= 0)
2452
2.71k
      ctxt->valid = 0;
2453
61.1k
  if (chk < 0)
2454
0
      ctxt->wellFormed = 0;
2455
61.1k
  ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
2456
61.1k
  ctxt->vctxt.flags |= XML_VCTXT_DTD_VALIDATED;
2457
61.1k
    }
2458
44.7M
#endif /* LIBXML_VALID_ENABLED */
2459
44.7M
}
2460
2461
/**
2462
 * xmlSAX2EndElementNs:
2463
 * @ctx:  the user data (XML parser context)
2464
 * @localname:  the local name of the element
2465
 * @prefix:  the element namespace prefix if available
2466
 * @URI:  the element namespace name if available
2467
 *
2468
 * SAX2 callback when an element end has been detected by the parser.
2469
 * It provides the namespace information for the element.
2470
 */
2471
void
2472
xmlSAX2EndElementNs(void *ctx,
2473
                    const xmlChar * localname ATTRIBUTE_UNUSED,
2474
                    const xmlChar * prefix ATTRIBUTE_UNUSED,
2475
        const xmlChar * URI ATTRIBUTE_UNUSED)
2476
43.1M
{
2477
43.1M
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2478
43.1M
    xmlParserNodeInfo node_info;
2479
43.1M
    xmlNodePtr cur;
2480
2481
43.1M
    if (ctx == NULL) return;
2482
43.1M
    cur = ctxt->node;
2483
    /* Capture end position and add node */
2484
43.1M
    if ((ctxt->record_info) && (cur != NULL)) {
2485
0
        node_info.end_pos = ctxt->input->cur - ctxt->input->base;
2486
0
        node_info.end_line = ctxt->input->line;
2487
0
        node_info.node = cur;
2488
0
        xmlParserAddNodeInfo(ctxt, &node_info);
2489
0
    }
2490
43.1M
    ctxt->nodemem = -1;
2491
2492
43.1M
#ifdef LIBXML_VALID_ENABLED
2493
43.1M
    if (ctxt->validate && ctxt->wellFormed &&
2494
43.1M
        ctxt->myDoc && ctxt->myDoc->intSubset)
2495
11.3M
        ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc, cur);
2496
43.1M
#endif /* LIBXML_VALID_ENABLED */
2497
2498
    /*
2499
     * end of parsing of this node.
2500
     */
2501
43.1M
    nodePop(ctxt);
2502
43.1M
}
2503
2504
/**
2505
 * xmlSAX2Reference:
2506
 * @ctx: the user data (XML parser context)
2507
 * @name:  The entity name
2508
 *
2509
 * called when an entity xmlSAX2Reference is detected.
2510
 */
2511
void
2512
xmlSAX2Reference(void *ctx, const xmlChar *name)
2513
3.12M
{
2514
3.12M
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2515
3.12M
    xmlNodePtr ret;
2516
2517
3.12M
    if (ctx == NULL) return;
2518
#ifdef DEBUG_SAX
2519
    xmlGenericError(xmlGenericErrorContext,
2520
      "SAX.xmlSAX2Reference(%s)\n", name);
2521
#endif
2522
3.12M
    if (name[0] == '#')
2523
6.73k
  ret = xmlNewCharRef(ctxt->myDoc, name);
2524
3.12M
    else
2525
3.12M
  ret = xmlNewReference(ctxt->myDoc, name);
2526
#ifdef DEBUG_SAX_TREE
2527
    xmlGenericError(xmlGenericErrorContext,
2528
      "add xmlSAX2Reference %s to %s \n", name, ctxt->node->name);
2529
#endif
2530
3.12M
    if (xmlAddChild(ctxt->node, ret) == NULL) {
2531
243k
        xmlFreeNode(ret);
2532
243k
    }
2533
3.12M
}
2534
2535
/**
2536
 * xmlSAX2Text:
2537
 * @ctx: the user data (XML parser context)
2538
 * @ch:  a xmlChar string
2539
 * @len: the number of xmlChar
2540
 * @type: text or cdata
2541
 *
2542
 * Append characters.
2543
 */
2544
static void
2545
xmlSAX2Text(xmlParserCtxtPtr ctxt, const xmlChar *ch, int len,
2546
            xmlElementType type)
2547
135M
{
2548
135M
    xmlNodePtr lastChild;
2549
2550
135M
    if (ctxt == NULL) return;
2551
#ifdef DEBUG_SAX
2552
    xmlGenericError(xmlGenericErrorContext,
2553
      "SAX.xmlSAX2Characters(%.30s, %d)\n", ch, len);
2554
#endif
2555
    /*
2556
     * Handle the data if any. If there is no child
2557
     * add it as content, otherwise if the last child is text,
2558
     * concatenate it, else create a new node of type text.
2559
     */
2560
2561
135M
    if (ctxt->node == NULL) {
2562
#ifdef DEBUG_SAX_TREE
2563
  xmlGenericError(xmlGenericErrorContext,
2564
    "add chars: ctxt->node == NULL !\n");
2565
#endif
2566
13.9M
        return;
2567
13.9M
    }
2568
121M
    lastChild = ctxt->node->last;
2569
#ifdef DEBUG_SAX_TREE
2570
    xmlGenericError(xmlGenericErrorContext,
2571
      "add chars to %s \n", ctxt->node->name);
2572
#endif
2573
2574
    /*
2575
     * Here we needed an accelerator mechanism in case of very large
2576
     * elements. Use an attribute in the structure !!!
2577
     */
2578
121M
    if (lastChild == NULL) {
2579
45.3M
        if (type == XML_TEXT_NODE)
2580
45.1M
            lastChild = xmlSAX2TextNode(ctxt, ch, len);
2581
188k
        else
2582
188k
            lastChild = xmlNewCDataBlock(ctxt->myDoc, ch, len);
2583
45.3M
  if (lastChild != NULL) {
2584
45.3M
      ctxt->node->children = lastChild;
2585
45.3M
      ctxt->node->last = lastChild;
2586
45.3M
      lastChild->parent = ctxt->node;
2587
45.3M
      lastChild->doc = ctxt->node->doc;
2588
45.3M
      ctxt->nodelen = len;
2589
45.3M
      ctxt->nodemem = len + 1;
2590
45.3M
  } else {
2591
0
      xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
2592
0
      return;
2593
0
  }
2594
76.1M
    } else {
2595
76.1M
  int coalesceText = (lastChild != NULL) &&
2596
76.1M
      (lastChild->type == type) &&
2597
76.1M
      ((type != XML_TEXT_NODE) ||
2598
26.0M
             (lastChild->name == xmlStringText));
2599
76.1M
  if ((coalesceText) && (ctxt->nodemem != 0)) {
2600
      /*
2601
       * The whole point of maintaining nodelen and nodemem,
2602
       * xmlTextConcat is too costly, i.e. compute length,
2603
       * reallocate a new buffer, move data, append ch. Here
2604
       * We try to minimize realloc() uses and avoid copying
2605
       * and recomputing length over and over.
2606
       */
2607
25.0M
      if (lastChild->content == (xmlChar *)&(lastChild->properties)) {
2608
502k
    lastChild->content = xmlStrdup(lastChild->content);
2609
502k
    lastChild->properties = NULL;
2610
24.5M
      } else if ((ctxt->nodemem == ctxt->nodelen + 1) &&
2611
24.5M
                 (xmlDictOwns(ctxt->dict, lastChild->content))) {
2612
12.5k
    lastChild->content = xmlStrdup(lastChild->content);
2613
12.5k
      }
2614
25.0M
      if (lastChild->content == NULL) {
2615
0
    xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters: xmlStrdup returned NULL");
2616
0
    return;
2617
0
      }
2618
25.0M
      if (ctxt->nodelen > INT_MAX - len) {
2619
0
                xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters overflow prevented");
2620
0
                return;
2621
0
      }
2622
25.0M
            if ((ctxt->nodelen + len > XML_MAX_TEXT_LENGTH) &&
2623
25.0M
                ((ctxt->options & XML_PARSE_HUGE) == 0)) {
2624
0
                xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters: huge text node");
2625
0
                return;
2626
0
            }
2627
25.0M
      if (ctxt->nodelen + len >= ctxt->nodemem) {
2628
5.12M
    xmlChar *newbuf;
2629
5.12M
    int size;
2630
2631
5.12M
    size = ctxt->nodemem > INT_MAX - len ?
2632
0
                       INT_MAX :
2633
5.12M
                       ctxt->nodemem + len;
2634
5.12M
    size = size > INT_MAX / 2 ? INT_MAX : size * 2;
2635
5.12M
                newbuf = (xmlChar *) xmlRealloc(lastChild->content,size);
2636
5.12M
    if (newbuf == NULL) {
2637
0
        xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
2638
0
        return;
2639
0
    }
2640
5.12M
    ctxt->nodemem = size;
2641
5.12M
    lastChild->content = newbuf;
2642
5.12M
      }
2643
25.0M
      memcpy(&lastChild->content[ctxt->nodelen], ch, len);
2644
25.0M
      ctxt->nodelen += len;
2645
25.0M
      lastChild->content[ctxt->nodelen] = 0;
2646
51.0M
  } else if (coalesceText) {
2647
919k
      if (xmlTextConcat(lastChild, ch, len)) {
2648
0
    xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
2649
0
      }
2650
919k
      if (ctxt->node->children != NULL) {
2651
919k
    ctxt->nodelen = xmlStrlen(lastChild->content);
2652
919k
    ctxt->nodemem = ctxt->nodelen + 1;
2653
919k
      }
2654
50.1M
  } else {
2655
      /* Mixed content, first time */
2656
50.1M
            if (type == XML_TEXT_NODE) {
2657
50.0M
                lastChild = xmlSAX2TextNode(ctxt, ch, len);
2658
50.0M
                if (lastChild != NULL)
2659
50.0M
                    lastChild->doc = ctxt->myDoc;
2660
50.0M
            } else
2661
13.2k
                lastChild = xmlNewCDataBlock(ctxt->myDoc, ch, len);
2662
50.1M
      if (lastChild != NULL) {
2663
50.1M
    xmlAddChild(ctxt->node, lastChild);
2664
50.1M
    if (ctxt->node->children != NULL) {
2665
50.1M
        ctxt->nodelen = len;
2666
50.1M
        ctxt->nodemem = len + 1;
2667
50.1M
    }
2668
50.1M
      }
2669
50.1M
  }
2670
76.1M
    }
2671
121M
}
2672
2673
/**
2674
 * xmlSAX2Characters:
2675
 * @ctx: the user data (XML parser context)
2676
 * @ch:  a xmlChar string
2677
 * @len: the number of xmlChar
2678
 *
2679
 * receiving some chars from the parser.
2680
 */
2681
void
2682
xmlSAX2Characters(void *ctx, const xmlChar *ch, int len)
2683
135M
{
2684
135M
    xmlSAX2Text((xmlParserCtxtPtr) ctx, ch, len, XML_TEXT_NODE);
2685
135M
}
2686
2687
/**
2688
 * xmlSAX2IgnorableWhitespace:
2689
 * @ctx: the user data (XML parser context)
2690
 * @ch:  a xmlChar string
2691
 * @len: the number of xmlChar
2692
 *
2693
 * receiving some ignorable whitespaces from the parser.
2694
 * UNUSED: by default the DOM building will use xmlSAX2Characters
2695
 */
2696
void
2697
xmlSAX2IgnorableWhitespace(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED)
2698
13.3M
{
2699
    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
2700
#ifdef DEBUG_SAX
2701
    xmlGenericError(xmlGenericErrorContext,
2702
      "SAX.xmlSAX2IgnorableWhitespace(%.30s, %d)\n", ch, len);
2703
#endif
2704
13.3M
}
2705
2706
/**
2707
 * xmlSAX2ProcessingInstruction:
2708
 * @ctx: the user data (XML parser context)
2709
 * @target:  the target name
2710
 * @data: the PI data's
2711
 *
2712
 * A processing instruction has been parsed.
2713
 */
2714
void
2715
xmlSAX2ProcessingInstruction(void *ctx, const xmlChar *target,
2716
                      const xmlChar *data)
2717
361k
{
2718
361k
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2719
361k
    xmlNodePtr ret;
2720
361k
    xmlNodePtr parent;
2721
2722
361k
    if (ctx == NULL) return;
2723
361k
    parent = ctxt->node;
2724
#ifdef DEBUG_SAX
2725
    xmlGenericError(xmlGenericErrorContext,
2726
      "SAX.xmlSAX2ProcessingInstruction(%s, %s)\n", target, data);
2727
#endif
2728
2729
361k
    ret = xmlNewDocPI(ctxt->myDoc, target, data);
2730
361k
    if (ret == NULL) return;
2731
2732
361k
    if (ctxt->linenumbers) {
2733
360k
  if (ctxt->input != NULL) {
2734
360k
      if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
2735
360k
    ret->line = ctxt->input->line;
2736
45
      else
2737
45
          ret->line = USHRT_MAX;
2738
360k
  }
2739
360k
    }
2740
361k
    if (ctxt->inSubset == 1) {
2741
1.52k
  xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
2742
1.52k
  return;
2743
360k
    } else if (ctxt->inSubset == 2) {
2744
15.7k
  xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
2745
15.7k
  return;
2746
15.7k
    }
2747
344k
    if (parent == NULL) {
2748
#ifdef DEBUG_SAX_TREE
2749
      xmlGenericError(xmlGenericErrorContext,
2750
        "Setting PI %s as root\n", target);
2751
#endif
2752
176k
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
2753
176k
  return;
2754
176k
    }
2755
168k
    if (parent->type == XML_ELEMENT_NODE) {
2756
#ifdef DEBUG_SAX_TREE
2757
  xmlGenericError(xmlGenericErrorContext,
2758
    "adding PI %s child to %s\n", target, parent->name);
2759
#endif
2760
168k
  xmlAddChild(parent, ret);
2761
168k
    } else {
2762
#ifdef DEBUG_SAX_TREE
2763
  xmlGenericError(xmlGenericErrorContext,
2764
    "adding PI %s sibling to ", target);
2765
  xmlDebugDumpOneNode(stderr, parent, 0);
2766
#endif
2767
0
  xmlAddSibling(parent, ret);
2768
0
    }
2769
168k
}
2770
2771
/**
2772
 * xmlSAX2Comment:
2773
 * @ctx: the user data (XML parser context)
2774
 * @value:  the xmlSAX2Comment content
2775
 *
2776
 * A xmlSAX2Comment has been parsed.
2777
 */
2778
void
2779
xmlSAX2Comment(void *ctx, const xmlChar *value)
2780
124M
{
2781
124M
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2782
124M
    xmlNodePtr ret;
2783
124M
    xmlNodePtr parent;
2784
2785
124M
    if (ctx == NULL) return;
2786
124M
    parent = ctxt->node;
2787
#ifdef DEBUG_SAX
2788
    xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2Comment(%s)\n", value);
2789
#endif
2790
124M
    ret = xmlNewDocComment(ctxt->myDoc, value);
2791
124M
    if (ret == NULL) return;
2792
124M
    if (ctxt->linenumbers) {
2793
124M
  if (ctxt->input != NULL) {
2794
124M
      if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
2795
124M
    ret->line = ctxt->input->line;
2796
74
      else
2797
74
          ret->line = USHRT_MAX;
2798
124M
  }
2799
124M
    }
2800
2801
124M
    if (ctxt->inSubset == 1) {
2802
109M
  xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
2803
109M
  return;
2804
109M
    } else if (ctxt->inSubset == 2) {
2805
13.9M
  xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
2806
13.9M
  return;
2807
13.9M
    }
2808
1.46M
    if (parent == NULL) {
2809
#ifdef DEBUG_SAX_TREE
2810
      xmlGenericError(xmlGenericErrorContext,
2811
        "Setting xmlSAX2Comment as root\n");
2812
#endif
2813
203k
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
2814
203k
  return;
2815
203k
    }
2816
1.25M
    if (parent->type == XML_ELEMENT_NODE) {
2817
#ifdef DEBUG_SAX_TREE
2818
  xmlGenericError(xmlGenericErrorContext,
2819
    "adding xmlSAX2Comment child to %s\n", parent->name);
2820
#endif
2821
1.25M
  xmlAddChild(parent, ret);
2822
1.25M
    } else {
2823
#ifdef DEBUG_SAX_TREE
2824
  xmlGenericError(xmlGenericErrorContext,
2825
    "adding xmlSAX2Comment sibling to ");
2826
  xmlDebugDumpOneNode(stderr, parent, 0);
2827
#endif
2828
0
  xmlAddSibling(parent, ret);
2829
0
    }
2830
1.25M
}
2831
2832
/**
2833
 * xmlSAX2CDataBlock:
2834
 * @ctx: the user data (XML parser context)
2835
 * @value:  The pcdata content
2836
 * @len:  the block length
2837
 *
2838
 * called when a pcdata block has been parsed
2839
 */
2840
void
2841
xmlSAX2CDataBlock(void *ctx, const xmlChar *value, int len)
2842
269k
{
2843
269k
    xmlSAX2Text((xmlParserCtxtPtr) ctx, value, len, XML_CDATA_SECTION_NODE);
2844
269k
}
2845
2846
static int xmlSAX2DefaultVersionValue = 2;
2847
2848
#ifdef LIBXML_SAX1_ENABLED
2849
/**
2850
 * xmlSAXDefaultVersion:
2851
 * @version:  the version, 1 or 2
2852
 *
2853
 * DEPRECATED: Use parser option XML_PARSE_SAX1.
2854
 *
2855
 * Set the default version of SAX used globally by the library.
2856
 * By default, during initialization the default is set to 2.
2857
 * Note that it is generally a better coding style to use
2858
 * xmlSAXVersion() to set up the version explicitly for a given
2859
 * parsing context.
2860
 *
2861
 * Returns the previous value in case of success and -1 in case of error.
2862
 */
2863
int
2864
xmlSAXDefaultVersion(int version)
2865
0
{
2866
0
    int ret = xmlSAX2DefaultVersionValue;
2867
2868
0
    if ((version != 1) && (version != 2))
2869
0
        return(-1);
2870
0
    xmlSAX2DefaultVersionValue = version;
2871
0
    return(ret);
2872
0
}
2873
#endif /* LIBXML_SAX1_ENABLED */
2874
2875
/**
2876
 * xmlSAXVersion:
2877
 * @hdlr:  the SAX handler
2878
 * @version:  the version, 1 or 2
2879
 *
2880
 * Initialize the default XML SAX handler according to the version
2881
 *
2882
 * Returns 0 in case of success and -1 in case of error.
2883
 */
2884
int
2885
xmlSAXVersion(xmlSAXHandler *hdlr, int version)
2886
1.51M
{
2887
1.51M
    if (hdlr == NULL) return(-1);
2888
1.51M
    if (version == 2) {
2889
1.51M
  hdlr->startElement = NULL;
2890
1.51M
  hdlr->endElement = NULL;
2891
1.51M
  hdlr->startElementNs = xmlSAX2StartElementNs;
2892
1.51M
  hdlr->endElementNs = xmlSAX2EndElementNs;
2893
1.51M
  hdlr->serror = NULL;
2894
1.51M
  hdlr->initialized = XML_SAX2_MAGIC;
2895
1.51M
#ifdef LIBXML_SAX1_ENABLED
2896
1.51M
    } else if (version == 1) {
2897
0
  hdlr->startElement = xmlSAX2StartElement;
2898
0
  hdlr->endElement = xmlSAX2EndElement;
2899
0
  hdlr->initialized = 1;
2900
0
#endif /* LIBXML_SAX1_ENABLED */
2901
0
    } else
2902
0
        return(-1);
2903
1.51M
    hdlr->internalSubset = xmlSAX2InternalSubset;
2904
1.51M
    hdlr->externalSubset = xmlSAX2ExternalSubset;
2905
1.51M
    hdlr->isStandalone = xmlSAX2IsStandalone;
2906
1.51M
    hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
2907
1.51M
    hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
2908
1.51M
    hdlr->resolveEntity = xmlSAX2ResolveEntity;
2909
1.51M
    hdlr->getEntity = xmlSAX2GetEntity;
2910
1.51M
    hdlr->getParameterEntity = xmlSAX2GetParameterEntity;
2911
1.51M
    hdlr->entityDecl = xmlSAX2EntityDecl;
2912
1.51M
    hdlr->attributeDecl = xmlSAX2AttributeDecl;
2913
1.51M
    hdlr->elementDecl = xmlSAX2ElementDecl;
2914
1.51M
    hdlr->notationDecl = xmlSAX2NotationDecl;
2915
1.51M
    hdlr->unparsedEntityDecl = xmlSAX2UnparsedEntityDecl;
2916
1.51M
    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
2917
1.51M
    hdlr->startDocument = xmlSAX2StartDocument;
2918
1.51M
    hdlr->endDocument = xmlSAX2EndDocument;
2919
1.51M
    hdlr->reference = xmlSAX2Reference;
2920
1.51M
    hdlr->characters = xmlSAX2Characters;
2921
1.51M
    hdlr->cdataBlock = xmlSAX2CDataBlock;
2922
1.51M
    hdlr->ignorableWhitespace = xmlSAX2Characters;
2923
1.51M
    hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
2924
1.51M
    hdlr->comment = xmlSAX2Comment;
2925
1.51M
    hdlr->warning = xmlParserWarning;
2926
1.51M
    hdlr->error = xmlParserError;
2927
1.51M
    hdlr->fatalError = xmlParserError;
2928
2929
1.51M
    return(0);
2930
1.51M
}
2931
2932
/**
2933
 * xmlSAX2InitDefaultSAXHandler:
2934
 * @hdlr:  the SAX handler
2935
 * @warning:  flag if non-zero sets the handler warning procedure
2936
 *
2937
 * Initialize the default XML SAX2 handler
2938
 */
2939
void
2940
xmlSAX2InitDefaultSAXHandler(xmlSAXHandler *hdlr, int warning)
2941
0
{
2942
0
    if ((hdlr == NULL) || (hdlr->initialized != 0))
2943
0
  return;
2944
2945
0
    xmlSAXVersion(hdlr, xmlSAX2DefaultVersionValue);
2946
0
    if (warning == 0)
2947
0
  hdlr->warning = NULL;
2948
0
    else
2949
0
  hdlr->warning = xmlParserWarning;
2950
0
}
2951
2952
/**
2953
 * xmlDefaultSAXHandlerInit:
2954
 *
2955
 * DEPRECATED: This function is a no-op. Call xmlInitParser to
2956
 * initialize the library.
2957
 *
2958
 * Initialize the default SAX2 handler
2959
 */
2960
void
2961
xmlDefaultSAXHandlerInit(void)
2962
0
{
2963
0
}
2964
2965
#ifdef LIBXML_HTML_ENABLED
2966
2967
/**
2968
 * xmlSAX2InitHtmlDefaultSAXHandler:
2969
 * @hdlr:  the SAX handler
2970
 *
2971
 * Initialize the default HTML SAX2 handler
2972
 */
2973
void
2974
xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr)
2975
0
{
2976
0
    if ((hdlr == NULL) || (hdlr->initialized != 0))
2977
0
  return;
2978
2979
0
    hdlr->internalSubset = xmlSAX2InternalSubset;
2980
0
    hdlr->externalSubset = NULL;
2981
0
    hdlr->isStandalone = NULL;
2982
0
    hdlr->hasInternalSubset = NULL;
2983
0
    hdlr->hasExternalSubset = NULL;
2984
0
    hdlr->resolveEntity = NULL;
2985
0
    hdlr->getEntity = xmlSAX2GetEntity;
2986
0
    hdlr->getParameterEntity = NULL;
2987
0
    hdlr->entityDecl = NULL;
2988
0
    hdlr->attributeDecl = NULL;
2989
0
    hdlr->elementDecl = NULL;
2990
0
    hdlr->notationDecl = NULL;
2991
0
    hdlr->unparsedEntityDecl = NULL;
2992
0
    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
2993
0
    hdlr->startDocument = xmlSAX2StartDocument;
2994
0
    hdlr->endDocument = xmlSAX2EndDocument;
2995
0
    hdlr->startElement = xmlSAX2StartElement;
2996
0
    hdlr->endElement = xmlSAX2EndElement;
2997
0
    hdlr->reference = NULL;
2998
0
    hdlr->characters = xmlSAX2Characters;
2999
0
    hdlr->cdataBlock = xmlSAX2CDataBlock;
3000
0
    hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
3001
0
    hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
3002
0
    hdlr->comment = xmlSAX2Comment;
3003
0
    hdlr->warning = xmlParserWarning;
3004
0
    hdlr->error = xmlParserError;
3005
0
    hdlr->fatalError = xmlParserError;
3006
3007
0
    hdlr->initialized = 1;
3008
0
}
3009
3010
/**
3011
 * htmlDefaultSAXHandlerInit:
3012
 *
3013
 * DEPRECATED: This function is a no-op. Call xmlInitParser to
3014
 * initialize the library.
3015
 */
3016
void
3017
htmlDefaultSAXHandlerInit(void)
3018
0
{
3019
0
}
3020
3021
#endif /* LIBXML_HTML_ENABLED */