Coverage Report

Created: 2023-09-25 06:03

/src/libxml2-2.11.5/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
0
{
100
0
    xmlStructuredErrorFunc schannel = NULL;
101
102
0
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
103
0
        (ctxt->instate == XML_PARSER_EOF))
104
0
  return;
105
0
    if (ctxt != NULL) {
106
0
  ctxt->errNo = error;
107
0
  if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
108
0
      schannel = ctxt->sax->serror;
109
0
  __xmlRaiseError(schannel,
110
0
      ctxt->vctxt.error, ctxt->vctxt.userData,
111
0
      ctxt, NULL, XML_FROM_DTD, error,
112
0
      XML_ERR_ERROR, NULL, 0, (const char *) str1,
113
0
      (const char *) str2, NULL, 0, 0,
114
0
      msg, (const char *) str1, (const char *) str2);
115
0
  ctxt->valid = 0;
116
0
    } 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
0
}
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
0
{
140
0
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
141
0
        (ctxt->instate == XML_PARSER_EOF))
142
0
  return;
143
0
    if (ctxt != NULL)
144
0
  ctxt->errNo = error;
145
0
    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
146
0
                    XML_ERR_FATAL, NULL, 0,
147
0
        (const char *) str1, (const char *) str2,
148
0
        NULL, 0, 0, msg, str1, str2);
149
0
    if (ctxt != NULL) {
150
0
  ctxt->wellFormed = 0;
151
0
  ctxt->valid = 0;
152
0
  if (ctxt->recovery == 0)
153
0
      ctxt->disableSAX = 1;
154
0
    }
155
0
}
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
0
{
171
0
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
172
0
        (ctxt->instate == XML_PARSER_EOF))
173
0
  return;
174
0
    if (ctxt != NULL)
175
0
  ctxt->errNo = error;
176
0
    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
177
0
                    XML_ERR_WARNING, NULL, 0,
178
0
        (const char *) str1, NULL,
179
0
        NULL, 0, 0, msg, str1);
180
0
}
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
0
{
195
0
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
196
0
        (ctxt->instate == XML_PARSER_EOF))
197
0
  return;
198
0
    if (ctxt != NULL)
199
0
  ctxt->errNo = error;
200
0
    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
201
0
                    XML_ERR_WARNING, NULL, 0,
202
0
        (const char *) str1, (const char *) str2,
203
0
        NULL, 0, 0, msg, str1, str2);
204
0
}
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
0
{
331
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
332
0
    xmlDtdPtr dtd;
333
0
    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
0
    if (ctxt->myDoc == NULL)
341
0
  return;
342
0
    dtd = xmlGetIntSubset(ctxt->myDoc);
343
0
    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
0
    ctxt->myDoc->intSubset =
351
0
  xmlCreateIntSubset(ctxt->myDoc, name, ExternalID, SystemID);
352
0
    if (ctxt->myDoc->intSubset == NULL)
353
0
        xmlSAX2ErrMemory(ctxt, "xmlSAX2InternalSubset");
354
0
}
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
0
{
369
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
370
0
    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
0
    if (((ExternalID != NULL) || (SystemID != NULL)) &&
377
0
        (((ctxt->validate) || (ctxt->loadsubset != 0)) &&
378
0
   (ctxt->wellFormed && ctxt->myDoc))) {
379
  /*
380
   * Try to fetch and parse the external subset.
381
   */
382
0
  xmlParserInputPtr oldinput;
383
0
  int oldinputNr;
384
0
  int oldinputMax;
385
0
  xmlParserInputPtr *oldinputTab;
386
0
  xmlParserInputPtr input = NULL;
387
0
  xmlCharEncoding enc;
388
0
  int oldcharset;
389
0
  const xmlChar *oldencoding;
390
0
  int oldprogressive;
391
0
        unsigned long consumed;
392
0
        size_t buffered;
393
394
  /*
395
   * Ask the Entity resolver to load the damn thing
396
   */
397
0
  if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
398
0
      input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
399
0
                                          SystemID);
400
0
  if (input == NULL) {
401
0
      return;
402
0
  }
403
404
0
  xmlNewDtd(ctxt->myDoc, name, ExternalID, SystemID);
405
406
  /*
407
   * make sure we won't destroy the main document context
408
   */
409
0
  oldinput = ctxt->input;
410
0
  oldinputNr = ctxt->inputNr;
411
0
  oldinputMax = ctxt->inputMax;
412
0
  oldinputTab = ctxt->inputTab;
413
0
  oldcharset = ctxt->charset;
414
0
  oldencoding = ctxt->encoding;
415
0
        oldprogressive = ctxt->progressive;
416
0
  ctxt->encoding = NULL;
417
0
        ctxt->progressive = 0;
418
419
0
  ctxt->inputTab = (xmlParserInputPtr *)
420
0
                   xmlMalloc(5 * sizeof(xmlParserInputPtr));
421
0
  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
0
  ctxt->inputNr = 0;
434
0
  ctxt->inputMax = 5;
435
0
  ctxt->input = NULL;
436
0
  xmlPushInput(ctxt, input);
437
438
  /*
439
   * On the fly encoding conversion if needed
440
   */
441
0
  if (ctxt->input->length >= 4) {
442
0
      enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
443
0
      xmlSwitchEncoding(ctxt, enc);
444
0
  }
445
446
0
  if (input->filename == NULL)
447
0
      input->filename = (char *) xmlCanonicPath(SystemID);
448
0
  input->line = 1;
449
0
  input->col = 1;
450
0
  input->base = ctxt->input->cur;
451
0
  input->cur = ctxt->input->cur;
452
0
  input->free = NULL;
453
454
  /*
455
   * let's parse that entity knowing it's an external subset.
456
   */
457
0
  xmlParseExternalSubset(ctxt, ExternalID, SystemID);
458
459
        /*
460
   * Free up the external entities
461
   */
462
463
0
  while (ctxt->inputNr > 1)
464
0
      xmlPopInput(ctxt);
465
466
0
        consumed = ctxt->input->consumed;
467
0
        buffered = ctxt->input->cur - ctxt->input->base;
468
0
        if (buffered > ULONG_MAX - consumed)
469
0
            consumed = ULONG_MAX;
470
0
        else
471
0
            consumed += buffered;
472
0
        if (consumed > ULONG_MAX - ctxt->sizeentities)
473
0
            ctxt->sizeentities = ULONG_MAX;
474
0
        else
475
0
            ctxt->sizeentities += consumed;
476
477
0
  xmlFreeInputStream(ctxt->input);
478
0
        xmlFree(ctxt->inputTab);
479
480
  /*
481
   * Restore the parsing context of the main entity
482
   */
483
0
  ctxt->input = oldinput;
484
0
  ctxt->inputNr = oldinputNr;
485
0
  ctxt->inputMax = oldinputMax;
486
0
  ctxt->inputTab = oldinputTab;
487
0
  ctxt->charset = oldcharset;
488
0
  if ((ctxt->encoding != NULL) &&
489
0
      ((ctxt->dict == NULL) ||
490
0
       (!xmlDictOwns(ctxt->dict, ctxt->encoding))))
491
0
      xmlFree((xmlChar *) ctxt->encoding);
492
0
  ctxt->encoding = oldencoding;
493
0
        ctxt->progressive = oldprogressive;
494
  /* ctxt->wellFormed = oldwellFormed; */
495
0
    }
496
0
}
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
0
{
515
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
516
0
    xmlParserInputPtr ret;
517
0
    xmlChar *URI;
518
0
    const char *base = NULL;
519
520
0
    if (ctx == NULL) return(NULL);
521
0
    if (ctxt->input != NULL)
522
0
  base = ctxt->input->filename;
523
0
    if (base == NULL)
524
0
  base = ctxt->directory;
525
526
0
    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
0
    ret = xmlLoadExternalEntity((const char *) URI,
534
0
        (const char *) publicId, ctxt);
535
0
    if (URI != NULL)
536
0
  xmlFree(URI);
537
0
    return(ret);
538
0
}
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
0
{
552
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
553
0
    xmlEntityPtr ret = NULL;
554
555
0
    if (ctx == NULL) return(NULL);
556
#ifdef DEBUG_SAX
557
    xmlGenericError(xmlGenericErrorContext,
558
      "SAX.xmlSAX2GetEntity(%s)\n", name);
559
#endif
560
561
0
    if (ctxt->inSubset == 0) {
562
0
  ret = xmlGetPredefinedEntity(name);
563
0
  if (ret != NULL)
564
0
      return(ret);
565
0
    }
566
0
    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->standalone == 1)) {
567
0
  if (ctxt->inSubset == 2) {
568
0
      ctxt->myDoc->standalone = 0;
569
0
      ret = xmlGetDocEntity(ctxt->myDoc, name);
570
0
      ctxt->myDoc->standalone = 1;
571
0
  } else {
572
0
      ret = xmlGetDocEntity(ctxt->myDoc, name);
573
0
      if (ret == NULL) {
574
0
    ctxt->myDoc->standalone = 0;
575
0
    ret = xmlGetDocEntity(ctxt->myDoc, name);
576
0
    if (ret != NULL) {
577
0
        xmlFatalErrMsg(ctxt, XML_ERR_NOT_STANDALONE,
578
0
   "Entity(%s) document marked standalone but requires external subset\n",
579
0
           name, NULL);
580
0
    }
581
0
    ctxt->myDoc->standalone = 1;
582
0
      }
583
0
  }
584
0
    } else {
585
0
  ret = xmlGetDocEntity(ctxt->myDoc, name);
586
0
    }
587
0
    return(ret);
588
0
}
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
0
{
602
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
603
0
    xmlEntityPtr ret;
604
605
0
    if (ctx == NULL) return(NULL);
606
#ifdef DEBUG_SAX
607
    xmlGenericError(xmlGenericErrorContext,
608
      "SAX.xmlSAX2GetParameterEntity(%s)\n", name);
609
#endif
610
611
0
    ret = xmlGetParameterEntity(ctxt->myDoc, name);
612
0
    return(ret);
613
0
}
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
11.7k
{
631
11.7k
    xmlEntityPtr ent;
632
11.7k
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
633
634
11.7k
    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
11.7k
    if (ctxt->inSubset == 1) {
641
11.7k
  ent = xmlAddDocEntity(ctxt->myDoc, name, type, publicId,
642
11.7k
                  systemId, content);
643
11.7k
  if ((ent == NULL) && (ctxt->pedantic))
644
0
      xmlWarnMsg(ctxt, XML_WAR_ENTITY_REDEFINED,
645
0
       "Entity(%s) already defined in the internal subset\n",
646
0
                 name);
647
11.7k
  if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
648
0
      xmlChar *URI;
649
0
      const char *base = NULL;
650
651
0
      if (ctxt->input != NULL)
652
0
    base = ctxt->input->filename;
653
0
      if (base == NULL)
654
0
    base = ctxt->directory;
655
656
0
      URI = xmlBuildURI(systemId, (const xmlChar *) base);
657
0
      ent->URI = URI;
658
0
  }
659
11.7k
    } else if (ctxt->inSubset == 2) {
660
0
  ent = xmlAddDtdEntity(ctxt->myDoc, name, type, publicId,
661
0
                  systemId, content);
662
0
  if ((ent == NULL) && (ctxt->pedantic) &&
663
0
      (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
664
0
      ctxt->sax->warning(ctxt->userData,
665
0
       "Entity(%s) already defined in the external subset\n", name);
666
0
  if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
667
0
      xmlChar *URI;
668
0
      const char *base = NULL;
669
670
0
      if (ctxt->input != NULL)
671
0
    base = ctxt->input->filename;
672
0
      if (base == NULL)
673
0
    base = ctxt->directory;
674
675
0
      URI = xmlBuildURI(systemId, (const xmlChar *) base);
676
0
      ent->URI = URI;
677
0
  }
678
0
    } 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
11.7k
}
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
0
{
702
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
703
0
    xmlAttributePtr attr;
704
0
    xmlChar *name = NULL, *prefix = NULL;
705
706
    /* Avoid unused variable warning if features are disabled. */
707
0
    (void) attr;
708
709
0
    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
0
    if ((xmlStrEqual(fullname, BAD_CAST "xml:id")) &&
718
0
        (type != XML_ATTRIBUTE_ID)) {
719
  /*
720
   * Raise the error but keep the validity flag
721
   */
722
0
  int tmp = ctxt->valid;
723
0
  xmlErrValid(ctxt, XML_DTD_XMLID_TYPE,
724
0
        "xml:id : attribute type should be ID\n", NULL, NULL);
725
0
  ctxt->valid = tmp;
726
0
    }
727
    /* TODO: optimize name/prefix allocation */
728
0
    name = xmlSplitQName(ctxt, fullname, &prefix);
729
0
    ctxt->vctxt.valid = 1;
730
0
    if (ctxt->inSubset == 1)
731
0
  attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, elem,
732
0
         name, prefix, (xmlAttributeType) type,
733
0
         (xmlAttributeDefault) def, defaultValue, tree);
734
0
    else if (ctxt->inSubset == 2)
735
0
  attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, elem,
736
0
     name, prefix, (xmlAttributeType) type,
737
0
     (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
0
#ifdef LIBXML_VALID_ENABLED
747
0
    if (ctxt->vctxt.valid == 0)
748
0
  ctxt->valid = 0;
749
0
    if ((attr != NULL) && (ctxt->validate) && (ctxt->wellFormed) &&
750
0
        (ctxt->myDoc->intSubset != NULL))
751
0
  ctxt->valid &= xmlValidateAttributeDecl(&ctxt->vctxt, ctxt->myDoc,
752
0
                                          attr);
753
0
#endif /* LIBXML_VALID_ENABLED */
754
0
    if (prefix != NULL)
755
0
  xmlFree(prefix);
756
0
    if (name != NULL)
757
0
  xmlFree(name);
758
0
}
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
0
{
773
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
774
0
    xmlElementPtr elem = NULL;
775
776
    /* Avoid unused variable warning if features are disabled. */
777
0
    (void) elem;
778
779
0
    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
0
    if (ctxt->inSubset == 1)
788
0
        elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->intSubset,
789
0
                                 name, (xmlElementTypeVal) type, content);
790
0
    else if (ctxt->inSubset == 2)
791
0
        elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->extSubset,
792
0
                                 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
0
#ifdef LIBXML_VALID_ENABLED
800
0
    if (elem == NULL)
801
0
        ctxt->valid = 0;
802
0
    if (ctxt->validate && ctxt->wellFormed &&
803
0
        ctxt->myDoc && ctxt->myDoc->intSubset)
804
0
        ctxt->valid &=
805
0
            xmlValidateElementDecl(&ctxt->vctxt, ctxt->myDoc, elem);
806
0
#endif /* LIBXML_VALID_ENABLED */
807
0
}
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
0
{
822
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
823
0
    xmlNotationPtr nota = NULL;
824
825
    /* Avoid unused variable warning if features are disabled. */
826
0
    (void) nota;
827
828
0
    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
0
    if ((publicId == NULL) && (systemId == NULL)) {
837
0
  xmlFatalErrMsg(ctxt, XML_ERR_NOTATION_PROCESSING,
838
0
       "SAX.xmlSAX2NotationDecl(%s) externalID or PublicID missing\n",
839
0
                 name, NULL);
840
0
  return;
841
0
    } else if (ctxt->inSubset == 1)
842
0
  nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, name,
843
0
                              publicId, systemId);
844
0
    else if (ctxt->inSubset == 2)
845
0
  nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, name,
846
0
                              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
0
#ifdef LIBXML_VALID_ENABLED
854
0
    if (nota == NULL) ctxt->valid = 0;
855
0
    if ((ctxt->validate) && (ctxt->wellFormed) &&
856
0
        (ctxt->myDoc->intSubset != NULL))
857
0
  ctxt->valid &= xmlValidateNotationDecl(&ctxt->vctxt, ctxt->myDoc,
858
0
                                         nota);
859
0
#endif /* LIBXML_VALID_ENABLED */
860
0
}
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
0
{
877
0
    xmlEntityPtr ent;
878
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
879
0
    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
0
    if (ctxt->inSubset == 1) {
886
0
  ent = xmlAddDocEntity(ctxt->myDoc, name,
887
0
      XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
888
0
      publicId, systemId, notationName);
889
0
  if ((ent == NULL) && (ctxt->pedantic) &&
890
0
      (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
891
0
      ctxt->sax->warning(ctxt->userData,
892
0
       "Entity(%s) already defined in the internal subset\n", name);
893
0
  if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
894
0
      xmlChar *URI;
895
0
      const char *base = NULL;
896
897
0
      if (ctxt->input != NULL)
898
0
    base = ctxt->input->filename;
899
0
      if (base == NULL)
900
0
    base = ctxt->directory;
901
902
0
      URI = xmlBuildURI(systemId, (const xmlChar *) base);
903
0
      ent->URI = URI;
904
0
  }
905
0
    } else if (ctxt->inSubset == 2) {
906
0
  ent = xmlAddDtdEntity(ctxt->myDoc, name,
907
0
      XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
908
0
      publicId, systemId, notationName);
909
0
  if ((ent == NULL) && (ctxt->pedantic) &&
910
0
      (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
911
0
      ctxt->sax->warning(ctxt->userData,
912
0
       "Entity(%s) already defined in the external subset\n", name);
913
0
  if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
914
0
      xmlChar *URI;
915
0
      const char *base = NULL;
916
917
0
      if (ctxt->input != NULL)
918
0
    base = ctxt->input->filename;
919
0
      if (base == NULL)
920
0
    base = ctxt->directory;
921
922
0
      URI = xmlBuildURI(systemId, (const xmlChar *) base);
923
0
      ent->URI = URI;
924
0
  }
925
0
    } 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
0
}
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
0
{
943
    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
944
#ifdef DEBUG_SAX
945
    xmlGenericError(xmlGenericErrorContext,
946
      "SAX.xmlSAX2SetDocumentLocator()\n");
947
#endif
948
0
}
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
0
{
959
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
960
0
    xmlDocPtr doc;
961
962
0
    if (ctx == NULL) return;
963
964
#ifdef DEBUG_SAX
965
    xmlGenericError(xmlGenericErrorContext,
966
      "SAX.xmlSAX2StartDocument()\n");
967
#endif
968
0
    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
0
    } else {
987
0
  doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
988
0
  if (doc != NULL) {
989
0
      doc->properties = 0;
990
0
      if (ctxt->options & XML_PARSE_OLD10)
991
0
          doc->properties |= XML_DOC_OLD10;
992
0
      doc->parseFlags = ctxt->options;
993
0
      if (ctxt->encoding != NULL)
994
0
    doc->encoding = xmlStrdup(ctxt->encoding);
995
0
      else
996
0
    doc->encoding = NULL;
997
0
      doc->standalone = ctxt->standalone;
998
0
  } else {
999
0
      xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
1000
0
      return;
1001
0
  }
1002
0
  if ((ctxt->dictNames) && (doc != NULL)) {
1003
0
      doc->dict = ctxt->dict;
1004
0
      xmlDictReference(doc->dict);
1005
0
  }
1006
0
    }
1007
0
    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->URL == NULL) &&
1008
0
  (ctxt->input != NULL) && (ctxt->input->filename != NULL)) {
1009
0
  ctxt->myDoc->URL = xmlPathToURI((const xmlChar *)ctxt->input->filename);
1010
0
  if (ctxt->myDoc->URL == NULL)
1011
0
      xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
1012
0
    }
1013
0
}
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
0
{
1024
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1025
#ifdef DEBUG_SAX
1026
    xmlGenericError(xmlGenericErrorContext,
1027
      "SAX.xmlSAX2EndDocument()\n");
1028
#endif
1029
0
    if (ctx == NULL) return;
1030
0
#ifdef LIBXML_VALID_ENABLED
1031
0
    if (ctxt->validate && ctxt->wellFormed &&
1032
0
        ctxt->myDoc && ctxt->myDoc->intSubset)
1033
0
  ctxt->valid &= xmlValidateDocumentFinal(&ctxt->vctxt, ctxt->myDoc);
1034
0
#endif /* LIBXML_VALID_ENABLED */
1035
1036
    /*
1037
     * Grab the encoding if it was added on-the-fly
1038
     */
1039
0
    if ((ctxt->encoding != NULL) && (ctxt->myDoc != NULL) &&
1040
0
  (ctxt->myDoc->encoding == NULL)) {
1041
0
  ctxt->myDoc->encoding = ctxt->encoding;
1042
0
  ctxt->encoding = NULL;
1043
0
    }
1044
0
    if ((ctxt->inputTab != NULL) &&
1045
0
        (ctxt->inputNr > 0) && (ctxt->inputTab[0] != NULL) &&
1046
0
        (ctxt->inputTab[0]->encoding != NULL) && (ctxt->myDoc != NULL) &&
1047
0
  (ctxt->myDoc->encoding == NULL)) {
1048
0
  ctxt->myDoc->encoding = xmlStrdup(ctxt->inputTab[0]->encoding);
1049
0
    }
1050
0
    if ((ctxt->charset != XML_CHAR_ENCODING_NONE) && (ctxt->myDoc != NULL) &&
1051
0
  (ctxt->myDoc->charset == XML_CHAR_ENCODING_NONE)) {
1052
0
  ctxt->myDoc->charset = ctxt->charset;
1053
0
    }
1054
0
}
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
0
{
1071
0
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
1072
0
        (ctxt->instate == XML_PARSER_EOF))
1073
0
  return;
1074
0
    if (ctxt != NULL)
1075
0
  ctxt->errNo = error;
1076
0
    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
1077
0
                    XML_ERR_ERROR, NULL, 0,
1078
0
        (const char *) str1, (const char *) str2,
1079
0
        NULL, 0, 0, msg, str1, str2);
1080
0
}
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
0
{
1098
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1099
0
    xmlAttrPtr ret;
1100
0
    xmlChar *name;
1101
0
    xmlChar *ns;
1102
0
    xmlChar *nval;
1103
0
    xmlNsPtr namespace;
1104
1105
0
    if (ctxt->html) {
1106
0
  name = xmlStrdup(fullname);
1107
0
  ns = NULL;
1108
0
  namespace = NULL;
1109
0
    } else {
1110
  /*
1111
   * Split the full name into a namespace prefix and the tag name
1112
   */
1113
0
  name = xmlSplitQName(ctxt, fullname, &ns);
1114
0
  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
0
    }
1131
0
    if (name == NULL) {
1132
0
        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1133
0
  if (ns != NULL)
1134
0
      xmlFree(ns);
1135
0
  return;
1136
0
    }
1137
1138
0
#ifdef LIBXML_HTML_ENABLED
1139
0
    if ((ctxt->html) &&
1140
0
        (value == NULL) && (htmlIsBooleanAttr(fullname))) {
1141
0
            nval = xmlStrdup(fullname);
1142
0
            value = (const xmlChar *) nval;
1143
0
    } else
1144
0
#endif
1145
0
    {
1146
0
#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
0
        ctxt->vctxt.valid = 1;
1153
0
        nval = xmlValidCtxtNormalizeAttributeValue(&ctxt->vctxt,
1154
0
                                               ctxt->myDoc, ctxt->node,
1155
0
                                               fullname, value);
1156
0
        if (ctxt->vctxt.valid != 1) {
1157
0
            ctxt->valid = 0;
1158
0
        }
1159
0
        if (nval != NULL)
1160
0
            value = nval;
1161
#else
1162
        nval = NULL;
1163
#endif /* LIBXML_VALID_ENABLED */
1164
0
    }
1165
1166
    /*
1167
     * Check whether it's a namespace definition
1168
     */
1169
0
    if ((!ctxt->html) && (ns == NULL) &&
1170
0
        (name[0] == 'x') && (name[1] == 'm') && (name[2] == 'l') &&
1171
0
        (name[3] == 'n') && (name[4] == 's') && (name[5] == 0)) {
1172
0
  xmlNsPtr nsret;
1173
0
  xmlChar *val;
1174
1175
        /* Avoid unused variable warning if features are disabled. */
1176
0
        (void) nsret;
1177
1178
0
        if (!ctxt->replaceEntities) {
1179
0
      ctxt->depth++;
1180
0
      val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
1181
0
                              0,0,0);
1182
0
      ctxt->depth--;
1183
0
      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
0
  } else {
1192
0
      val = (xmlChar *) value;
1193
0
  }
1194
1195
0
  if (val[0] != 0) {
1196
0
      xmlURIPtr uri;
1197
1198
0
      uri = xmlParseURI((const char *)val);
1199
0
      if (uri == NULL) {
1200
0
    if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
1201
0
        ctxt->sax->warning(ctxt->userData,
1202
0
       "xmlns: %s not a valid URI\n", val);
1203
0
      } else {
1204
0
    if (uri->scheme == NULL) {
1205
0
        if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
1206
0
      ctxt->sax->warning(ctxt->userData,
1207
0
           "xmlns: URI %s is not absolute\n", val);
1208
0
    }
1209
0
    xmlFreeURI(uri);
1210
0
      }
1211
0
  }
1212
1213
  /* a default namespace definition */
1214
0
  nsret = xmlNewNs(ctxt->node, val, NULL);
1215
1216
0
#ifdef LIBXML_VALID_ENABLED
1217
  /*
1218
   * Validate also for namespace decls, they are attributes from
1219
   * an XML-1.0 perspective
1220
   */
1221
0
        if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
1222
0
      ctxt->myDoc && ctxt->myDoc->intSubset)
1223
0
      ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
1224
0
             ctxt->node, prefix, nsret, val);
1225
0
#endif /* LIBXML_VALID_ENABLED */
1226
0
  if (name != NULL)
1227
0
      xmlFree(name);
1228
0
  if (nval != NULL)
1229
0
      xmlFree(nval);
1230
0
  if (val != value)
1231
0
      xmlFree(val);
1232
0
  return;
1233
0
    }
1234
0
    if ((!ctxt->html) &&
1235
0
  (ns != NULL) && (ns[0] == 'x') && (ns[1] == 'm') && (ns[2] == 'l') &&
1236
0
        (ns[3] == 'n') && (ns[4] == 's') && (ns[5] == 0)) {
1237
0
  xmlNsPtr nsret;
1238
0
  xmlChar *val;
1239
1240
        /* Avoid unused variable warning if features are disabled. */
1241
0
        (void) nsret;
1242
1243
0
        if (!ctxt->replaceEntities) {
1244
0
      ctxt->depth++;
1245
0
      val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
1246
0
                              0,0,0);
1247
0
      ctxt->depth--;
1248
0
      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
0
  } else {
1258
0
      val = (xmlChar *) value;
1259
0
  }
1260
1261
0
  if (val[0] == 0) {
1262
0
      xmlNsErrMsg(ctxt, XML_NS_ERR_EMPTY,
1263
0
            "Empty namespace name for prefix %s\n", name, NULL);
1264
0
  }
1265
0
  if ((ctxt->pedantic != 0) && (val[0] != 0)) {
1266
0
      xmlURIPtr uri;
1267
1268
0
      uri = xmlParseURI((const char *)val);
1269
0
      if (uri == NULL) {
1270
0
          xmlNsWarnMsg(ctxt, XML_WAR_NS_URI,
1271
0
       "xmlns:%s: %s not a valid URI\n", name, value);
1272
0
      } else {
1273
0
    if (uri->scheme == NULL) {
1274
0
        xmlNsWarnMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
1275
0
         "xmlns:%s: URI %s is not absolute\n", name, value);
1276
0
    }
1277
0
    xmlFreeURI(uri);
1278
0
      }
1279
0
  }
1280
1281
  /* a standard namespace definition */
1282
0
  nsret = xmlNewNs(ctxt->node, val, name);
1283
0
  xmlFree(ns);
1284
0
#ifdef LIBXML_VALID_ENABLED
1285
  /*
1286
   * Validate also for namespace decls, they are attributes from
1287
   * an XML-1.0 perspective
1288
   */
1289
0
        if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
1290
0
      ctxt->myDoc && ctxt->myDoc->intSubset)
1291
0
      ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
1292
0
             ctxt->node, prefix, nsret, value);
1293
0
#endif /* LIBXML_VALID_ENABLED */
1294
0
  if (name != NULL)
1295
0
      xmlFree(name);
1296
0
  if (nval != NULL)
1297
0
      xmlFree(nval);
1298
0
  if (val != value)
1299
0
      xmlFree(val);
1300
0
  return;
1301
0
    }
1302
1303
0
    if (ns != NULL) {
1304
0
  namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, ns);
1305
1306
0
  if (namespace == NULL) {
1307
0
      xmlNsErrMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
1308
0
        "Namespace prefix %s of attribute %s is not defined\n",
1309
0
                 ns, name);
1310
0
  } else {
1311
0
            xmlAttrPtr prop;
1312
1313
0
            prop = ctxt->node->properties;
1314
0
            while (prop != NULL) {
1315
0
                if (prop->ns != NULL) {
1316
0
                    if ((xmlStrEqual(name, prop->name)) &&
1317
0
                        ((namespace == prop->ns) ||
1318
0
                         (xmlStrEqual(namespace->href, prop->ns->href)))) {
1319
0
                            xmlNsErrMsg(ctxt, XML_ERR_ATTRIBUTE_REDEFINED,
1320
0
                                    "Attribute %s in %s redefined\n",
1321
0
                                             name, namespace->href);
1322
0
                        ctxt->wellFormed = 0;
1323
0
                        if (ctxt->recovery == 0) ctxt->disableSAX = 1;
1324
0
                        if (name != NULL)
1325
0
                            xmlFree(name);
1326
0
                        goto error;
1327
0
                    }
1328
0
                }
1329
0
                prop = prop->next;
1330
0
            }
1331
0
        }
1332
0
    } else {
1333
0
  namespace = NULL;
1334
0
    }
1335
1336
    /* !!!!!! <a toto:arg="" xmlns:toto="http://toto.com"> */
1337
0
    ret = xmlNewNsPropEatName(ctxt->node, namespace, name, NULL);
1338
0
    if (ret == NULL)
1339
0
        goto error;
1340
1341
0
    if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
1342
0
        xmlNodePtr tmp;
1343
1344
0
        ret->children = xmlStringGetNodeList(ctxt->myDoc, value);
1345
0
        tmp = ret->children;
1346
0
        while (tmp != NULL) {
1347
0
            tmp->parent = (xmlNodePtr) ret;
1348
0
            if (tmp->next == NULL)
1349
0
                ret->last = tmp;
1350
0
            tmp = tmp->next;
1351
0
        }
1352
0
    } else if (value != NULL) {
1353
0
        ret->children = xmlNewDocText(ctxt->myDoc, value);
1354
0
        ret->last = ret->children;
1355
0
        if (ret->children != NULL)
1356
0
            ret->children->parent = (xmlNodePtr) ret;
1357
0
    }
1358
1359
0
#ifdef LIBXML_VALID_ENABLED
1360
0
    if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
1361
0
        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
0
        if (!ctxt->replaceEntities) {
1368
0
      xmlChar *val;
1369
1370
0
      ctxt->depth++;
1371
0
      val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
1372
0
                              0,0,0);
1373
0
      ctxt->depth--;
1374
1375
0
      if (val == NULL)
1376
0
    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
1377
0
        ctxt->myDoc, ctxt->node, ret, value);
1378
0
      else {
1379
0
    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
0
    nvalnorm = xmlValidNormalizeAttributeValue(ctxt->myDoc,
1387
0
              ctxt->node, fullname, val);
1388
0
    if (nvalnorm != NULL) {
1389
0
        xmlFree(val);
1390
0
        val = nvalnorm;
1391
0
    }
1392
1393
0
    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
1394
0
              ctxt->myDoc, ctxt->node, ret, val);
1395
0
                xmlFree(val);
1396
0
      }
1397
0
  } else {
1398
0
      ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc,
1399
0
                 ctxt->node, ret, value);
1400
0
  }
1401
0
    } else
1402
0
#endif /* LIBXML_VALID_ENABLED */
1403
0
           if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
1404
0
         (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
1405
0
          ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0))) &&
1406
               /* Don't create IDs containing entity references */
1407
0
               (ret->children != NULL) &&
1408
0
               (ret->children->type == XML_TEXT_NODE) &&
1409
0
               (ret->children->next == NULL)) {
1410
0
        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
0
  if (xmlStrEqual(fullname, BAD_CAST "xml:id")) {
1416
      /*
1417
       * Add the xml:id value
1418
       *
1419
       * Open issue: normalization of the value.
1420
       */
1421
0
      if (xmlValidateNCName(content, 1) != 0) {
1422
0
          xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
1423
0
          "xml:id : attribute value %s is not an NCName\n",
1424
0
          (const char *) content, NULL);
1425
0
      }
1426
0
      xmlAddID(&ctxt->vctxt, ctxt->myDoc, content, ret);
1427
0
  } else if (xmlIsID(ctxt->myDoc, ctxt->node, ret))
1428
0
      xmlAddID(&ctxt->vctxt, ctxt->myDoc, content, ret);
1429
0
  else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret))
1430
0
      xmlAddRef(&ctxt->vctxt, ctxt->myDoc, content, ret);
1431
0
    }
1432
1433
0
error:
1434
0
    if (nval != NULL)
1435
0
  xmlFree(nval);
1436
0
    if (ns != NULL)
1437
0
  xmlFree(ns);
1438
0
}
1439
1440
/*
1441
 * xmlCheckDefaultedAttributes:
1442
 *
1443
 * Check defaulted attributes from the DTD
1444
 */
1445
static void
1446
xmlCheckDefaultedAttributes(xmlParserCtxtPtr ctxt, const xmlChar *name,
1447
0
  const xmlChar *prefix, const xmlChar **atts) {
1448
0
    xmlElementPtr elemDecl;
1449
0
    const xmlChar *att;
1450
0
    int internal = 1;
1451
0
    int i;
1452
1453
0
    elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->intSubset, name, prefix);
1454
0
    if (elemDecl == NULL) {
1455
0
  elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset, name, prefix);
1456
0
  internal = 0;
1457
0
    }
1458
1459
0
process_external_subset:
1460
1461
0
    if (elemDecl != NULL) {
1462
0
  xmlAttributePtr attr = elemDecl->attributes;
1463
  /*
1464
   * Check against defaulted attributes from the external subset
1465
   * if the document is stamped as standalone
1466
   */
1467
0
  if ((ctxt->myDoc->standalone == 1) &&
1468
0
      (ctxt->myDoc->extSubset != NULL) &&
1469
0
      (ctxt->validate)) {
1470
0
      while (attr != NULL) {
1471
0
    if ((attr->defaultValue != NULL) &&
1472
0
        (xmlGetDtdQAttrDesc(ctxt->myDoc->extSubset,
1473
0
          attr->elem, attr->name,
1474
0
          attr->prefix) == attr) &&
1475
0
        (xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
1476
0
          attr->elem, attr->name,
1477
0
          attr->prefix) == NULL)) {
1478
0
        xmlChar *fulln;
1479
1480
0
        if (attr->prefix != NULL) {
1481
0
      fulln = xmlStrdup(attr->prefix);
1482
0
      fulln = xmlStrcat(fulln, BAD_CAST ":");
1483
0
      fulln = xmlStrcat(fulln, attr->name);
1484
0
        } else {
1485
0
      fulln = xmlStrdup(attr->name);
1486
0
        }
1487
0
                    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
0
        att = NULL;
1497
0
        if (atts != NULL) {
1498
0
      i = 0;
1499
0
      att = atts[i];
1500
0
      while (att != NULL) {
1501
0
          if (xmlStrEqual(att, fulln))
1502
0
        break;
1503
0
          i += 2;
1504
0
          att = atts[i];
1505
0
      }
1506
0
        }
1507
0
        if (att == NULL) {
1508
0
            xmlErrValid(ctxt, XML_DTD_STANDALONE_DEFAULTED,
1509
0
      "standalone: attribute %s on %s defaulted from external subset\n",
1510
0
            (const char *)fulln,
1511
0
            (const char *)attr->elem);
1512
0
        }
1513
0
                    xmlFree(fulln);
1514
0
    }
1515
0
    attr = attr->nexth;
1516
0
      }
1517
0
  }
1518
1519
  /*
1520
   * Actually insert defaulted values when needed
1521
   */
1522
0
  attr = elemDecl->attributes;
1523
0
  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
0
      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
0
    if (((attr->prefix != NULL) &&
1539
0
         (xmlStrEqual(attr->prefix, BAD_CAST "xmlns"))) ||
1540
0
        ((attr->prefix == NULL) &&
1541
0
         (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) ||
1542
0
        (ctxt->loadsubset & XML_COMPLETE_ATTRS)) {
1543
0
        xmlAttributePtr tst;
1544
1545
0
        tst = xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
1546
0
               attr->elem, attr->name,
1547
0
               attr->prefix);
1548
0
        if ((tst == attr) || (tst == NULL)) {
1549
0
            xmlChar fn[50];
1550
0
      xmlChar *fulln;
1551
1552
0
                        fulln = xmlBuildQName(attr->name, attr->prefix, fn, 50);
1553
0
      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
0
      att = NULL;
1563
0
      if (atts != NULL) {
1564
0
          i = 0;
1565
0
          att = atts[i];
1566
0
          while (att != NULL) {
1567
0
        if (xmlStrEqual(att, fulln))
1568
0
            break;
1569
0
        i += 2;
1570
0
        att = atts[i];
1571
0
          }
1572
0
      }
1573
0
      if (att == NULL) {
1574
0
          xmlSAX2AttributeInternal(ctxt, fulln,
1575
0
             attr->defaultValue, prefix);
1576
0
      }
1577
0
      if ((fulln != fn) && (fulln != attr->name))
1578
0
          xmlFree(fulln);
1579
0
        }
1580
0
    }
1581
0
      }
1582
0
      attr = attr->nexth;
1583
0
  }
1584
0
  if (internal == 1) {
1585
0
      elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset,
1586
0
                                 name, prefix);
1587
0
      internal = 0;
1588
0
      goto process_external_subset;
1589
0
  }
1590
0
    }
1591
0
}
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
0
{
1604
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1605
0
    xmlNodePtr ret;
1606
0
    xmlNodePtr parent;
1607
0
    xmlNsPtr ns;
1608
0
    xmlChar *name;
1609
0
    xmlChar *prefix;
1610
0
    const xmlChar *att;
1611
0
    const xmlChar *value;
1612
0
    int i;
1613
1614
0
    if ((ctx == NULL) || (fullname == NULL) || (ctxt->myDoc == NULL)) return;
1615
0
    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
0
    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
1625
0
        ((ctxt->myDoc->intSubset == NULL) ||
1626
0
   ((ctxt->myDoc->intSubset->notations == NULL) &&
1627
0
    (ctxt->myDoc->intSubset->elements == NULL) &&
1628
0
    (ctxt->myDoc->intSubset->attributes == NULL) &&
1629
0
    (ctxt->myDoc->intSubset->entities == NULL)))) {
1630
0
  xmlErrValid(ctxt, XML_ERR_NO_DTD,
1631
0
    "Validation failed: no DTD found !", NULL, NULL);
1632
0
  ctxt->validate = 0;
1633
0
    }
1634
1635
0
    if (ctxt->html) {
1636
0
        prefix = NULL;
1637
0
        name = xmlStrdup(fullname);
1638
0
    } else {
1639
        /*
1640
         * Split the full name into a namespace prefix and the tag name
1641
         */
1642
0
        name = xmlSplitQName(ctxt, fullname, &prefix);
1643
0
    }
1644
1645
    /*
1646
     * Note : the namespace resolution is deferred until the end of the
1647
     *        attributes parsing, since local namespace can be defined as
1648
     *        an attribute at this level.
1649
     */
1650
0
    ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL, name, NULL);
1651
0
    if (ret == NULL) {
1652
0
        if (prefix != NULL)
1653
0
      xmlFree(prefix);
1654
0
  xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1655
0
        return;
1656
0
    }
1657
0
    if (ctxt->myDoc->children == NULL) {
1658
#ifdef DEBUG_SAX_TREE
1659
  xmlGenericError(xmlGenericErrorContext, "Setting %s as root\n", name);
1660
#endif
1661
0
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
1662
0
    } else if (parent == NULL) {
1663
0
        parent = ctxt->myDoc->children;
1664
0
    }
1665
0
    ctxt->nodemem = -1;
1666
0
    if (ctxt->linenumbers) {
1667
0
  if (ctxt->input != NULL) {
1668
0
      if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
1669
0
    ret->line = ctxt->input->line;
1670
0
      else
1671
0
          ret->line = USHRT_MAX;
1672
0
  }
1673
0
    }
1674
1675
    /*
1676
     * We are parsing a new node.
1677
     */
1678
#ifdef DEBUG_SAX_TREE
1679
    xmlGenericError(xmlGenericErrorContext, "pushing(%s)\n", name);
1680
#endif
1681
0
    if (nodePush(ctxt, ret) < 0) {
1682
0
        xmlUnlinkNode(ret);
1683
0
        xmlFreeNode(ret);
1684
0
        if (prefix != NULL)
1685
0
            xmlFree(prefix);
1686
0
        return;
1687
0
    }
1688
1689
    /*
1690
     * Link the child element
1691
     */
1692
0
    if (parent != NULL) {
1693
0
        if (parent->type == XML_ELEMENT_NODE) {
1694
#ifdef DEBUG_SAX_TREE
1695
      xmlGenericError(xmlGenericErrorContext,
1696
        "adding child %s to %s\n", name, parent->name);
1697
#endif
1698
0
      xmlAddChild(parent, ret);
1699
0
  } else {
1700
#ifdef DEBUG_SAX_TREE
1701
      xmlGenericError(xmlGenericErrorContext,
1702
        "adding sibling %s to ", name);
1703
      xmlDebugDumpOneNode(stderr, parent, 0);
1704
#endif
1705
0
      xmlAddSibling(parent, ret);
1706
0
  }
1707
0
    }
1708
1709
0
    if (!ctxt->html) {
1710
        /*
1711
         * Insert all the defaulted attributes from the DTD especially
1712
         * namespaces
1713
         */
1714
0
        if ((ctxt->myDoc->intSubset != NULL) ||
1715
0
            (ctxt->myDoc->extSubset != NULL)) {
1716
0
            xmlCheckDefaultedAttributes(ctxt, name, prefix, atts);
1717
0
        }
1718
1719
        /*
1720
         * process all the attributes whose name start with "xmlns"
1721
         */
1722
0
        if (atts != NULL) {
1723
0
            i = 0;
1724
0
            att = atts[i++];
1725
0
            value = atts[i++];
1726
0
      while ((att != NULL) && (value != NULL)) {
1727
0
    if ((att[0] == 'x') && (att[1] == 'm') && (att[2] == 'l') &&
1728
0
        (att[3] == 'n') && (att[4] == 's'))
1729
0
        xmlSAX2AttributeInternal(ctxt, att, value, prefix);
1730
1731
0
    att = atts[i++];
1732
0
    value = atts[i++];
1733
0
      }
1734
0
        }
1735
1736
        /*
1737
         * Search the namespace, note that since the attributes have been
1738
         * processed, the local namespaces are available.
1739
         */
1740
0
        ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
1741
0
        if ((ns == NULL) && (parent != NULL))
1742
0
            ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
1743
0
        if ((prefix != NULL) && (ns == NULL)) {
1744
0
            ns = xmlNewNs(ret, NULL, prefix);
1745
0
            xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
1746
0
                         "Namespace prefix %s is not defined\n",
1747
0
                         prefix, NULL);
1748
0
        }
1749
1750
        /*
1751
         * set the namespace node, making sure that if the default namespace
1752
         * is unbound on a parent we simply keep it NULL
1753
         */
1754
0
        if ((ns != NULL) && (ns->href != NULL) &&
1755
0
            ((ns->href[0] != 0) || (ns->prefix != NULL)))
1756
0
            xmlSetNs(ret, ns);
1757
0
    }
1758
1759
    /*
1760
     * process all the other attributes
1761
     */
1762
0
    if (atts != NULL) {
1763
0
        i = 0;
1764
0
  att = atts[i++];
1765
0
  value = atts[i++];
1766
0
  if (ctxt->html) {
1767
0
      while (att != NULL) {
1768
0
    xmlSAX2AttributeInternal(ctxt, att, value, NULL);
1769
0
    att = atts[i++];
1770
0
    value = atts[i++];
1771
0
      }
1772
0
  } else {
1773
0
      while ((att != NULL) && (value != NULL)) {
1774
0
    if ((att[0] != 'x') || (att[1] != 'm') || (att[2] != 'l') ||
1775
0
        (att[3] != 'n') || (att[4] != 's'))
1776
0
        xmlSAX2AttributeInternal(ctxt, att, value, NULL);
1777
1778
    /*
1779
     * Next ones
1780
     */
1781
0
    att = atts[i++];
1782
0
    value = atts[i++];
1783
0
      }
1784
0
  }
1785
0
    }
1786
1787
0
#ifdef LIBXML_VALID_ENABLED
1788
    /*
1789
     * If it's the Document root, finish the DTD validation and
1790
     * check the document root element for validity
1791
     */
1792
0
    if ((ctxt->validate) &&
1793
0
        ((ctxt->vctxt.flags & XML_VCTXT_DTD_VALIDATED) == 0)) {
1794
0
  int chk;
1795
1796
0
  chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
1797
0
  if (chk <= 0)
1798
0
      ctxt->valid = 0;
1799
0
  if (chk < 0)
1800
0
      ctxt->wellFormed = 0;
1801
0
  ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
1802
0
  ctxt->vctxt.flags |= XML_VCTXT_DTD_VALIDATED;
1803
0
    }
1804
0
#endif /* LIBXML_VALID_ENABLED */
1805
1806
0
    if (prefix != NULL)
1807
0
  xmlFree(prefix);
1808
1809
0
}
1810
1811
/**
1812
 * xmlSAX2EndElement:
1813
 * @ctx: the user data (XML parser context)
1814
 * @name:  The element name
1815
 *
1816
 * called when the end of an element has been detected.
1817
 */
1818
void
1819
xmlSAX2EndElement(void *ctx, const xmlChar *name ATTRIBUTE_UNUSED)
1820
0
{
1821
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1822
0
    xmlNodePtr cur;
1823
1824
0
    if (ctx == NULL) return;
1825
0
    cur = ctxt->node;
1826
#ifdef DEBUG_SAX
1827
    if (name == NULL)
1828
        xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(NULL)\n");
1829
    else
1830
  xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(%s)\n", name);
1831
#endif
1832
1833
0
    ctxt->nodemem = -1;
1834
1835
0
#ifdef LIBXML_VALID_ENABLED
1836
0
    if (ctxt->validate && ctxt->wellFormed &&
1837
0
        ctxt->myDoc && ctxt->myDoc->intSubset)
1838
0
        ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc,
1839
0
               cur);
1840
0
#endif /* LIBXML_VALID_ENABLED */
1841
1842
1843
    /*
1844
     * end of parsing of this node.
1845
     */
1846
#ifdef DEBUG_SAX_TREE
1847
    xmlGenericError(xmlGenericErrorContext, "popping(%s)\n", cur->name);
1848
#endif
1849
0
    nodePop(ctxt);
1850
0
}
1851
#endif /* LIBXML_SAX1_ENABLED || LIBXML_HTML_ENABLED || LIBXML_LEGACY_ENABLED */
1852
1853
/*
1854
 * xmlSAX2TextNode:
1855
 * @ctxt:  the parser context
1856
 * @str:  the input string
1857
 * @len: the string length
1858
 *
1859
 * Callback for a text node
1860
 *
1861
 * Returns the newly allocated string or NULL if not needed or error
1862
 */
1863
static xmlNodePtr
1864
0
xmlSAX2TextNode(xmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
1865
0
    xmlNodePtr ret;
1866
0
    const xmlChar *intern = NULL;
1867
1868
    /*
1869
     * Allocate
1870
     */
1871
0
    if (ctxt->freeElems != NULL) {
1872
0
  ret = ctxt->freeElems;
1873
0
  ctxt->freeElems = ret->next;
1874
0
  ctxt->freeElemsNr--;
1875
0
    } else {
1876
0
  ret = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
1877
0
    }
1878
0
    if (ret == NULL) {
1879
0
        xmlErrMemory(ctxt, "xmlSAX2Characters");
1880
0
  return(NULL);
1881
0
    }
1882
0
    memset(ret, 0, sizeof(xmlNode));
1883
    /*
1884
     * intern the formatting blanks found between tags, or the
1885
     * very short strings
1886
     */
1887
0
    if (ctxt->dictNames) {
1888
0
        xmlChar cur = str[len];
1889
1890
0
  if ((len < (int) (2 * sizeof(void *))) &&
1891
0
      (ctxt->options & XML_PARSE_COMPACT)) {
1892
      /* store the string in the node overriding properties and nsDef */
1893
0
      xmlChar *tmp = (xmlChar *) &(ret->properties);
1894
0
      memcpy(tmp, str, len);
1895
0
      tmp[len] = 0;
1896
0
      intern = tmp;
1897
0
  } else if ((len <= 3) && ((cur == '"') || (cur == '\'') ||
1898
0
      ((cur == '<') && (str[len + 1] != '!')))) {
1899
0
      intern = xmlDictLookup(ctxt->dict, str, len);
1900
0
  } else if (IS_BLANK_CH(*str) && (len < 60) && (cur == '<') &&
1901
0
             (str[len + 1] != '!')) {
1902
0
      int i;
1903
1904
0
      for (i = 1;i < len;i++) {
1905
0
    if (!IS_BLANK_CH(str[i])) goto skip;
1906
0
      }
1907
0
      intern = xmlDictLookup(ctxt->dict, str, len);
1908
0
  }
1909
0
    }
1910
0
skip:
1911
0
    ret->type = XML_TEXT_NODE;
1912
1913
0
    ret->name = xmlStringText;
1914
0
    if (intern == NULL) {
1915
0
  ret->content = xmlStrndup(str, len);
1916
0
  if (ret->content == NULL) {
1917
0
      xmlSAX2ErrMemory(ctxt, "xmlSAX2TextNode");
1918
0
      xmlFree(ret);
1919
0
      return(NULL);
1920
0
  }
1921
0
    } else
1922
0
  ret->content = (xmlChar *) intern;
1923
1924
0
    if (ctxt->linenumbers) {
1925
0
  if (ctxt->input != NULL) {
1926
0
      if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
1927
0
    ret->line = ctxt->input->line;
1928
0
      else {
1929
0
          ret->line = USHRT_MAX;
1930
0
    if (ctxt->options & XML_PARSE_BIG_LINES)
1931
0
        ret->psvi = (void *) (ptrdiff_t) ctxt->input->line;
1932
0
      }
1933
0
  }
1934
0
    }
1935
1936
0
    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
1937
0
  xmlRegisterNodeDefaultValue(ret);
1938
0
    return(ret);
1939
0
}
1940
1941
#ifdef LIBXML_VALID_ENABLED
1942
/*
1943
 * xmlSAX2DecodeAttrEntities:
1944
 * @ctxt:  the parser context
1945
 * @str:  the input string
1946
 * @len: the string length
1947
 *
1948
 * Remove the entities from an attribute value
1949
 *
1950
 * Returns the newly allocated string or NULL if not needed or error
1951
 */
1952
static xmlChar *
1953
xmlSAX2DecodeAttrEntities(xmlParserCtxtPtr ctxt, const xmlChar *str,
1954
0
                          const xmlChar *end) {
1955
0
    const xmlChar *in;
1956
0
    xmlChar *ret;
1957
1958
0
    in = str;
1959
0
    while (in < end)
1960
0
        if (*in++ == '&')
1961
0
      goto decode;
1962
0
    return(NULL);
1963
0
decode:
1964
0
    ctxt->depth++;
1965
0
    ret = xmlStringLenDecodeEntities(ctxt, str, end - str,
1966
0
             XML_SUBSTITUTE_REF, 0,0,0);
1967
0
    ctxt->depth--;
1968
0
    return(ret);
1969
0
}
1970
#endif /* LIBXML_VALID_ENABLED */
1971
1972
/**
1973
 * xmlSAX2AttributeNs:
1974
 * @ctx: the user data (XML parser context)
1975
 * @localname:  the local name of the attribute
1976
 * @prefix:  the attribute namespace prefix if available
1977
 * @URI:  the attribute namespace name if available
1978
 * @value:  Start of the attribute value
1979
 * @valueend: end of the attribute value
1980
 *
1981
 * Handle an attribute that has been read by the parser.
1982
 * The default handling is to convert the attribute into an
1983
 * DOM subtree and past it in a new xmlAttr element added to
1984
 * the element.
1985
 */
1986
static void
1987
xmlSAX2AttributeNs(xmlParserCtxtPtr ctxt,
1988
                   const xmlChar * localname,
1989
                   const xmlChar * prefix,
1990
       const xmlChar * value,
1991
       const xmlChar * valueend)
1992
0
{
1993
0
    xmlAttrPtr ret;
1994
0
    xmlNsPtr namespace = NULL;
1995
0
    xmlChar *dup = NULL;
1996
1997
    /*
1998
     * Note: if prefix == NULL, the attribute is not in the default namespace
1999
     */
2000
0
    if (prefix != NULL)
2001
0
  namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, prefix);
2002
2003
    /*
2004
     * allocate the node
2005
     */
2006
0
    if (ctxt->freeAttrs != NULL) {
2007
0
        ret = ctxt->freeAttrs;
2008
0
  ctxt->freeAttrs = ret->next;
2009
0
  ctxt->freeAttrsNr--;
2010
0
  memset(ret, 0, sizeof(xmlAttr));
2011
0
  ret->type = XML_ATTRIBUTE_NODE;
2012
2013
0
  ret->parent = ctxt->node;
2014
0
  ret->doc = ctxt->myDoc;
2015
0
  ret->ns = namespace;
2016
2017
0
  if (ctxt->dictNames)
2018
0
      ret->name = localname;
2019
0
  else
2020
0
      ret->name = xmlStrdup(localname);
2021
2022
        /* link at the end to preserve order, TODO speed up with a last */
2023
0
  if (ctxt->node->properties == NULL) {
2024
0
      ctxt->node->properties = ret;
2025
0
  } else {
2026
0
      xmlAttrPtr prev = ctxt->node->properties;
2027
2028
0
      while (prev->next != NULL) prev = prev->next;
2029
0
      prev->next = ret;
2030
0
      ret->prev = prev;
2031
0
  }
2032
2033
0
  if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
2034
0
      xmlRegisterNodeDefaultValue((xmlNodePtr)ret);
2035
0
    } else {
2036
0
  if (ctxt->dictNames)
2037
0
      ret = xmlNewNsPropEatName(ctxt->node, namespace,
2038
0
                                (xmlChar *) localname, NULL);
2039
0
  else
2040
0
      ret = xmlNewNsProp(ctxt->node, namespace, localname, NULL);
2041
0
  if (ret == NULL) {
2042
0
      xmlErrMemory(ctxt, "xmlSAX2AttributeNs");
2043
0
      return;
2044
0
  }
2045
0
    }
2046
2047
0
    if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
2048
0
  xmlNodePtr tmp;
2049
2050
  /*
2051
   * We know that if there is an entity reference, then
2052
   * the string has been dup'ed and terminates with 0
2053
   * otherwise with ' or "
2054
   */
2055
0
  if (*valueend != 0) {
2056
0
      tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
2057
0
      ret->children = tmp;
2058
0
      ret->last = tmp;
2059
0
      if (tmp != NULL) {
2060
0
    tmp->doc = ret->doc;
2061
0
    tmp->parent = (xmlNodePtr) ret;
2062
0
      }
2063
0
  } else {
2064
0
      ret->children = xmlStringLenGetNodeList(ctxt->myDoc, value,
2065
0
                valueend - value);
2066
0
      tmp = ret->children;
2067
0
      while (tmp != NULL) {
2068
0
          tmp->doc = ret->doc;
2069
0
    tmp->parent = (xmlNodePtr) ret;
2070
0
    if (tmp->next == NULL)
2071
0
        ret->last = tmp;
2072
0
    tmp = tmp->next;
2073
0
      }
2074
0
  }
2075
0
    } else if (value != NULL) {
2076
0
  xmlNodePtr tmp;
2077
2078
0
  tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
2079
0
  ret->children = tmp;
2080
0
  ret->last = tmp;
2081
0
  if (tmp != NULL) {
2082
0
      tmp->doc = ret->doc;
2083
0
      tmp->parent = (xmlNodePtr) ret;
2084
0
  }
2085
0
    }
2086
2087
0
#ifdef LIBXML_VALID_ENABLED
2088
0
    if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
2089
0
        ctxt->myDoc && ctxt->myDoc->intSubset) {
2090
  /*
2091
   * If we don't substitute entities, the validation should be
2092
   * done on a value with replaced entities anyway.
2093
   */
2094
0
        if (!ctxt->replaceEntities) {
2095
0
      dup = xmlSAX2DecodeAttrEntities(ctxt, value, valueend);
2096
0
      if (dup == NULL) {
2097
0
          if (*valueend == 0) {
2098
0
        ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2099
0
            ctxt->myDoc, ctxt->node, ret, value);
2100
0
    } else {
2101
        /*
2102
         * That should already be normalized.
2103
         * cheaper to finally allocate here than duplicate
2104
         * entry points in the full validation code
2105
         */
2106
0
        dup = xmlStrndup(value, valueend - value);
2107
2108
0
        ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2109
0
            ctxt->myDoc, ctxt->node, ret, dup);
2110
0
    }
2111
0
      } else {
2112
          /*
2113
     * dup now contains a string of the flattened attribute
2114
     * content with entities substituted. Check if we need to
2115
     * apply an extra layer of normalization.
2116
     * It need to be done twice ... it's an extra burden related
2117
     * to the ability to keep references in attributes
2118
     */
2119
0
    if (ctxt->attsSpecial != NULL) {
2120
0
        xmlChar *nvalnorm;
2121
0
        xmlChar fn[50];
2122
0
        xmlChar *fullname;
2123
2124
0
        fullname = xmlBuildQName(localname, prefix, fn, 50);
2125
0
        if (fullname != NULL) {
2126
0
      ctxt->vctxt.valid = 1;
2127
0
            nvalnorm = xmlValidCtxtNormalizeAttributeValue(
2128
0
                       &ctxt->vctxt, ctxt->myDoc,
2129
0
           ctxt->node, fullname, dup);
2130
0
      if (ctxt->vctxt.valid != 1)
2131
0
          ctxt->valid = 0;
2132
2133
0
      if ((fullname != fn) && (fullname != localname))
2134
0
          xmlFree(fullname);
2135
0
      if (nvalnorm != NULL) {
2136
0
          xmlFree(dup);
2137
0
          dup = nvalnorm;
2138
0
      }
2139
0
        }
2140
0
    }
2141
2142
0
    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2143
0
              ctxt->myDoc, ctxt->node, ret, dup);
2144
0
      }
2145
0
  } else {
2146
      /*
2147
       * if entities already have been substituted, then
2148
       * the attribute as passed is already normalized
2149
       */
2150
0
      dup = xmlStrndup(value, valueend - value);
2151
2152
0
      ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2153
0
                               ctxt->myDoc, ctxt->node, ret, dup);
2154
0
  }
2155
0
    } else
2156
0
#endif /* LIBXML_VALID_ENABLED */
2157
0
           if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
2158
0
         (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
2159
0
          ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0))) &&
2160
               /* Don't create IDs containing entity references */
2161
0
               (ret->children != NULL) &&
2162
0
               (ret->children->type == XML_TEXT_NODE) &&
2163
0
               (ret->children->next == NULL)) {
2164
0
        xmlChar *content = ret->children->content;
2165
        /*
2166
   * when validating, the ID registration is done at the attribute
2167
   * validation level. Otherwise we have to do specific handling here.
2168
   */
2169
0
        if ((prefix == ctxt->str_xml) &&
2170
0
             (localname[0] == 'i') && (localname[1] == 'd') &&
2171
0
       (localname[2] == 0)) {
2172
      /*
2173
       * Add the xml:id value
2174
       *
2175
       * Open issue: normalization of the value.
2176
       */
2177
0
#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
2178
0
#ifdef LIBXML_VALID_ENABLED
2179
0
      if (xmlValidateNCName(content, 1) != 0) {
2180
0
          xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
2181
0
          "xml:id : attribute value %s is not an NCName\n",
2182
0
          (const char *) content, NULL);
2183
0
      }
2184
0
#endif
2185
0
#endif
2186
0
      xmlAddID(&ctxt->vctxt, ctxt->myDoc, content, ret);
2187
0
  } else if (xmlIsID(ctxt->myDoc, ctxt->node, ret)) {
2188
0
      xmlAddID(&ctxt->vctxt, ctxt->myDoc, content, ret);
2189
0
  } else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret)) {
2190
0
      xmlAddRef(&ctxt->vctxt, ctxt->myDoc, content, ret);
2191
0
  }
2192
0
    }
2193
0
    if (dup != NULL)
2194
0
  xmlFree(dup);
2195
0
}
2196
2197
/**
2198
 * xmlSAX2StartElementNs:
2199
 * @ctx:  the user data (XML parser context)
2200
 * @localname:  the local name of the element
2201
 * @prefix:  the element namespace prefix if available
2202
 * @URI:  the element namespace name if available
2203
 * @nb_namespaces:  number of namespace definitions on that node
2204
 * @namespaces:  pointer to the array of prefix/URI pairs namespace definitions
2205
 * @nb_attributes:  the number of attributes on that node
2206
 * @nb_defaulted:  the number of defaulted attributes.
2207
 * @attributes:  pointer to the array of (localname/prefix/URI/value/end)
2208
 *               attribute values.
2209
 *
2210
 * SAX2 callback when an element start has been detected by the parser.
2211
 * It provides the namespace information for the element, as well as
2212
 * the new namespace declarations on the element.
2213
 */
2214
void
2215
xmlSAX2StartElementNs(void *ctx,
2216
                      const xmlChar *localname,
2217
          const xmlChar *prefix,
2218
          const xmlChar *URI,
2219
          int nb_namespaces,
2220
          const xmlChar **namespaces,
2221
          int nb_attributes,
2222
          int nb_defaulted,
2223
          const xmlChar **attributes)
2224
0
{
2225
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2226
0
    xmlNodePtr ret;
2227
0
    xmlNodePtr parent;
2228
0
    xmlNsPtr last = NULL, ns;
2229
0
    const xmlChar *uri, *pref;
2230
0
    xmlChar *lname = NULL;
2231
0
    int i, j;
2232
2233
0
    if (ctx == NULL) return;
2234
0
    parent = ctxt->node;
2235
    /*
2236
     * First check on validity:
2237
     */
2238
0
    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
2239
0
        ((ctxt->myDoc->intSubset == NULL) ||
2240
0
   ((ctxt->myDoc->intSubset->notations == NULL) &&
2241
0
    (ctxt->myDoc->intSubset->elements == NULL) &&
2242
0
    (ctxt->myDoc->intSubset->attributes == NULL) &&
2243
0
    (ctxt->myDoc->intSubset->entities == NULL)))) {
2244
0
  xmlErrValid(ctxt, XML_DTD_NO_DTD,
2245
0
    "Validation failed: no DTD found !", NULL, NULL);
2246
0
  ctxt->validate = 0;
2247
0
    }
2248
2249
    /*
2250
     * Take care of the rare case of an undefined namespace prefix
2251
     */
2252
0
    if ((prefix != NULL) && (URI == NULL)) {
2253
0
        if (ctxt->dictNames) {
2254
0
      const xmlChar *fullname;
2255
2256
0
      fullname = xmlDictQLookup(ctxt->dict, prefix, localname);
2257
0
      if (fullname != NULL)
2258
0
          localname = fullname;
2259
0
  } else {
2260
0
      lname = xmlBuildQName(localname, prefix, NULL, 0);
2261
0
  }
2262
0
    }
2263
    /*
2264
     * allocate the node
2265
     */
2266
0
    if (ctxt->freeElems != NULL) {
2267
0
        ret = ctxt->freeElems;
2268
0
  ctxt->freeElems = ret->next;
2269
0
  ctxt->freeElemsNr--;
2270
0
  memset(ret, 0, sizeof(xmlNode));
2271
0
        ret->doc = ctxt->myDoc;
2272
0
  ret->type = XML_ELEMENT_NODE;
2273
2274
0
  if (ctxt->dictNames)
2275
0
      ret->name = localname;
2276
0
  else {
2277
0
      if (lname == NULL)
2278
0
    ret->name = xmlStrdup(localname);
2279
0
      else
2280
0
          ret->name = lname;
2281
0
      if (ret->name == NULL) {
2282
0
          xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
2283
0
                xmlFree(ret);
2284
0
    return;
2285
0
      }
2286
0
  }
2287
0
  if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
2288
0
      xmlRegisterNodeDefaultValue(ret);
2289
0
    } else {
2290
0
  if (ctxt->dictNames)
2291
0
      ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
2292
0
                                 (xmlChar *) localname, NULL);
2293
0
  else if (lname == NULL)
2294
0
      ret = xmlNewDocNode(ctxt->myDoc, NULL, localname, NULL);
2295
0
  else
2296
0
      ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
2297
0
                                 (xmlChar *) lname, NULL);
2298
0
  if (ret == NULL) {
2299
0
      xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
2300
0
      return;
2301
0
  }
2302
0
    }
2303
0
    if (ctxt->linenumbers) {
2304
0
  if (ctxt->input != NULL) {
2305
0
      if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
2306
0
    ret->line = ctxt->input->line;
2307
0
      else
2308
0
          ret->line = USHRT_MAX;
2309
0
  }
2310
0
    }
2311
2312
0
    if (parent == NULL) {
2313
0
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
2314
0
    }
2315
    /*
2316
     * Build the namespace list
2317
     */
2318
0
    for (i = 0,j = 0;j < nb_namespaces;j++) {
2319
0
        pref = namespaces[i++];
2320
0
  uri = namespaces[i++];
2321
0
  ns = xmlNewNs(NULL, uri, pref);
2322
0
  if (ns != NULL) {
2323
0
      if (last == NULL) {
2324
0
          ret->nsDef = last = ns;
2325
0
      } else {
2326
0
          last->next = ns;
2327
0
    last = ns;
2328
0
      }
2329
0
      if ((URI != NULL) && (prefix == pref))
2330
0
    ret->ns = ns;
2331
0
  } else {
2332
            /*
2333
             * any out of memory error would already have been raised
2334
             * but we can't be guaranteed it's the actual error due to the
2335
             * API, best is to skip in this case
2336
             */
2337
0
      continue;
2338
0
  }
2339
0
#ifdef LIBXML_VALID_ENABLED
2340
0
  if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
2341
0
      ctxt->myDoc && ctxt->myDoc->intSubset) {
2342
0
      ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
2343
0
                                             ret, prefix, ns, uri);
2344
0
  }
2345
0
#endif /* LIBXML_VALID_ENABLED */
2346
0
    }
2347
0
    ctxt->nodemem = -1;
2348
2349
    /*
2350
     * We are parsing a new node.
2351
     */
2352
0
    if (nodePush(ctxt, ret) < 0) {
2353
0
        xmlUnlinkNode(ret);
2354
0
        xmlFreeNode(ret);
2355
0
        return;
2356
0
    }
2357
2358
    /*
2359
     * Link the child element
2360
     */
2361
0
    if (parent != NULL) {
2362
0
        if (parent->type == XML_ELEMENT_NODE) {
2363
0
      xmlAddChild(parent, ret);
2364
0
  } else {
2365
0
      xmlAddSibling(parent, ret);
2366
0
  }
2367
0
    }
2368
2369
    /*
2370
     * Insert the defaulted attributes from the DTD only if requested:
2371
     */
2372
0
    if ((nb_defaulted != 0) &&
2373
0
        ((ctxt->loadsubset & XML_COMPLETE_ATTRS) == 0))
2374
0
  nb_attributes -= nb_defaulted;
2375
2376
    /*
2377
     * Search the namespace if it wasn't already found
2378
     * Note that, if prefix is NULL, this searches for the default Ns
2379
     */
2380
0
    if ((URI != NULL) && (ret->ns == NULL)) {
2381
0
        ret->ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
2382
0
  if ((ret->ns == NULL) && (xmlStrEqual(prefix, BAD_CAST "xml"))) {
2383
0
      ret->ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
2384
0
  }
2385
0
  if (ret->ns == NULL) {
2386
0
      ns = xmlNewNs(ret, NULL, prefix);
2387
0
      if (ns == NULL) {
2388
2389
0
          xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
2390
0
    return;
2391
0
      }
2392
0
            if (prefix != NULL)
2393
0
                xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
2394
0
                             "Namespace prefix %s was not found\n",
2395
0
                             prefix, NULL);
2396
0
            else
2397
0
                xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
2398
0
                             "Namespace default prefix was not found\n",
2399
0
                             NULL, NULL);
2400
0
  }
2401
0
    }
2402
2403
    /*
2404
     * process all the other attributes
2405
     */
2406
0
    if (nb_attributes > 0) {
2407
0
        for (j = 0,i = 0;i < nb_attributes;i++,j+=5) {
2408
      /*
2409
       * Handle the rare case of an undefined attribute prefix
2410
       */
2411
0
      if ((attributes[j+1] != NULL) && (attributes[j+2] == NULL)) {
2412
0
    if (ctxt->dictNames) {
2413
0
        const xmlChar *fullname;
2414
2415
0
        fullname = xmlDictQLookup(ctxt->dict, attributes[j+1],
2416
0
                                  attributes[j]);
2417
0
        if (fullname != NULL) {
2418
0
      xmlSAX2AttributeNs(ctxt, fullname, NULL,
2419
0
                         attributes[j+3], attributes[j+4]);
2420
0
            continue;
2421
0
        }
2422
0
    } else {
2423
0
        lname = xmlBuildQName(attributes[j], attributes[j+1],
2424
0
                              NULL, 0);
2425
0
        if (lname != NULL) {
2426
0
      xmlSAX2AttributeNs(ctxt, lname, NULL,
2427
0
                         attributes[j+3], attributes[j+4]);
2428
0
      xmlFree(lname);
2429
0
            continue;
2430
0
        }
2431
0
    }
2432
0
      }
2433
0
      xmlSAX2AttributeNs(ctxt, attributes[j], attributes[j+1],
2434
0
             attributes[j+3], attributes[j+4]);
2435
0
  }
2436
0
    }
2437
2438
0
#ifdef LIBXML_VALID_ENABLED
2439
    /*
2440
     * If it's the Document root, finish the DTD validation and
2441
     * check the document root element for validity
2442
     */
2443
0
    if ((ctxt->validate) &&
2444
0
        ((ctxt->vctxt.flags & XML_VCTXT_DTD_VALIDATED) == 0)) {
2445
0
  int chk;
2446
2447
0
  chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
2448
0
  if (chk <= 0)
2449
0
      ctxt->valid = 0;
2450
0
  if (chk < 0)
2451
0
      ctxt->wellFormed = 0;
2452
0
  ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
2453
0
  ctxt->vctxt.flags |= XML_VCTXT_DTD_VALIDATED;
2454
0
    }
2455
0
#endif /* LIBXML_VALID_ENABLED */
2456
0
}
2457
2458
/**
2459
 * xmlSAX2EndElementNs:
2460
 * @ctx:  the user data (XML parser context)
2461
 * @localname:  the local name of the element
2462
 * @prefix:  the element namespace prefix if available
2463
 * @URI:  the element namespace name if available
2464
 *
2465
 * SAX2 callback when an element end has been detected by the parser.
2466
 * It provides the namespace information for the element.
2467
 */
2468
void
2469
xmlSAX2EndElementNs(void *ctx,
2470
                    const xmlChar * localname ATTRIBUTE_UNUSED,
2471
                    const xmlChar * prefix ATTRIBUTE_UNUSED,
2472
        const xmlChar * URI ATTRIBUTE_UNUSED)
2473
0
{
2474
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2475
2476
0
    if (ctx == NULL) return;
2477
0
    ctxt->nodemem = -1;
2478
2479
0
#ifdef LIBXML_VALID_ENABLED
2480
0
    if (ctxt->validate && ctxt->wellFormed &&
2481
0
        ctxt->myDoc && ctxt->myDoc->intSubset)
2482
0
        ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc,
2483
0
                                             ctxt->node);
2484
0
#endif /* LIBXML_VALID_ENABLED */
2485
2486
    /*
2487
     * end of parsing of this node.
2488
     */
2489
0
    nodePop(ctxt);
2490
0
}
2491
2492
/**
2493
 * xmlSAX2Reference:
2494
 * @ctx: the user data (XML parser context)
2495
 * @name:  The entity name
2496
 *
2497
 * called when an entity xmlSAX2Reference is detected.
2498
 */
2499
void
2500
xmlSAX2Reference(void *ctx, const xmlChar *name)
2501
0
{
2502
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2503
0
    xmlNodePtr ret;
2504
2505
0
    if (ctx == NULL) return;
2506
#ifdef DEBUG_SAX
2507
    xmlGenericError(xmlGenericErrorContext,
2508
      "SAX.xmlSAX2Reference(%s)\n", name);
2509
#endif
2510
0
    if (name[0] == '#')
2511
0
  ret = xmlNewCharRef(ctxt->myDoc, name);
2512
0
    else
2513
0
  ret = xmlNewReference(ctxt->myDoc, name);
2514
#ifdef DEBUG_SAX_TREE
2515
    xmlGenericError(xmlGenericErrorContext,
2516
      "add xmlSAX2Reference %s to %s \n", name, ctxt->node->name);
2517
#endif
2518
0
    if (xmlAddChild(ctxt->node, ret) == NULL) {
2519
0
        xmlFreeNode(ret);
2520
0
    }
2521
0
}
2522
2523
/**
2524
 * xmlSAX2Text:
2525
 * @ctx: the user data (XML parser context)
2526
 * @ch:  a xmlChar string
2527
 * @len: the number of xmlChar
2528
 * @type: text or cdata
2529
 *
2530
 * Append characters.
2531
 */
2532
static void
2533
xmlSAX2Text(xmlParserCtxtPtr ctxt, const xmlChar *ch, int len,
2534
            xmlElementType type)
2535
0
{
2536
0
    xmlNodePtr lastChild;
2537
2538
0
    if (ctxt == NULL) return;
2539
#ifdef DEBUG_SAX
2540
    xmlGenericError(xmlGenericErrorContext,
2541
      "SAX.xmlSAX2Characters(%.30s, %d)\n", ch, len);
2542
#endif
2543
    /*
2544
     * Handle the data if any. If there is no child
2545
     * add it as content, otherwise if the last child is text,
2546
     * concatenate it, else create a new node of type text.
2547
     */
2548
2549
0
    if (ctxt->node == NULL) {
2550
#ifdef DEBUG_SAX_TREE
2551
  xmlGenericError(xmlGenericErrorContext,
2552
    "add chars: ctxt->node == NULL !\n");
2553
#endif
2554
0
        return;
2555
0
    }
2556
0
    lastChild = ctxt->node->last;
2557
#ifdef DEBUG_SAX_TREE
2558
    xmlGenericError(xmlGenericErrorContext,
2559
      "add chars to %s \n", ctxt->node->name);
2560
#endif
2561
2562
    /*
2563
     * Here we needed an accelerator mechanism in case of very large
2564
     * elements. Use an attribute in the structure !!!
2565
     */
2566
0
    if (lastChild == NULL) {
2567
0
        if (type == XML_TEXT_NODE)
2568
0
            lastChild = xmlSAX2TextNode(ctxt, ch, len);
2569
0
        else
2570
0
            lastChild = xmlNewCDataBlock(ctxt->myDoc, ch, len);
2571
0
  if (lastChild != NULL) {
2572
0
      ctxt->node->children = lastChild;
2573
0
      ctxt->node->last = lastChild;
2574
0
      lastChild->parent = ctxt->node;
2575
0
      lastChild->doc = ctxt->node->doc;
2576
0
      ctxt->nodelen = len;
2577
0
      ctxt->nodemem = len + 1;
2578
0
  } else {
2579
0
      xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
2580
0
      return;
2581
0
  }
2582
0
    } else {
2583
0
  int coalesceText = (lastChild != NULL) &&
2584
0
      (lastChild->type == type) &&
2585
0
      ((type != XML_TEXT_NODE) ||
2586
0
             (lastChild->name == xmlStringText));
2587
0
  if ((coalesceText) && (ctxt->nodemem != 0)) {
2588
      /*
2589
       * The whole point of maintaining nodelen and nodemem,
2590
       * xmlTextConcat is too costly, i.e. compute length,
2591
       * reallocate a new buffer, move data, append ch. Here
2592
       * We try to minimize realloc() uses and avoid copying
2593
       * and recomputing length over and over.
2594
       */
2595
0
      if (lastChild->content == (xmlChar *)&(lastChild->properties)) {
2596
0
    lastChild->content = xmlStrdup(lastChild->content);
2597
0
    lastChild->properties = NULL;
2598
0
      } else if ((ctxt->nodemem == ctxt->nodelen + 1) &&
2599
0
                 (xmlDictOwns(ctxt->dict, lastChild->content))) {
2600
0
    lastChild->content = xmlStrdup(lastChild->content);
2601
0
      }
2602
0
      if (lastChild->content == NULL) {
2603
0
    xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters: xmlStrdup returned NULL");
2604
0
    return;
2605
0
      }
2606
0
      if (ctxt->nodelen > INT_MAX - len) {
2607
0
                xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters overflow prevented");
2608
0
                return;
2609
0
      }
2610
0
            if ((ctxt->nodelen + len > XML_MAX_TEXT_LENGTH) &&
2611
0
                ((ctxt->options & XML_PARSE_HUGE) == 0)) {
2612
0
                xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters: huge text node");
2613
0
                return;
2614
0
            }
2615
0
      if (ctxt->nodelen + len >= ctxt->nodemem) {
2616
0
    xmlChar *newbuf;
2617
0
    int size;
2618
2619
0
    size = ctxt->nodemem > INT_MAX - len ?
2620
0
                       INT_MAX :
2621
0
                       ctxt->nodemem + len;
2622
0
    size = size > INT_MAX / 2 ? INT_MAX : size * 2;
2623
0
                newbuf = (xmlChar *) xmlRealloc(lastChild->content,size);
2624
0
    if (newbuf == NULL) {
2625
0
        xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
2626
0
        return;
2627
0
    }
2628
0
    ctxt->nodemem = size;
2629
0
    lastChild->content = newbuf;
2630
0
      }
2631
0
      memcpy(&lastChild->content[ctxt->nodelen], ch, len);
2632
0
      ctxt->nodelen += len;
2633
0
      lastChild->content[ctxt->nodelen] = 0;
2634
0
  } else if (coalesceText) {
2635
0
      if (xmlTextConcat(lastChild, ch, len)) {
2636
0
    xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
2637
0
      }
2638
0
      if (ctxt->node->children != NULL) {
2639
0
    ctxt->nodelen = xmlStrlen(lastChild->content);
2640
0
    ctxt->nodemem = ctxt->nodelen + 1;
2641
0
      }
2642
0
  } else {
2643
      /* Mixed content, first time */
2644
0
            if (type == XML_TEXT_NODE) {
2645
0
                lastChild = xmlSAX2TextNode(ctxt, ch, len);
2646
0
                if (lastChild != NULL)
2647
0
                    lastChild->doc = ctxt->myDoc;
2648
0
            } else
2649
0
                lastChild = xmlNewCDataBlock(ctxt->myDoc, ch, len);
2650
0
      if (lastChild != NULL) {
2651
0
    xmlAddChild(ctxt->node, lastChild);
2652
0
    if (ctxt->node->children != NULL) {
2653
0
        ctxt->nodelen = len;
2654
0
        ctxt->nodemem = len + 1;
2655
0
    }
2656
0
      }
2657
0
  }
2658
0
    }
2659
0
}
2660
2661
/**
2662
 * xmlSAX2Characters:
2663
 * @ctx: the user data (XML parser context)
2664
 * @ch:  a xmlChar string
2665
 * @len: the number of xmlChar
2666
 *
2667
 * receiving some chars from the parser.
2668
 */
2669
void
2670
xmlSAX2Characters(void *ctx, const xmlChar *ch, int len)
2671
0
{
2672
0
    xmlSAX2Text((xmlParserCtxtPtr) ctx, ch, len, XML_TEXT_NODE);
2673
0
}
2674
2675
/**
2676
 * xmlSAX2IgnorableWhitespace:
2677
 * @ctx: the user data (XML parser context)
2678
 * @ch:  a xmlChar string
2679
 * @len: the number of xmlChar
2680
 *
2681
 * receiving some ignorable whitespaces from the parser.
2682
 * UNUSED: by default the DOM building will use xmlSAX2Characters
2683
 */
2684
void
2685
xmlSAX2IgnorableWhitespace(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED)
2686
0
{
2687
    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
2688
#ifdef DEBUG_SAX
2689
    xmlGenericError(xmlGenericErrorContext,
2690
      "SAX.xmlSAX2IgnorableWhitespace(%.30s, %d)\n", ch, len);
2691
#endif
2692
0
}
2693
2694
/**
2695
 * xmlSAX2ProcessingInstruction:
2696
 * @ctx: the user data (XML parser context)
2697
 * @target:  the target name
2698
 * @data: the PI data's
2699
 *
2700
 * A processing instruction has been parsed.
2701
 */
2702
void
2703
xmlSAX2ProcessingInstruction(void *ctx, const xmlChar *target,
2704
                      const xmlChar *data)
2705
0
{
2706
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2707
0
    xmlNodePtr ret;
2708
0
    xmlNodePtr parent;
2709
2710
0
    if (ctx == NULL) return;
2711
0
    parent = ctxt->node;
2712
#ifdef DEBUG_SAX
2713
    xmlGenericError(xmlGenericErrorContext,
2714
      "SAX.xmlSAX2ProcessingInstruction(%s, %s)\n", target, data);
2715
#endif
2716
2717
0
    ret = xmlNewDocPI(ctxt->myDoc, target, data);
2718
0
    if (ret == NULL) return;
2719
2720
0
    if (ctxt->linenumbers) {
2721
0
  if (ctxt->input != NULL) {
2722
0
      if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
2723
0
    ret->line = ctxt->input->line;
2724
0
      else
2725
0
          ret->line = USHRT_MAX;
2726
0
  }
2727
0
    }
2728
0
    if (ctxt->inSubset == 1) {
2729
0
  xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
2730
0
  return;
2731
0
    } else if (ctxt->inSubset == 2) {
2732
0
  xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
2733
0
  return;
2734
0
    }
2735
0
    if (parent == NULL) {
2736
#ifdef DEBUG_SAX_TREE
2737
      xmlGenericError(xmlGenericErrorContext,
2738
        "Setting PI %s as root\n", target);
2739
#endif
2740
0
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
2741
0
  return;
2742
0
    }
2743
0
    if (parent->type == XML_ELEMENT_NODE) {
2744
#ifdef DEBUG_SAX_TREE
2745
  xmlGenericError(xmlGenericErrorContext,
2746
    "adding PI %s child to %s\n", target, parent->name);
2747
#endif
2748
0
  xmlAddChild(parent, ret);
2749
0
    } else {
2750
#ifdef DEBUG_SAX_TREE
2751
  xmlGenericError(xmlGenericErrorContext,
2752
    "adding PI %s sibling to ", target);
2753
  xmlDebugDumpOneNode(stderr, parent, 0);
2754
#endif
2755
0
  xmlAddSibling(parent, ret);
2756
0
    }
2757
0
}
2758
2759
/**
2760
 * xmlSAX2Comment:
2761
 * @ctx: the user data (XML parser context)
2762
 * @value:  the xmlSAX2Comment content
2763
 *
2764
 * A xmlSAX2Comment has been parsed.
2765
 */
2766
void
2767
xmlSAX2Comment(void *ctx, const xmlChar *value)
2768
0
{
2769
0
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2770
0
    xmlNodePtr ret;
2771
0
    xmlNodePtr parent;
2772
2773
0
    if (ctx == NULL) return;
2774
0
    parent = ctxt->node;
2775
#ifdef DEBUG_SAX
2776
    xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2Comment(%s)\n", value);
2777
#endif
2778
0
    ret = xmlNewDocComment(ctxt->myDoc, value);
2779
0
    if (ret == NULL) return;
2780
0
    if (ctxt->linenumbers) {
2781
0
  if (ctxt->input != NULL) {
2782
0
      if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
2783
0
    ret->line = ctxt->input->line;
2784
0
      else
2785
0
          ret->line = USHRT_MAX;
2786
0
  }
2787
0
    }
2788
2789
0
    if (ctxt->inSubset == 1) {
2790
0
  xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
2791
0
  return;
2792
0
    } else if (ctxt->inSubset == 2) {
2793
0
  xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
2794
0
  return;
2795
0
    }
2796
0
    if (parent == NULL) {
2797
#ifdef DEBUG_SAX_TREE
2798
      xmlGenericError(xmlGenericErrorContext,
2799
        "Setting xmlSAX2Comment as root\n");
2800
#endif
2801
0
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
2802
0
  return;
2803
0
    }
2804
0
    if (parent->type == XML_ELEMENT_NODE) {
2805
#ifdef DEBUG_SAX_TREE
2806
  xmlGenericError(xmlGenericErrorContext,
2807
    "adding xmlSAX2Comment child to %s\n", parent->name);
2808
#endif
2809
0
  xmlAddChild(parent, ret);
2810
0
    } else {
2811
#ifdef DEBUG_SAX_TREE
2812
  xmlGenericError(xmlGenericErrorContext,
2813
    "adding xmlSAX2Comment sibling to ");
2814
  xmlDebugDumpOneNode(stderr, parent, 0);
2815
#endif
2816
0
  xmlAddSibling(parent, ret);
2817
0
    }
2818
0
}
2819
2820
/**
2821
 * xmlSAX2CDataBlock:
2822
 * @ctx: the user data (XML parser context)
2823
 * @value:  The pcdata content
2824
 * @len:  the block length
2825
 *
2826
 * called when a pcdata block has been parsed
2827
 */
2828
void
2829
xmlSAX2CDataBlock(void *ctx, const xmlChar *value, int len)
2830
0
{
2831
0
    xmlSAX2Text((xmlParserCtxtPtr) ctx, value, len, XML_CDATA_SECTION_NODE);
2832
0
}
2833
2834
static int xmlSAX2DefaultVersionValue = 2;
2835
2836
#ifdef LIBXML_SAX1_ENABLED
2837
/**
2838
 * xmlSAXDefaultVersion:
2839
 * @version:  the version, 1 or 2
2840
 *
2841
 * DEPRECATED: Use parser option XML_PARSE_SAX1.
2842
 *
2843
 * Set the default version of SAX used globally by the library.
2844
 * By default, during initialization the default is set to 2.
2845
 * Note that it is generally a better coding style to use
2846
 * xmlSAXVersion() to set up the version explicitly for a given
2847
 * parsing context.
2848
 *
2849
 * Returns the previous value in case of success and -1 in case of error.
2850
 */
2851
int
2852
xmlSAXDefaultVersion(int version)
2853
0
{
2854
0
    int ret = xmlSAX2DefaultVersionValue;
2855
2856
0
    if ((version != 1) && (version != 2))
2857
0
        return(-1);
2858
0
    xmlSAX2DefaultVersionValue = version;
2859
0
    return(ret);
2860
0
}
2861
#endif /* LIBXML_SAX1_ENABLED */
2862
2863
/**
2864
 * xmlSAXVersion:
2865
 * @hdlr:  the SAX handler
2866
 * @version:  the version, 1 or 2
2867
 *
2868
 * Initialize the default XML SAX handler according to the version
2869
 *
2870
 * Returns 0 in case of success and -1 in case of error.
2871
 */
2872
int
2873
xmlSAXVersion(xmlSAXHandler *hdlr, int version)
2874
0
{
2875
0
    if (hdlr == NULL) return(-1);
2876
0
    if (version == 2) {
2877
0
  hdlr->startElement = NULL;
2878
0
  hdlr->endElement = NULL;
2879
0
  hdlr->startElementNs = xmlSAX2StartElementNs;
2880
0
  hdlr->endElementNs = xmlSAX2EndElementNs;
2881
0
  hdlr->serror = NULL;
2882
0
  hdlr->initialized = XML_SAX2_MAGIC;
2883
0
#ifdef LIBXML_SAX1_ENABLED
2884
0
    } else if (version == 1) {
2885
0
  hdlr->startElement = xmlSAX2StartElement;
2886
0
  hdlr->endElement = xmlSAX2EndElement;
2887
0
  hdlr->initialized = 1;
2888
0
#endif /* LIBXML_SAX1_ENABLED */
2889
0
    } else
2890
0
        return(-1);
2891
0
    hdlr->internalSubset = xmlSAX2InternalSubset;
2892
0
    hdlr->externalSubset = xmlSAX2ExternalSubset;
2893
0
    hdlr->isStandalone = xmlSAX2IsStandalone;
2894
0
    hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
2895
0
    hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
2896
0
    hdlr->resolveEntity = xmlSAX2ResolveEntity;
2897
0
    hdlr->getEntity = xmlSAX2GetEntity;
2898
0
    hdlr->getParameterEntity = xmlSAX2GetParameterEntity;
2899
0
    hdlr->entityDecl = xmlSAX2EntityDecl;
2900
0
    hdlr->attributeDecl = xmlSAX2AttributeDecl;
2901
0
    hdlr->elementDecl = xmlSAX2ElementDecl;
2902
0
    hdlr->notationDecl = xmlSAX2NotationDecl;
2903
0
    hdlr->unparsedEntityDecl = xmlSAX2UnparsedEntityDecl;
2904
0
    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
2905
0
    hdlr->startDocument = xmlSAX2StartDocument;
2906
0
    hdlr->endDocument = xmlSAX2EndDocument;
2907
0
    hdlr->reference = xmlSAX2Reference;
2908
0
    hdlr->characters = xmlSAX2Characters;
2909
0
    hdlr->cdataBlock = xmlSAX2CDataBlock;
2910
0
    hdlr->ignorableWhitespace = xmlSAX2Characters;
2911
0
    hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
2912
0
    hdlr->comment = xmlSAX2Comment;
2913
0
    hdlr->warning = xmlParserWarning;
2914
0
    hdlr->error = xmlParserError;
2915
0
    hdlr->fatalError = xmlParserError;
2916
2917
0
    return(0);
2918
0
}
2919
2920
/**
2921
 * xmlSAX2InitDefaultSAXHandler:
2922
 * @hdlr:  the SAX handler
2923
 * @warning:  flag if non-zero sets the handler warning procedure
2924
 *
2925
 * Initialize the default XML SAX2 handler
2926
 */
2927
void
2928
xmlSAX2InitDefaultSAXHandler(xmlSAXHandler *hdlr, int warning)
2929
0
{
2930
0
    if ((hdlr == NULL) || (hdlr->initialized != 0))
2931
0
  return;
2932
2933
0
    xmlSAXVersion(hdlr, xmlSAX2DefaultVersionValue);
2934
0
    if (warning == 0)
2935
0
  hdlr->warning = NULL;
2936
0
    else
2937
0
  hdlr->warning = xmlParserWarning;
2938
0
}
2939
2940
/**
2941
 * xmlDefaultSAXHandlerInit:
2942
 *
2943
 * DEPRECATED: This function is a no-op. Call xmlInitParser to
2944
 * initialize the library.
2945
 *
2946
 * Initialize the default SAX2 handler
2947
 */
2948
void
2949
xmlDefaultSAXHandlerInit(void)
2950
0
{
2951
0
}
2952
2953
#ifdef LIBXML_HTML_ENABLED
2954
2955
/**
2956
 * xmlSAX2InitHtmlDefaultSAXHandler:
2957
 * @hdlr:  the SAX handler
2958
 *
2959
 * Initialize the default HTML SAX2 handler
2960
 */
2961
void
2962
xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr)
2963
0
{
2964
0
    if ((hdlr == NULL) || (hdlr->initialized != 0))
2965
0
  return;
2966
2967
0
    hdlr->internalSubset = xmlSAX2InternalSubset;
2968
0
    hdlr->externalSubset = NULL;
2969
0
    hdlr->isStandalone = NULL;
2970
0
    hdlr->hasInternalSubset = NULL;
2971
0
    hdlr->hasExternalSubset = NULL;
2972
0
    hdlr->resolveEntity = NULL;
2973
0
    hdlr->getEntity = xmlSAX2GetEntity;
2974
0
    hdlr->getParameterEntity = NULL;
2975
0
    hdlr->entityDecl = NULL;
2976
0
    hdlr->attributeDecl = NULL;
2977
0
    hdlr->elementDecl = NULL;
2978
0
    hdlr->notationDecl = NULL;
2979
0
    hdlr->unparsedEntityDecl = NULL;
2980
0
    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
2981
0
    hdlr->startDocument = xmlSAX2StartDocument;
2982
0
    hdlr->endDocument = xmlSAX2EndDocument;
2983
0
    hdlr->startElement = xmlSAX2StartElement;
2984
0
    hdlr->endElement = xmlSAX2EndElement;
2985
0
    hdlr->reference = NULL;
2986
0
    hdlr->characters = xmlSAX2Characters;
2987
0
    hdlr->cdataBlock = xmlSAX2CDataBlock;
2988
0
    hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
2989
0
    hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
2990
0
    hdlr->comment = xmlSAX2Comment;
2991
0
    hdlr->warning = xmlParserWarning;
2992
0
    hdlr->error = xmlParserError;
2993
0
    hdlr->fatalError = xmlParserError;
2994
2995
0
    hdlr->initialized = 1;
2996
0
}
2997
2998
/**
2999
 * htmlDefaultSAXHandlerInit:
3000
 *
3001
 * DEPRECATED: This function is a no-op. Call xmlInitParser to
3002
 * initialize the library.
3003
 */
3004
void
3005
htmlDefaultSAXHandlerInit(void)
3006
0
{
3007
0
}
3008
3009
#endif /* LIBXML_HTML_ENABLED */