~ubuntu-branches/ubuntu/utopic/libxml2/utopic
» Revision
43.2.6
: .pc/0010-Fix-handling-of-mmap-errors.patch/xmllint.c
« back to all changes in this revision
Viewing changes to .pc/0010-Fix-handling-of-mmap-errors.patch/xmllint.c
- browse files at revision 43.2.6
- compare with another revision
- download diff
- download tarball
- view history from revision 43.2.6
- Committer: Package Import Robot
- Author(s): Aron Xu, Christian Svensson, Daniel Schepler, Helmut Grohne, Adam Conrad, Matthias Klose, Aron Xu
- Date: 2014-07-09 05:40:15 UTC
- mto: This revision was merged to the branch mainline in revision 75.
- Revision ID: package-import@ubuntu.com-20140709054015-rdnfjxrf3zvmw6l7
[ Christian Svensson ]
* Do not build-depend on readline (Closes: #742350)
[ Daniel Schepler ]
* Patch to bootstrap without python (Closes: #738080)
[ Helmut Grohne ]
* Drop unneeded B-D on perl and binutils (Closes: #753005)
[ Adam Conrad ]
* Actually run dh_autoreconf, which the old/new mixed rules file misses.
[ Matthias Klose ]
* Add patch to fix python multiarch issue
* Allow the package to cross-build by tweaking B-Ds on python
* Set PYTHON_LIBS for cross builds
[ Aron Xu ]
* Use correct $CC
* Configure udeb without python
* New round of cherry-picking upstream fixes
- Includes fixes for CVE-2014-0191 (Closes: #747309).
* Call prename with -vf
* Require python-all-dev (>= 2.7.5-5~)
* Bump std-ver: 3.9.4 -> 3.9.5, no change
* Do not build-depend on readline (Closes: #742350)
[ Daniel Schepler ]
* Patch to bootstrap without python (Closes: #738080)
[ Helmut Grohne ]
* Drop unneeded B-D on perl and binutils (Closes: #753005)
[ Adam Conrad ]
* Actually run dh_autoreconf, which the old/new mixed rules file misses.
[ Matthias Klose ]
* Add patch to fix python multiarch issue
* Allow the package to cross-build by tweaking B-Ds on python
* Set PYTHON_LIBS for cross builds
[ Aron Xu ]
* Use correct $CC
* Configure udeb without python
* New round of cherry-picking upstream fixes
- Includes fixes for CVE-2014-0191 (Closes: #747309).
* Call prename with -vf
* Require python-all-dev (>= 2.7.5-5~)
* Bump std-ver: 3.9.4 -> 3.9.5, no change
- files added:
- .pc/0002-fix-python-multiarch-includes.patch
- .pc/0002-fix-python-multiarch-includes.patch/python
- .pc/0003-Fix-an-error-in-xmlCleanupParser.patch
- .pc/0004-Fix-missing-break-on-last-function-for-attributes.patch
- .pc/0004-Fix-missing-break-on-last-function-for-attributes.patch/python
- .pc/0005-xmllint-memory-should-fail-on-empty-files.patch
- .pc/0006-properly-quote-the-namespace-uris-written-out-during.patch
- .pc/0007-Fix-a-parsing-bug-on-non-ascii-element-and-CR-LF-usa.patch
- .pc/0008-missing-else-in-xlink.c.patch
- .pc/0009-Catch-malloc-error-and-exit-accordingly.patch
- .pc/0010-Fix-handling-of-mmap-errors.patch
- .pc/0011-Avoid-crash-if-allocation-fails.patch
- .pc/0012-Fix-a-possible-NULL-dereference.patch
- .pc/0013-Clear-up-a-potential-NULL-dereference.patch
- .pc/0014-Fix-XPath-optimization-with-predicates.patch
- .pc/0015-xmllint-pretty-crashed-without-following-numeric-arg.patch
- .pc/0016-Fix-potential-NULL-pointer-dereferences-in-regexp-co.patch
- .pc/0017-Fix-a-potential-NULL-dereference-in-tree-code.patch
- .pc/0018-Fix-pointer-dereferenced-before-null-check.patch
- .pc/0019-Fix-a-bug-loading-some-compressed-files.patch
- .pc/0020-Avoid-a-possibility-of-dangling-encoding-handler.patch
- .pc/0021-Fix-a-couple-of-missing-NULL-checks.patch
- .pc/0022-adding-init-calls-to-xml-and-html-Read-parsing-entry.patch
- .pc/0023-Handling-of-XPath-function-arguments-in-error-case.patch
- .pc/0024-Missing-initialization-for-the-catalog-module.patch
- .pc/0025-Fix-an-fd-leak-in-an-error-case.patch
- .pc/0026-fixing-a-ptotential-uninitialized-access.patch
- .pc/0027-Fix-xmlTextWriterWriteElement-when-a-null-content-is.patch
- .pc/0028-Avoid-a-possible-NULL-pointer-dereference.patch
- .pc/0029-Do-not-fetch-external-parameter-entities.patch
- .pc/0030-Avoid-Possible-null-pointer-dereference-in-memory-de.patch
- .pc/0031-xmllint-was-not-parsing-the-c14n11-flag.patch
- .pc/0032-Fix-regressions-introduced-by-CVE-2014-0191-patch.patch
- files removed:
- .pc/0002-Fix-an-error-in-xmlCleanupParser.patch
- .pc/0003-Fix-missing-break-on-last-function-for-attributes.patch
- .pc/0003-Fix-missing-break-on-last-function-for-attributes.patch/python
- .pc/0004-xmllint-memory-should-fail-on-empty-files.patch
- .pc/0005-properly-quote-the-namespace-uris-written-out-during.patch
- .pc/0006-Fix-a-parsing-bug-on-non-ascii-element-and-CR-LF-usa.patch
- .pc/0007-Fix-XPath-optimization-with-predicates.patch
- files modified:
- .pc/applied-patches
added
removed
.pc/0010-Fix-handling-of-mmap-errors.patch/xmllint.c
1
/*
2
* xmllint.c : a small tester program for XML input.
3
*
4
* See Copyright for the status of this software.
5
*
6
* daniel@veillard.com
7
*/
8
9
#include "libxml.h"
10
11
#include <string.h>
12
#include <stdarg.h>
13
#include <assert.h>
14
15
#if defined (_WIN32) && !defined(__CYGWIN__)
16
#if defined (_MSC_VER) || defined(__BORLANDC__)
17
#include <winsock2.h>
18
#pragma comment(lib, "ws2_32.lib")
19
#define gettimeofday(p1,p2)
20
#endif /* _MSC_VER */
21
#endif /* _WIN32 */
22
23
#ifdef HAVE_SYS_TIME_H
24
#include <sys/time.h>
25
#endif
26
#ifdef HAVE_TIME_H
27
#include <time.h>
28
#endif
29
30
#ifdef __MINGW32__
31
#define _WINSOCKAPI_
32
#include <wsockcompat.h>
33
#include <winsock2.h>
34
#undef XML_SOCKLEN_T
35
#define XML_SOCKLEN_T unsigned int
36
#endif
37
38
#ifdef HAVE_SYS_TIMEB_H
39
#include <sys/timeb.h>
40
#endif
41
42
#ifdef HAVE_SYS_TYPES_H
43
#include <sys/types.h>
44
#endif
45
#ifdef HAVE_SYS_STAT_H
46
#include <sys/stat.h>
47
#endif
48
#ifdef HAVE_FCNTL_H
49
#include <fcntl.h>
50
#endif
51
#ifdef HAVE_UNISTD_H
52
#include <unistd.h>
53
#endif
54
#ifdef HAVE_SYS_MMAN_H
55
#include <sys/mman.h>
56
/* seems needed for Solaris */
57
#ifndef MAP_FAILED
58
#define MAP_FAILED ((void *) -1)
59
#endif
60
#endif
61
#ifdef HAVE_STDLIB_H
62
#include <stdlib.h>
63
#endif
64
#ifdef HAVE_LIBREADLINE
65
#include <readline/readline.h>
66
#ifdef HAVE_LIBHISTORY
67
#include <readline/history.h>
68
#endif
69
#endif
70
71
#include <libxml/xmlmemory.h>
72
#include <libxml/parser.h>
73
#include <libxml/parserInternals.h>
74
#include <libxml/HTMLparser.h>
75
#include <libxml/HTMLtree.h>
76
#include <libxml/tree.h>
77
#include <libxml/xpath.h>
78
#include <libxml/debugXML.h>
79
#include <libxml/xmlerror.h>
80
#ifdef LIBXML_XINCLUDE_ENABLED
81
#include <libxml/xinclude.h>
82
#endif
83
#ifdef LIBXML_CATALOG_ENABLED
84
#include <libxml/catalog.h>
85
#endif
86
#include <libxml/globals.h>
87
#include <libxml/xmlreader.h>
88
#ifdef LIBXML_SCHEMATRON_ENABLED
89
#include <libxml/schematron.h>
90
#endif
91
#ifdef LIBXML_SCHEMAS_ENABLED
92
#include <libxml/relaxng.h>
93
#include <libxml/xmlschemas.h>
94
#endif
95
#ifdef LIBXML_PATTERN_ENABLED
96
#include <libxml/pattern.h>
97
#endif
98
#ifdef LIBXML_C14N_ENABLED
99
#include <libxml/c14n.h>
100
#endif
101
#ifdef LIBXML_OUTPUT_ENABLED
102
#include <libxml/xmlsave.h>
103
#endif
104
105
#ifndef XML_XML_DEFAULT_CATALOG
106
#define XML_XML_DEFAULT_CATALOG "file:///etc/xml/catalog"
107
#endif
108
109
typedef enum {
110
XMLLINT_RETURN_OK = 0, /* No error */
111
XMLLINT_ERR_UNCLASS = 1, /* Unclassified */
112
XMLLINT_ERR_DTD = 2, /* Error in DTD */
113
XMLLINT_ERR_VALID = 3, /* Validation error */
114
XMLLINT_ERR_RDFILE = 4, /* CtxtReadFile error */
115
XMLLINT_ERR_SCHEMACOMP = 5, /* Schema compilation */
116
XMLLINT_ERR_OUT = 6, /* Error writing output */
117
XMLLINT_ERR_SCHEMAPAT = 7, /* Error in schema pattern */
118
XMLLINT_ERR_RDREGIS = 8, /* Error in Reader registration */
119
XMLLINT_ERR_MEM = 9, /* Out of memory error */
120
XMLLINT_ERR_XPATH = 10 /* XPath evaluation error */
121
} xmllintReturnCode;
122
#ifdef LIBXML_DEBUG_ENABLED
123
static int shell = 0;
124
static int debugent = 0;
125
#endif
126
static int debug = 0;
127
static int maxmem = 0;
128
#ifdef LIBXML_TREE_ENABLED
129
static int copy = 0;
130
#endif /* LIBXML_TREE_ENABLED */
131
static int recovery = 0;
132
static int noent = 0;
133
static int noenc = 0;
134
static int noblanks = 0;
135
static int noout = 0;
136
static int nowrap = 0;
137
#ifdef LIBXML_OUTPUT_ENABLED
138
static int format = 0;
139
static const char *output = NULL;
140
static int compress = 0;
141
static int oldout = 0;
142
#endif /* LIBXML_OUTPUT_ENABLED */
143
#ifdef LIBXML_VALID_ENABLED
144
static int valid = 0;
145
static int postvalid = 0;
146
static char * dtdvalid = NULL;
147
static char * dtdvalidfpi = NULL;
148
#endif
149
#ifdef LIBXML_SCHEMAS_ENABLED
150
static char * relaxng = NULL;
151
static xmlRelaxNGPtr relaxngschemas = NULL;
152
static char * schema = NULL;
153
static xmlSchemaPtr wxschemas = NULL;
154
#endif
155
#ifdef LIBXML_SCHEMATRON_ENABLED
156
static char * schematron = NULL;
157
static xmlSchematronPtr wxschematron = NULL;
158
#endif
159
static int repeat = 0;
160
static int insert = 0;
161
#if defined(LIBXML_HTML_ENABLED) || defined(LIBXML_VALID_ENABLED)
162
static int html = 0;
163
static int xmlout = 0;
164
#endif
165
static int htmlout = 0;
166
#if defined(LIBXML_HTML_ENABLED)
167
static int nodefdtd = 0;
168
#endif
169
#ifdef LIBXML_PUSH_ENABLED
170
static int push = 0;
171
static int pushsize = 4096;
172
#endif /* LIBXML_PUSH_ENABLED */
173
#ifdef HAVE_MMAP
174
static int memory = 0;
175
#endif
176
static int testIO = 0;
177
static char *encoding = NULL;
178
#ifdef LIBXML_XINCLUDE_ENABLED
179
static int xinclude = 0;
180
#endif
181
static int dtdattrs = 0;
182
static int loaddtd = 0;
183
static xmllintReturnCode progresult = XMLLINT_RETURN_OK;
184
static int timing = 0;
185
static int generate = 0;
186
static int dropdtd = 0;
187
#ifdef LIBXML_CATALOG_ENABLED
188
static int catalogs = 0;
189
static int nocatalogs = 0;
190
#endif
191
#ifdef LIBXML_C14N_ENABLED
192
static int canonical = 0;
193
static int canonical_11 = 0;
194
static int exc_canonical = 0;
195
#endif
196
#ifdef LIBXML_READER_ENABLED
197
static int stream = 0;
198
static int walker = 0;
199
#endif /* LIBXML_READER_ENABLED */
200
static int chkregister = 0;
201
static int nbregister = 0;
202
#ifdef LIBXML_SAX1_ENABLED
203
static int sax1 = 0;
204
#endif /* LIBXML_SAX1_ENABLED */
205
#ifdef LIBXML_PATTERN_ENABLED
206
static const char *pattern = NULL;
207
static xmlPatternPtr patternc = NULL;
208
static xmlStreamCtxtPtr patstream = NULL;
209
#endif
210
#ifdef LIBXML_XPATH_ENABLED
211
static const char *xpathquery = NULL;
212
#endif
213
static int options = XML_PARSE_COMPACT | XML_PARSE_BIG_LINES;
214
static int sax = 0;
215
static int oldxml10 = 0;
216
217
/************************************************************************
218
* *
219
* Entity loading control and customization. *
220
* *
221
************************************************************************/
222
#define MAX_PATHS 64
223
#ifdef _WIN32
224
# define PATH_SEPARATOR ';'
225
#else
226
# define PATH_SEPARATOR ':'
227
#endif
228
static xmlChar *paths[MAX_PATHS + 1];
229
static int nbpaths = 0;
230
static int load_trace = 0;
231
232
static
233
void parsePath(const xmlChar *path) {
234
const xmlChar *cur;
235
236
if (path == NULL)
237
return;
238
while (*path != 0) {
239
if (nbpaths >= MAX_PATHS) {
240
fprintf(stderr, "MAX_PATHS reached: too many paths\n");
241
return;
242
}
243
cur = path;
244
while ((*cur == ' ') || (*cur == PATH_SEPARATOR))
245
cur++;
246
path = cur;
247
while ((*cur != 0) && (*cur != ' ') && (*cur != PATH_SEPARATOR))
248
cur++;
249
if (cur != path) {
250
paths[nbpaths] = xmlStrndup(path, cur - path);
251
if (paths[nbpaths] != NULL)
252
nbpaths++;
253
path = cur;
254
}
255
}
256
}
257
258
static xmlExternalEntityLoader defaultEntityLoader = NULL;
259
260
static xmlParserInputPtr
261
xmllintExternalEntityLoader(const char *URL, const char *ID,
262
xmlParserCtxtPtr ctxt) {
263
xmlParserInputPtr ret;
264
warningSAXFunc warning = NULL;
265
errorSAXFunc err = NULL;
266
267
int i;
268
const char *lastsegment = URL;
269
const char *iter = URL;
270
271
if ((nbpaths > 0) && (iter != NULL)) {
272
while (*iter != 0) {
273
if (*iter == '/')
274
lastsegment = iter + 1;
275
iter++;
276
}
277
}
278
279
if ((ctxt != NULL) && (ctxt->sax != NULL)) {
280
warning = ctxt->sax->warning;
281
err = ctxt->sax->error;
282
ctxt->sax->warning = NULL;
283
ctxt->sax->error = NULL;
284
}
285
286
if (defaultEntityLoader != NULL) {
287
ret = defaultEntityLoader(URL, ID, ctxt);
288
if (ret != NULL) {
289
if (warning != NULL)
290
ctxt->sax->warning = warning;
291
if (err != NULL)
292
ctxt->sax->error = err;
293
if (load_trace) {
294
fprintf \
295
(stderr,
296
"Loaded URL=\"%s\" ID=\"%s\"\n",
297
URL ? URL : "(null)",
298
ID ? ID : "(null)");
299
}
300
return(ret);
301
}
302
}
303
for (i = 0;i < nbpaths;i++) {
304
xmlChar *newURL;
305
306
newURL = xmlStrdup((const xmlChar *) paths[i]);
307
newURL = xmlStrcat(newURL, (const xmlChar *) "/");
308
newURL = xmlStrcat(newURL, (const xmlChar *) lastsegment);
309
if (newURL != NULL) {
310
ret = defaultEntityLoader((const char *)newURL, ID, ctxt);
311
if (ret != NULL) {
312
if (warning != NULL)
313
ctxt->sax->warning = warning;
314
if (err != NULL)
315
ctxt->sax->error = err;
316
if (load_trace) {
317
fprintf \
318
(stderr,
319
"Loaded URL=\"%s\" ID=\"%s\"\n",
320
newURL,
321
ID ? ID : "(null)");
322
}
323
xmlFree(newURL);
324
return(ret);
325
}
326
xmlFree(newURL);
327
}
328
}
329
if (err != NULL)
330
ctxt->sax->error = err;
331
if (warning != NULL) {
332
ctxt->sax->warning = warning;
333
if (URL != NULL)
334
warning(ctxt, "failed to load external entity \"%s\"\n", URL);
335
else if (ID != NULL)
336
warning(ctxt, "failed to load external entity \"%s\"\n", ID);
337
}
338
return(NULL);
339
}
340
/************************************************************************
341
* *
342
* Memory allocation consumption debugging *
343
* *
344
************************************************************************/
345
346
static void
347
OOM(void)
348
{
349
fprintf(stderr, "Ran out of memory needs > %d bytes\n", maxmem);
350
progresult = XMLLINT_ERR_MEM;
351
}
352
353
static void
354
myFreeFunc(void *mem)
355
{
356
xmlMemFree(mem);
357
}
358
static void *
359
myMallocFunc(size_t size)
360
{
361
void *ret;
362
363
ret = xmlMemMalloc(size);
364
if (ret != NULL) {
365
if (xmlMemUsed() > maxmem) {
366
OOM();
367
xmlMemFree(ret);
368
return (NULL);
369
}
370
}
371
return (ret);
372
}
373
static void *
374
myReallocFunc(void *mem, size_t size)
375
{
376
void *ret;
377
378
ret = xmlMemRealloc(mem, size);
379
if (ret != NULL) {
380
if (xmlMemUsed() > maxmem) {
381
OOM();
382
xmlMemFree(ret);
383
return (NULL);
384
}
385
}
386
return (ret);
387
}
388
static char *
389
myStrdupFunc(const char *str)
390
{
391
char *ret;
392
393
ret = xmlMemoryStrdup(str);
394
if (ret != NULL) {
395
if (xmlMemUsed() > maxmem) {
396
OOM();
397
xmlFree(ret);
398
return (NULL);
399
}
400
}
401
return (ret);
402
}
403
/************************************************************************
404
* *
405
* Internal timing routines to remove the necessity to have *
406
* unix-specific function calls. *
407
* *
408
************************************************************************/
409
410
#ifndef HAVE_GETTIMEOFDAY
411
#ifdef HAVE_SYS_TIMEB_H
412
#ifdef HAVE_SYS_TIME_H
413
#ifdef HAVE_FTIME
414
415
static int
416
my_gettimeofday(struct timeval *tvp, void *tzp)
417
{
418
struct timeb timebuffer;
419
420
ftime(&timebuffer);
421
if (tvp) {
422
tvp->tv_sec = timebuffer.time;
423
tvp->tv_usec = timebuffer.millitm * 1000L;
424
}
425
return (0);
426
}
427
#define HAVE_GETTIMEOFDAY 1
428
#define gettimeofday my_gettimeofday
429
430
#endif /* HAVE_FTIME */
431
#endif /* HAVE_SYS_TIME_H */
432
#endif /* HAVE_SYS_TIMEB_H */
433
#endif /* !HAVE_GETTIMEOFDAY */
434
435
#if defined(HAVE_GETTIMEOFDAY)
436
static struct timeval begin, end;
437
438
/*
439
* startTimer: call where you want to start timing
440
*/
441
static void
442
startTimer(void)
443
{
444
gettimeofday(&begin, NULL);
445
}
446
447
/*
448
* endTimer: call where you want to stop timing and to print out a
449
* message about the timing performed; format is a printf
450
* type argument
451
*/
452
static void XMLCDECL
453
endTimer(const char *fmt, ...)
454
{
455
long msec;
456
va_list ap;
457
458
gettimeofday(&end, NULL);
459
msec = end.tv_sec - begin.tv_sec;
460
msec *= 1000;
461
msec += (end.tv_usec - begin.tv_usec) / 1000;
462
463
#ifndef HAVE_STDARG_H
464
#error "endTimer required stdarg functions"
465
#endif
466
va_start(ap, fmt);
467
vfprintf(stderr, fmt, ap);
468
va_end(ap);
469
470
fprintf(stderr, " took %ld ms\n", msec);
471
}
472
#elif defined(HAVE_TIME_H)
473
/*
474
* No gettimeofday function, so we have to make do with calling clock.
475
* This is obviously less accurate, but there's little we can do about
476
* that.
477
*/
478
#ifndef CLOCKS_PER_SEC
479
#define CLOCKS_PER_SEC 100
480
#endif
481
482
static clock_t begin, end;
483
static void
484
startTimer(void)
485
{
486
begin = clock();
487
}
488
static void XMLCDECL
489
endTimer(const char *fmt, ...)
490
{
491
long msec;
492
va_list ap;
493
494
end = clock();
495
msec = ((end - begin) * 1000) / CLOCKS_PER_SEC;
496
497
#ifndef HAVE_STDARG_H
498
#error "endTimer required stdarg functions"
499
#endif
500
va_start(ap, fmt);
501
vfprintf(stderr, fmt, ap);
502
va_end(ap);
503
fprintf(stderr, " took %ld ms\n", msec);
504
}
505
#else
506
507
/*
508
* We don't have a gettimeofday or time.h, so we just don't do timing
509
*/
510
static void
511
startTimer(void)
512
{
513
/*
514
* Do nothing
515
*/
516
}
517
static void XMLCDECL
518
endTimer(char *format, ...)
519
{
520
/*
521
* We cannot do anything because we don't have a timing function
522
*/
523
#ifdef HAVE_STDARG_H
524
va_list ap;
525
va_start(ap, format);
526
vfprintf(stderr, format, ap);
527
va_end(ap);
528
fprintf(stderr, " was not timed\n");
529
#else
530
/* We don't have gettimeofday, time or stdarg.h, what crazy world is
531
* this ?!
532
*/
533
#endif
534
}
535
#endif
536
/************************************************************************
537
* *
538
* HTML ouput *
539
* *
540
************************************************************************/
541
static char buffer[50000];
542
543
static void
544
xmlHTMLEncodeSend(void) {
545
char *result;
546
547
result = (char *) xmlEncodeEntitiesReentrant(NULL, BAD_CAST buffer);
548
if (result) {
549
xmlGenericError(xmlGenericErrorContext, "%s", result);
550
xmlFree(result);
551
}
552
buffer[0] = 0;
553
}
554
555
/**
556
* xmlHTMLPrintFileInfo:
557
* @input: an xmlParserInputPtr input
558
*
559
* Displays the associated file and line informations for the current input
560
*/
561
562
static void
563
xmlHTMLPrintFileInfo(xmlParserInputPtr input) {
564
int len;
565
xmlGenericError(xmlGenericErrorContext, "<p>");
566
567
len = strlen(buffer);
568
if (input != NULL) {
569
if (input->filename) {
570
snprintf(&buffer[len], sizeof(buffer) - len, "%s:%d: ", input->filename,
571
input->line);
572
} else {
573
snprintf(&buffer[len], sizeof(buffer) - len, "Entity: line %d: ", input->line);
574
}
575
}
576
xmlHTMLEncodeSend();
577
}
578
579
/**
580
* xmlHTMLPrintFileContext:
581
* @input: an xmlParserInputPtr input
582
*
583
* Displays current context within the input content for error tracking
584
*/
585
586
static void
587
xmlHTMLPrintFileContext(xmlParserInputPtr input) {
588
const xmlChar *cur, *base;
589
int len;
590
int n;
591
592
if (input == NULL) return;
593
xmlGenericError(xmlGenericErrorContext, "<pre>\n");
594
cur = input->cur;
595
base = input->base;
596
while ((cur > base) && ((*cur == '\n') || (*cur == '\r'))) {
597
cur--;
598
}
599
n = 0;
600
while ((n++ < 80) && (cur > base) && (*cur != '\n') && (*cur != '\r'))
601
cur--;
602
if ((*cur == '\n') || (*cur == '\r')) cur++;
603
base = cur;
604
n = 0;
605
while ((*cur != 0) && (*cur != '\n') && (*cur != '\r') && (n < 79)) {
606
len = strlen(buffer);
607
snprintf(&buffer[len], sizeof(buffer) - len, "%c",
608
(unsigned char) *cur++);
609
n++;
610
}
611
len = strlen(buffer);
612
snprintf(&buffer[len], sizeof(buffer) - len, "\n");
613
cur = input->cur;
614
while ((*cur == '\n') || (*cur == '\r'))
615
cur--;
616
n = 0;
617
while ((cur != base) && (n++ < 80)) {
618
len = strlen(buffer);
619
snprintf(&buffer[len], sizeof(buffer) - len, " ");
620
base++;
621
}
622
len = strlen(buffer);
623
snprintf(&buffer[len], sizeof(buffer) - len, "^\n");
624
xmlHTMLEncodeSend();
625
xmlGenericError(xmlGenericErrorContext, "</pre>");
626
}
627
628
/**
629
* xmlHTMLError:
630
* @ctx: an XML parser context
631
* @msg: the message to display/transmit
632
* @...: extra parameters for the message display
633
*
634
* Display and format an error messages, gives file, line, position and
635
* extra parameters.
636
*/
637
static void XMLCDECL
638
xmlHTMLError(void *ctx, const char *msg, ...)
639
{
640
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
641
xmlParserInputPtr input;
642
va_list args;
643
int len;
644
645
buffer[0] = 0;
646
input = ctxt->input;
647
if ((input != NULL) && (input->filename == NULL) && (ctxt->inputNr > 1)) {
648
input = ctxt->inputTab[ctxt->inputNr - 2];
649
}
650
651
xmlHTMLPrintFileInfo(input);
652
653
xmlGenericError(xmlGenericErrorContext, "<b>error</b>: ");
654
va_start(args, msg);
655
len = strlen(buffer);
656
vsnprintf(&buffer[len], sizeof(buffer) - len, msg, args);
657
va_end(args);
658
xmlHTMLEncodeSend();
659
xmlGenericError(xmlGenericErrorContext, "</p>\n");
660
661
xmlHTMLPrintFileContext(input);
662
xmlHTMLEncodeSend();
663
}
664
665
/**
666
* xmlHTMLWarning:
667
* @ctx: an XML parser context
668
* @msg: the message to display/transmit
669
* @...: extra parameters for the message display
670
*
671
* Display and format a warning messages, gives file, line, position and
672
* extra parameters.
673
*/
674
static void XMLCDECL
675
xmlHTMLWarning(void *ctx, const char *msg, ...)
676
{
677
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
678
xmlParserInputPtr input;
679
va_list args;
680
int len;
681
682
buffer[0] = 0;
683
input = ctxt->input;
684
if ((input != NULL) && (input->filename == NULL) && (ctxt->inputNr > 1)) {
685
input = ctxt->inputTab[ctxt->inputNr - 2];
686
}
687
688
689
xmlHTMLPrintFileInfo(input);
690
691
xmlGenericError(xmlGenericErrorContext, "<b>warning</b>: ");
692
va_start(args, msg);
693
len = strlen(buffer);
694
vsnprintf(&buffer[len], sizeof(buffer) - len, msg, args);
695
va_end(args);
696
xmlHTMLEncodeSend();
697
xmlGenericError(xmlGenericErrorContext, "</p>\n");
698
699
xmlHTMLPrintFileContext(input);
700
xmlHTMLEncodeSend();
701
}
702
703
/**
704
* xmlHTMLValidityError:
705
* @ctx: an XML parser context
706
* @msg: the message to display/transmit
707
* @...: extra parameters for the message display
708
*
709
* Display and format an validity error messages, gives file,
710
* line, position and extra parameters.
711
*/
712
static void XMLCDECL
713
xmlHTMLValidityError(void *ctx, const char *msg, ...)
714
{
715
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
716
xmlParserInputPtr input;
717
va_list args;
718
int len;
719
720
buffer[0] = 0;
721
input = ctxt->input;
722
if ((input->filename == NULL) && (ctxt->inputNr > 1))
723
input = ctxt->inputTab[ctxt->inputNr - 2];
724
725
xmlHTMLPrintFileInfo(input);
726
727
xmlGenericError(xmlGenericErrorContext, "<b>validity error</b>: ");
728
len = strlen(buffer);
729
va_start(args, msg);
730
vsnprintf(&buffer[len], sizeof(buffer) - len, msg, args);
731
va_end(args);
732
xmlHTMLEncodeSend();
733
xmlGenericError(xmlGenericErrorContext, "</p>\n");
734
735
xmlHTMLPrintFileContext(input);
736
xmlHTMLEncodeSend();
737
progresult = XMLLINT_ERR_VALID;
738
}
739
740
/**
741
* xmlHTMLValidityWarning:
742
* @ctx: an XML parser context
743
* @msg: the message to display/transmit
744
* @...: extra parameters for the message display
745
*
746
* Display and format a validity warning messages, gives file, line,
747
* position and extra parameters.
748
*/
749
static void XMLCDECL
750
xmlHTMLValidityWarning(void *ctx, const char *msg, ...)
751
{
752
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
753
xmlParserInputPtr input;
754
va_list args;
755
int len;
756
757
buffer[0] = 0;
758
input = ctxt->input;
759
if ((input->filename == NULL) && (ctxt->inputNr > 1))
760
input = ctxt->inputTab[ctxt->inputNr - 2];
761
762
xmlHTMLPrintFileInfo(input);
763
764
xmlGenericError(xmlGenericErrorContext, "<b>validity warning</b>: ");
765
va_start(args, msg);
766
len = strlen(buffer);
767
vsnprintf(&buffer[len], sizeof(buffer) - len, msg, args);
768
va_end(args);
769
xmlHTMLEncodeSend();
770
xmlGenericError(xmlGenericErrorContext, "</p>\n");
771
772
xmlHTMLPrintFileContext(input);
773
xmlHTMLEncodeSend();
774
}
775
776
/************************************************************************
777
* *
778
* Shell Interface *
779
* *
780
************************************************************************/
781
#ifdef LIBXML_DEBUG_ENABLED
782
#ifdef LIBXML_XPATH_ENABLED
783
/**
784
* xmlShellReadline:
785
* @prompt: the prompt value
786
*
787
* Read a string
788
*
789
* Returns a pointer to it or NULL on EOF the caller is expected to
790
* free the returned string.
791
*/
792
static char *
793
xmlShellReadline(char *prompt) {
794
#ifdef HAVE_LIBREADLINE
795
char *line_read;
796
797
/* Get a line from the user. */
798
line_read = readline (prompt);
799
800
/* If the line has any text in it, save it on the history. */
801
if (line_read && *line_read)
802
add_history (line_read);
803
804
return (line_read);
805
#else
806
char line_read[501];
807
char *ret;
808
int len;
809
810
if (prompt != NULL)
811
fprintf(stdout, "%s", prompt);
812
if (!fgets(line_read, 500, stdin))
813
return(NULL);
814
line_read[500] = 0;
815
len = strlen(line_read);
816
ret = (char *) malloc(len + 1);
817
if (ret != NULL) {
818
memcpy (ret, line_read, len + 1);
819
}
820
return(ret);
821
#endif
822
}
823
#endif /* LIBXML_XPATH_ENABLED */
824
#endif /* LIBXML_DEBUG_ENABLED */
825
826
/************************************************************************
827
* *
828
* I/O Interfaces *
829
* *
830
************************************************************************/
831
832
static int myRead(FILE *f, char * buf, int len) {
833
return(fread(buf, 1, len, f));
834
}
835
static void myClose(FILE *f) {
836
if (f != stdin) {
837
fclose(f);
838
}
839
}
840
841
/************************************************************************
842
* *
843
* SAX based tests *
844
* *
845
************************************************************************/
846
847
/*
848
* empty SAX block
849
*/
850
static xmlSAXHandler emptySAXHandlerStruct = {
851
NULL, /* internalSubset */
852
NULL, /* isStandalone */
853
NULL, /* hasInternalSubset */
854
NULL, /* hasExternalSubset */
855
NULL, /* resolveEntity */
856
NULL, /* getEntity */
857
NULL, /* entityDecl */
858
NULL, /* notationDecl */
859
NULL, /* attributeDecl */
860
NULL, /* elementDecl */
861
NULL, /* unparsedEntityDecl */
862
NULL, /* setDocumentLocator */
863
NULL, /* startDocument */
864
NULL, /* endDocument */
865
NULL, /* startElement */
866
NULL, /* endElement */
867
NULL, /* reference */
868
NULL, /* characters */
869
NULL, /* ignorableWhitespace */
870
NULL, /* processingInstruction */
871
NULL, /* comment */
872
NULL, /* xmlParserWarning */
873
NULL, /* xmlParserError */
874
NULL, /* xmlParserError */
875
NULL, /* getParameterEntity */
876
NULL, /* cdataBlock; */
877
NULL, /* externalSubset; */
878
XML_SAX2_MAGIC,
879
NULL,
880
NULL, /* startElementNs */
881
NULL, /* endElementNs */
882
NULL /* xmlStructuredErrorFunc */
883
};
884
885
static xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;
886
extern xmlSAXHandlerPtr debugSAXHandler;
887
static int callbacks;
888
889
/**
890
* isStandaloneDebug:
891
* @ctxt: An XML parser context
892
*
893
* Is this document tagged standalone ?
894
*
895
* Returns 1 if true
896
*/
897
static int
898
isStandaloneDebug(void *ctx ATTRIBUTE_UNUSED)
899
{
900
callbacks++;
901
if (noout)
902
return(0);
903
fprintf(stdout, "SAX.isStandalone()\n");
904
return(0);
905
}
906
907
/**
908
* hasInternalSubsetDebug:
909
* @ctxt: An XML parser context
910
*
911
* Does this document has an internal subset
912
*
913
* Returns 1 if true
914
*/
915
static int
916
hasInternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
917
{
918
callbacks++;
919
if (noout)
920
return(0);
921
fprintf(stdout, "SAX.hasInternalSubset()\n");
922
return(0);
923
}
924
925
/**
926
* hasExternalSubsetDebug:
927
* @ctxt: An XML parser context
928
*
929
* Does this document has an external subset
930
*
931
* Returns 1 if true
932
*/
933
static int
934
hasExternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
935
{
936
callbacks++;
937
if (noout)
938
return(0);
939
fprintf(stdout, "SAX.hasExternalSubset()\n");
940
return(0);
941
}
942
943
/**
944
* internalSubsetDebug:
945
* @ctxt: An XML parser context
946
*
947
* Does this document has an internal subset
948
*/
949
static void
950
internalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
951
const xmlChar *ExternalID, const xmlChar *SystemID)
952
{
953
callbacks++;
954
if (noout)
955
return;
956
fprintf(stdout, "SAX.internalSubset(%s,", name);
957
if (ExternalID == NULL)
958
fprintf(stdout, " ,");
959
else
960
fprintf(stdout, " %s,", ExternalID);
961
if (SystemID == NULL)
962
fprintf(stdout, " )\n");
963
else
964
fprintf(stdout, " %s)\n", SystemID);
965
}
966
967
/**
968
* externalSubsetDebug:
969
* @ctxt: An XML parser context
970
*
971
* Does this document has an external subset
972
*/
973
static void
974
externalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
975
const xmlChar *ExternalID, const xmlChar *SystemID)
976
{
977
callbacks++;
978
if (noout)
979
return;
980
fprintf(stdout, "SAX.externalSubset(%s,", name);
981
if (ExternalID == NULL)
982
fprintf(stdout, " ,");
983
else
984
fprintf(stdout, " %s,", ExternalID);
985
if (SystemID == NULL)
986
fprintf(stdout, " )\n");
987
else
988
fprintf(stdout, " %s)\n", SystemID);
989
}
990
991
/**
992
* resolveEntityDebug:
993
* @ctxt: An XML parser context
994
* @publicId: The public ID of the entity
995
* @systemId: The system ID of the entity
996
*
997
* Special entity resolver, better left to the parser, it has
998
* more context than the application layer.
999
* The default behaviour is to NOT resolve the entities, in that case
1000
* the ENTITY_REF nodes are built in the structure (and the parameter
1001
* values).
1002
*
1003
* Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
1004
*/
1005
static xmlParserInputPtr
1006
resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId)
1007
{
1008
callbacks++;
1009
if (noout)
1010
return(NULL);
1011
/* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
1012
1013
1014
fprintf(stdout, "SAX.resolveEntity(");
1015
if (publicId != NULL)
1016
fprintf(stdout, "%s", (char *)publicId);
1017
else
1018
fprintf(stdout, " ");
1019
if (systemId != NULL)
1020
fprintf(stdout, ", %s)\n", (char *)systemId);
1021
else
1022
fprintf(stdout, ", )\n");
1023
return(NULL);
1024
}
1025
1026
/**
1027
* getEntityDebug:
1028
* @ctxt: An XML parser context
1029
* @name: The entity name
1030
*
1031
* Get an entity by name
1032
*
1033
* Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
1034
*/
1035
static xmlEntityPtr
1036
getEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
1037
{
1038
callbacks++;
1039
if (noout)
1040
return(NULL);
1041
fprintf(stdout, "SAX.getEntity(%s)\n", name);
1042
return(NULL);
1043
}
1044
1045
/**
1046
* getParameterEntityDebug:
1047
* @ctxt: An XML parser context
1048
* @name: The entity name
1049
*
1050
* Get a parameter entity by name
1051
*
1052
* Returns the xmlParserInputPtr
1053
*/
1054
static xmlEntityPtr
1055
getParameterEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
1056
{
1057
callbacks++;
1058
if (noout)
1059
return(NULL);
1060
fprintf(stdout, "SAX.getParameterEntity(%s)\n", name);
1061
return(NULL);
1062
}
1063
1064
1065
/**
1066
* entityDeclDebug:
1067
* @ctxt: An XML parser context
1068
* @name: the entity name
1069
* @type: the entity type
1070
* @publicId: The public ID of the entity
1071
* @systemId: The system ID of the entity
1072
* @content: the entity value (without processing).
1073
*
1074
* An entity definition has been parsed
1075
*/
1076
static void
1077
entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
1078
const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
1079
{
1080
const xmlChar *nullstr = BAD_CAST "(null)";
1081
/* not all libraries handle printing null pointers nicely */
1082
if (publicId == NULL)
1083
publicId = nullstr;
1084
if (systemId == NULL)
1085
systemId = nullstr;
1086
if (content == NULL)
1087
content = (xmlChar *)nullstr;
1088
callbacks++;
1089
if (noout)
1090
return;
1091
fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
1092
name, type, publicId, systemId, content);
1093
}
1094
1095
/**
1096
* attributeDeclDebug:
1097
* @ctxt: An XML parser context
1098
* @name: the attribute name
1099
* @type: the attribute type
1100
*
1101
* An attribute definition has been parsed
1102
*/
1103
static void
1104
attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar * elem,
1105
const xmlChar * name, int type, int def,
1106
const xmlChar * defaultValue, xmlEnumerationPtr tree)
1107
{
1108
callbacks++;
1109
if (noout)
1110
return;
1111
if (defaultValue == NULL)
1112
fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, NULL, ...)\n",
1113
elem, name, type, def);
1114
else
1115
fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
1116
elem, name, type, def, defaultValue);
1117
xmlFreeEnumeration(tree);
1118
}
1119
1120
/**
1121
* elementDeclDebug:
1122
* @ctxt: An XML parser context
1123
* @name: the element name
1124
* @type: the element type
1125
* @content: the element value (without processing).
1126
*
1127
* An element definition has been parsed
1128
*/
1129
static void
1130
elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
1131
xmlElementContentPtr content ATTRIBUTE_UNUSED)
1132
{
1133
callbacks++;
1134
if (noout)
1135
return;
1136
fprintf(stdout, "SAX.elementDecl(%s, %d, ...)\n",
1137
name, type);
1138
}
1139
1140
/**
1141
* notationDeclDebug:
1142
* @ctxt: An XML parser context
1143
* @name: The name of the notation
1144
* @publicId: The public ID of the entity
1145
* @systemId: The system ID of the entity
1146
*
1147
* What to do when a notation declaration has been parsed.
1148
*/
1149
static void
1150
notationDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
1151
const xmlChar *publicId, const xmlChar *systemId)
1152
{
1153
callbacks++;
1154
if (noout)
1155
return;
1156
fprintf(stdout, "SAX.notationDecl(%s, %s, %s)\n",
1157
(char *) name, (char *) publicId, (char *) systemId);
1158
}
1159
1160
/**
1161
* unparsedEntityDeclDebug:
1162
* @ctxt: An XML parser context
1163
* @name: The name of the entity
1164
* @publicId: The public ID of the entity
1165
* @systemId: The system ID of the entity
1166
* @notationName: the name of the notation
1167
*
1168
* What to do when an unparsed entity declaration is parsed
1169
*/
1170
static void
1171
unparsedEntityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
1172
const xmlChar *publicId, const xmlChar *systemId,
1173
const xmlChar *notationName)
1174
{
1175
const xmlChar *nullstr = BAD_CAST "(null)";
1176
1177
if (publicId == NULL)
1178
publicId = nullstr;
1179
if (systemId == NULL)
1180
systemId = nullstr;
1181
if (notationName == NULL)
1182
notationName = nullstr;
1183
callbacks++;
1184
if (noout)
1185
return;
1186
fprintf(stdout, "SAX.unparsedEntityDecl(%s, %s, %s, %s)\n",
1187
(char *) name, (char *) publicId, (char *) systemId,
1188
(char *) notationName);
1189
}
1190
1191
/**
1192
* setDocumentLocatorDebug:
1193
* @ctxt: An XML parser context
1194
* @loc: A SAX Locator
1195
*
1196
* Receive the document locator at startup, actually xmlDefaultSAXLocator
1197
* Everything is available on the context, so this is useless in our case.
1198
*/
1199
static void
1200
setDocumentLocatorDebug(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
1201
{
1202
callbacks++;
1203
if (noout)
1204
return;
1205
fprintf(stdout, "SAX.setDocumentLocator()\n");
1206
}
1207
1208
/**
1209
* startDocumentDebug:
1210
* @ctxt: An XML parser context
1211
*
1212
* called when the document start being processed.
1213
*/
1214
static void
1215
startDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
1216
{
1217
callbacks++;
1218
if (noout)
1219
return;
1220
fprintf(stdout, "SAX.startDocument()\n");
1221
}
1222
1223
/**
1224
* endDocumentDebug:
1225
* @ctxt: An XML parser context
1226
*
1227
* called when the document end has been detected.
1228
*/
1229
static void
1230
endDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
1231
{
1232
callbacks++;
1233
if (noout)
1234
return;
1235
fprintf(stdout, "SAX.endDocument()\n");
1236
}
1237
1238
/**
1239
* startElementDebug:
1240
* @ctxt: An XML parser context
1241
* @name: The element name
1242
*
1243
* called when an opening tag has been processed.
1244
*/
1245
static void
1246
startElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, const xmlChar **atts)
1247
{
1248
int i;
1249
1250
callbacks++;
1251
if (noout)
1252
return;
1253
fprintf(stdout, "SAX.startElement(%s", (char *) name);
1254
if (atts != NULL) {
1255
for (i = 0;(atts[i] != NULL);i++) {
1256
fprintf(stdout, ", %s='", atts[i++]);
1257
if (atts[i] != NULL)
1258
fprintf(stdout, "%s'", atts[i]);
1259
}
1260
}
1261
fprintf(stdout, ")\n");
1262
}
1263
1264
/**
1265
* endElementDebug:
1266
* @ctxt: An XML parser context
1267
* @name: The element name
1268
*
1269
* called when the end of an element has been detected.
1270
*/
1271
static void
1272
endElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
1273
{
1274
callbacks++;
1275
if (noout)
1276
return;
1277
fprintf(stdout, "SAX.endElement(%s)\n", (char *) name);
1278
}
1279
1280
/**
1281
* charactersDebug:
1282
* @ctxt: An XML parser context
1283
* @ch: a xmlChar string
1284
* @len: the number of xmlChar
1285
*
1286
* receiving some chars from the parser.
1287
* Question: how much at a time ???
1288
*/
1289
static void
1290
charactersDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
1291
{
1292
char out[40];
1293
int i;
1294
1295
callbacks++;
1296
if (noout)
1297
return;
1298
for (i = 0;(i<len) && (i < 30);i++)
1299
out[i] = ch[i];
1300
out[i] = 0;
1301
1302
fprintf(stdout, "SAX.characters(%s, %d)\n", out, len);
1303
}
1304
1305
/**
1306
* referenceDebug:
1307
* @ctxt: An XML parser context
1308
* @name: The entity name
1309
*
1310
* called when an entity reference is detected.
1311
*/
1312
static void
1313
referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
1314
{
1315
callbacks++;
1316
if (noout)
1317
return;
1318
fprintf(stdout, "SAX.reference(%s)\n", name);
1319
}
1320
1321
/**
1322
* ignorableWhitespaceDebug:
1323
* @ctxt: An XML parser context
1324
* @ch: a xmlChar string
1325
* @start: the first char in the string
1326
* @len: the number of xmlChar
1327
*
1328
* receiving some ignorable whitespaces from the parser.
1329
* Question: how much at a time ???
1330
*/
1331
static void
1332
ignorableWhitespaceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
1333
{
1334
char out[40];
1335
int i;
1336
1337
callbacks++;
1338
if (noout)
1339
return;
1340
for (i = 0;(i<len) && (i < 30);i++)
1341
out[i] = ch[i];
1342
out[i] = 0;
1343
fprintf(stdout, "SAX.ignorableWhitespace(%s, %d)\n", out, len);
1344
}
1345
1346
/**
1347
* processingInstructionDebug:
1348
* @ctxt: An XML parser context
1349
* @target: the target name
1350
* @data: the PI data's
1351
* @len: the number of xmlChar
1352
*
1353
* A processing instruction has been parsed.
1354
*/
1355
static void
1356
processingInstructionDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *target,
1357
const xmlChar *data)
1358
{
1359
callbacks++;
1360
if (noout)
1361
return;
1362
if (data != NULL)
1363
fprintf(stdout, "SAX.processingInstruction(%s, %s)\n",
1364
(char *) target, (char *) data);
1365
else
1366
fprintf(stdout, "SAX.processingInstruction(%s, NULL)\n",
1367
(char *) target);
1368
}
1369
1370
/**
1371
* cdataBlockDebug:
1372
* @ctx: the user data (XML parser context)
1373
* @value: The pcdata content
1374
* @len: the block length
1375
*
1376
* called when a pcdata block has been parsed
1377
*/
1378
static void
1379
cdataBlockDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value, int len)
1380
{
1381
callbacks++;
1382
if (noout)
1383
return;
1384
fprintf(stdout, "SAX.pcdata(%.20s, %d)\n",
1385
(char *) value, len);
1386
}
1387
1388
/**
1389
* commentDebug:
1390
* @ctxt: An XML parser context
1391
* @value: the comment content
1392
*
1393
* A comment has been parsed.
1394
*/
1395
static void
1396
commentDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value)
1397
{
1398
callbacks++;
1399
if (noout)
1400
return;
1401
fprintf(stdout, "SAX.comment(%s)\n", value);
1402
}
1403
1404
/**
1405
* warningDebug:
1406
* @ctxt: An XML parser context
1407
* @msg: the message to display/transmit
1408
* @...: extra parameters for the message display
1409
*
1410
* Display and format a warning messages, gives file, line, position and
1411
* extra parameters.
1412
*/
1413
static void XMLCDECL
1414
warningDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
1415
{
1416
va_list args;
1417
1418
callbacks++;
1419
if (noout)
1420
return;
1421
va_start(args, msg);
1422
fprintf(stdout, "SAX.warning: ");
1423
vfprintf(stdout, msg, args);
1424
va_end(args);
1425
}
1426
1427
/**
1428
* errorDebug:
1429
* @ctxt: An XML parser context
1430
* @msg: the message to display/transmit
1431
* @...: extra parameters for the message display
1432
*
1433
* Display and format a error messages, gives file, line, position and
1434
* extra parameters.
1435
*/
1436
static void XMLCDECL
1437
errorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
1438
{
1439
va_list args;
1440
1441
callbacks++;
1442
if (noout)
1443
return;
1444
va_start(args, msg);
1445
fprintf(stdout, "SAX.error: ");
1446
vfprintf(stdout, msg, args);
1447
va_end(args);
1448
}
1449
1450
/**
1451
* fatalErrorDebug:
1452
* @ctxt: An XML parser context
1453
* @msg: the message to display/transmit
1454
* @...: extra parameters for the message display
1455
*
1456
* Display and format a fatalError messages, gives file, line, position and
1457
* extra parameters.
1458
*/
1459
static void XMLCDECL
1460
fatalErrorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
1461
{
1462
va_list args;
1463
1464
callbacks++;
1465
if (noout)
1466
return;
1467
va_start(args, msg);
1468
fprintf(stdout, "SAX.fatalError: ");
1469
vfprintf(stdout, msg, args);
1470
va_end(args);
1471
}
1472
1473
static xmlSAXHandler debugSAXHandlerStruct = {
1474
internalSubsetDebug,
1475
isStandaloneDebug,
1476
hasInternalSubsetDebug,
1477
hasExternalSubsetDebug,
1478
resolveEntityDebug,
1479
getEntityDebug,
1480
entityDeclDebug,
1481
notationDeclDebug,
1482
attributeDeclDebug,
1483
elementDeclDebug,
1484
unparsedEntityDeclDebug,
1485
setDocumentLocatorDebug,
1486
startDocumentDebug,
1487
endDocumentDebug,
1488
startElementDebug,
1489
endElementDebug,
1490
referenceDebug,
1491
charactersDebug,
1492
ignorableWhitespaceDebug,
1493
processingInstructionDebug,
1494
commentDebug,
1495
warningDebug,
1496
errorDebug,
1497
fatalErrorDebug,
1498
getParameterEntityDebug,
1499
cdataBlockDebug,
1500
externalSubsetDebug,
1501
1,
1502
NULL,
1503
NULL,
1504
NULL,
1505
NULL
1506
};
1507
1508
xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct;
1509
1510
/*
1511
* SAX2 specific callbacks
1512
*/
1513
/**
1514
* startElementNsDebug:
1515
* @ctxt: An XML parser context
1516
* @name: The element name
1517
*
1518
* called when an opening tag has been processed.
1519
*/
1520
static void
1521
startElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
1522
const xmlChar *localname,
1523
const xmlChar *prefix,
1524
const xmlChar *URI,
1525
int nb_namespaces,
1526
const xmlChar **namespaces,
1527
int nb_attributes,
1528
int nb_defaulted,
1529
const xmlChar **attributes)
1530
{
1531
int i;
1532
1533
callbacks++;
1534
if (noout)
1535
return;
1536
fprintf(stdout, "SAX.startElementNs(%s", (char *) localname);
1537
if (prefix == NULL)
1538
fprintf(stdout, ", NULL");
1539
else
1540
fprintf(stdout, ", %s", (char *) prefix);
1541
if (URI == NULL)
1542
fprintf(stdout, ", NULL");
1543
else
1544
fprintf(stdout, ", '%s'", (char *) URI);
1545
fprintf(stdout, ", %d", nb_namespaces);
1546
1547
if (namespaces != NULL) {
1548
for (i = 0;i < nb_namespaces * 2;i++) {
1549
fprintf(stdout, ", xmlns");
1550
if (namespaces[i] != NULL)
1551
fprintf(stdout, ":%s", namespaces[i]);
1552
i++;
1553
fprintf(stdout, "='%s'", namespaces[i]);
1554
}
1555
}
1556
fprintf(stdout, ", %d, %d", nb_attributes, nb_defaulted);
1557
if (attributes != NULL) {
1558
for (i = 0;i < nb_attributes * 5;i += 5) {
1559
if (attributes[i + 1] != NULL)
1560
fprintf(stdout, ", %s:%s='", attributes[i + 1], attributes[i]);
1561
else
1562
fprintf(stdout, ", %s='", attributes[i]);
1563
fprintf(stdout, "%.4s...', %d", attributes[i + 3],
1564
(int)(attributes[i + 4] - attributes[i + 3]));
1565
}
1566
}
1567
fprintf(stdout, ")\n");
1568
}
1569
1570
/**
1571
* endElementDebug:
1572
* @ctxt: An XML parser context
1573
* @name: The element name
1574
*
1575
* called when the end of an element has been detected.
1576
*/
1577
static void
1578
endElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
1579
const xmlChar *localname,
1580
const xmlChar *prefix,
1581
const xmlChar *URI)
1582
{
1583
callbacks++;
1584
if (noout)
1585
return;
1586
fprintf(stdout, "SAX.endElementNs(%s", (char *) localname);
1587
if (prefix == NULL)
1588
fprintf(stdout, ", NULL");
1589
else
1590
fprintf(stdout, ", %s", (char *) prefix);
1591
if (URI == NULL)
1592
fprintf(stdout, ", NULL)\n");
1593
else
1594
fprintf(stdout, ", '%s')\n", (char *) URI);
1595
}
1596
1597
static xmlSAXHandler debugSAX2HandlerStruct = {
1598
internalSubsetDebug,
1599
isStandaloneDebug,
1600
hasInternalSubsetDebug,
1601
hasExternalSubsetDebug,
1602
resolveEntityDebug,
1603
getEntityDebug,
1604
entityDeclDebug,
1605
notationDeclDebug,
1606
attributeDeclDebug,
1607
elementDeclDebug,
1608
unparsedEntityDeclDebug,
1609
setDocumentLocatorDebug,
1610
startDocumentDebug,
1611
endDocumentDebug,
1612
NULL,
1613
NULL,
1614
referenceDebug,
1615
charactersDebug,
1616
ignorableWhitespaceDebug,
1617
processingInstructionDebug,
1618
commentDebug,
1619
warningDebug,
1620
errorDebug,
1621
fatalErrorDebug,
1622
getParameterEntityDebug,
1623
cdataBlockDebug,
1624
externalSubsetDebug,
1625
XML_SAX2_MAGIC,
1626
NULL,
1627
startElementNsDebug,
1628
endElementNsDebug,
1629
NULL
1630
};
1631
1632
static xmlSAXHandlerPtr debugSAX2Handler = &debugSAX2HandlerStruct;
1633
1634
static void
1635
testSAX(const char *filename) {
1636
xmlSAXHandlerPtr handler;
1637
const char *user_data = "user_data"; /* mostly for debugging */
1638
xmlParserInputBufferPtr buf = NULL;
1639
xmlParserInputPtr inputStream;
1640
xmlParserCtxtPtr ctxt = NULL;
1641
xmlSAXHandlerPtr old_sax = NULL;
1642
1643
callbacks = 0;
1644
1645
if (noout) {
1646
handler = emptySAXHandler;
1647
#ifdef LIBXML_SAX1_ENABLED
1648
} else if (sax1) {
1649
handler = debugSAXHandler;
1650
#endif
1651
} else {
1652
handler = debugSAX2Handler;
1653
}
1654
1655
/*
1656
* it's not the simplest code but the most generic in term of I/O
1657
*/
1658
buf = xmlParserInputBufferCreateFilename(filename, XML_CHAR_ENCODING_NONE);
1659
if (buf == NULL) {
1660
goto error;
1661
}
1662
1663
#ifdef LIBXML_SCHEMAS_ENABLED
1664
if (wxschemas != NULL) {
1665
int ret;
1666
xmlSchemaValidCtxtPtr vctxt;
1667
1668
vctxt = xmlSchemaNewValidCtxt(wxschemas);
1669
xmlSchemaSetValidErrors(vctxt,
1670
(xmlSchemaValidityErrorFunc) fprintf,
1671
(xmlSchemaValidityWarningFunc) fprintf,
1672
stderr);
1673
xmlSchemaValidateSetFilename(vctxt, filename);
1674
1675
ret = xmlSchemaValidateStream(vctxt, buf, 0, handler,
1676
(void *)user_data);
1677
if (repeat == 0) {
1678
if (ret == 0) {
1679
fprintf(stderr, "%s validates\n", filename);
1680
} else if (ret > 0) {
1681
fprintf(stderr, "%s fails to validate\n", filename);
1682
progresult = XMLLINT_ERR_VALID;
1683
} else {
1684
fprintf(stderr, "%s validation generated an internal error\n",
1685
filename);
1686
progresult = XMLLINT_ERR_VALID;
1687
}
1688
}
1689
xmlSchemaFreeValidCtxt(vctxt);
1690
} else
1691
#endif
1692
{
1693
/*
1694
* Create the parser context amd hook the input
1695
*/
1696
ctxt = xmlNewParserCtxt();
1697
if (ctxt == NULL) {
1698
xmlFreeParserInputBuffer(buf);
1699
goto error;
1700
}
1701
old_sax = ctxt->sax;
1702
ctxt->sax = handler;
1703
ctxt->userData = (void *) user_data;
1704
inputStream = xmlNewIOInputStream(ctxt, buf, XML_CHAR_ENCODING_NONE);
1705
if (inputStream == NULL) {
1706
xmlFreeParserInputBuffer(buf);
1707
goto error;
1708
}
1709
inputPush(ctxt, inputStream);
1710
1711
/* do the parsing */
1712
xmlParseDocument(ctxt);
1713
1714
if (ctxt->myDoc != NULL) {
1715
fprintf(stderr, "SAX generated a doc !\n");
1716
xmlFreeDoc(ctxt->myDoc);
1717
ctxt->myDoc = NULL;
1718
}
1719
}
1720
1721
error:
1722
if (ctxt != NULL) {
1723
ctxt->sax = old_sax;
1724
xmlFreeParserCtxt(ctxt);
1725
}
1726
}
1727
1728
/************************************************************************
1729
* *
1730
* Stream Test processing *
1731
* *
1732
************************************************************************/
1733
#ifdef LIBXML_READER_ENABLED
1734
static void processNode(xmlTextReaderPtr reader) {
1735
const xmlChar *name, *value;
1736
int type, empty;
1737
1738
type = xmlTextReaderNodeType(reader);
1739
empty = xmlTextReaderIsEmptyElement(reader);
1740
1741
if (debug) {
1742
name = xmlTextReaderConstName(reader);
1743
if (name == NULL)
1744
name = BAD_CAST "--";
1745
1746
value = xmlTextReaderConstValue(reader);
1747
1748
1749
printf("%d %d %s %d %d",
1750
xmlTextReaderDepth(reader),
1751
type,
1752
name,
1753
empty,
1754
xmlTextReaderHasValue(reader));
1755
if (value == NULL)
1756
printf("\n");
1757
else {
1758
printf(" %s\n", value);
1759
}
1760
}
1761
#ifdef LIBXML_PATTERN_ENABLED
1762
if (patternc) {
1763
xmlChar *path = NULL;
1764
int match = -1;
1765
1766
if (type == XML_READER_TYPE_ELEMENT) {
1767
/* do the check only on element start */
1768
match = xmlPatternMatch(patternc, xmlTextReaderCurrentNode(reader));
1769
1770
if (match) {
1771
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
1772
path = xmlGetNodePath(xmlTextReaderCurrentNode(reader));
1773
printf("Node %s matches pattern %s\n", path, pattern);
1774
#else
1775
printf("Node %s matches pattern %s\n",
1776
xmlTextReaderConstName(reader), pattern);
1777
#endif
1778
}
1779
}
1780
if (patstream != NULL) {
1781
int ret;
1782
1783
if (type == XML_READER_TYPE_ELEMENT) {
1784
ret = xmlStreamPush(patstream,
1785
xmlTextReaderConstLocalName(reader),
1786
xmlTextReaderConstNamespaceUri(reader));
1787
if (ret < 0) {
1788
fprintf(stderr, "xmlStreamPush() failure\n");
1789
xmlFreeStreamCtxt(patstream);
1790
patstream = NULL;
1791
} else if (ret != match) {
1792
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
1793
if (path == NULL) {
1794
path = xmlGetNodePath(
1795
xmlTextReaderCurrentNode(reader));
1796
}
1797
#endif
1798
fprintf(stderr,
1799
"xmlPatternMatch and xmlStreamPush disagree\n");
1800
if (path != NULL)
1801
fprintf(stderr, " pattern %s node %s\n",
1802
pattern, path);
1803
else
1804
fprintf(stderr, " pattern %s node %s\n",
1805
pattern, xmlTextReaderConstName(reader));
1806
}
1807
1808
}
1809
if ((type == XML_READER_TYPE_END_ELEMENT) ||
1810
((type == XML_READER_TYPE_ELEMENT) && (empty))) {
1811
ret = xmlStreamPop(patstream);
1812
if (ret < 0) {
1813
fprintf(stderr, "xmlStreamPop() failure\n");
1814
xmlFreeStreamCtxt(patstream);
1815
patstream = NULL;
1816
}
1817
}
1818
}
1819
if (path != NULL)
1820
xmlFree(path);
1821
}
1822
#endif
1823
}
1824
1825
static void streamFile(char *filename) {
1826
xmlTextReaderPtr reader;
1827
int ret;
1828
#ifdef HAVE_MMAP
1829
int fd = -1;
1830
struct stat info;
1831
const char *base = NULL;
1832
xmlParserInputBufferPtr input = NULL;
1833
1834
if (memory) {
1835
if (stat(filename, &info) < 0)
1836
return;
1837
if ((fd = open(filename, O_RDONLY)) < 0)
1838
return;
1839
base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
1840
if (base == (void *) MAP_FAILED)
1841
return;
1842
1843
reader = xmlReaderForMemory(base, info.st_size, filename,
1844
NULL, options);
1845
} else
1846
#endif
1847
reader = xmlReaderForFile(filename, NULL, options);
1848
#ifdef LIBXML_PATTERN_ENABLED
1849
if (pattern != NULL) {
1850
patternc = xmlPatterncompile((const xmlChar *) pattern, NULL, 0, NULL);
1851
if (patternc == NULL) {
1852
xmlGenericError(xmlGenericErrorContext,
1853
"Pattern %s failed to compile\n", pattern);
1854
progresult = XMLLINT_ERR_SCHEMAPAT;
1855
pattern = NULL;
1856
}
1857
}
1858
if (patternc != NULL) {
1859
patstream = xmlPatternGetStreamCtxt(patternc);
1860
if (patstream != NULL) {
1861
ret = xmlStreamPush(patstream, NULL, NULL);
1862
if (ret < 0) {
1863
fprintf(stderr, "xmlStreamPush() failure\n");
1864
xmlFreeStreamCtxt(patstream);
1865
patstream = NULL;
1866
}
1867
}
1868
}
1869
#endif
1870
1871
1872
if (reader != NULL) {
1873
#ifdef LIBXML_VALID_ENABLED
1874
if (valid)
1875
xmlTextReaderSetParserProp(reader, XML_PARSER_VALIDATE, 1);
1876
else
1877
#endif /* LIBXML_VALID_ENABLED */
1878
if (loaddtd)
1879
xmlTextReaderSetParserProp(reader, XML_PARSER_LOADDTD, 1);
1880
#ifdef LIBXML_SCHEMAS_ENABLED
1881
if (relaxng != NULL) {
1882
if ((timing) && (!repeat)) {
1883
startTimer();
1884
}
1885
ret = xmlTextReaderRelaxNGValidate(reader, relaxng);
1886
if (ret < 0) {
1887
xmlGenericError(xmlGenericErrorContext,
1888
"Relax-NG schema %s failed to compile\n", relaxng);
1889
progresult = XMLLINT_ERR_SCHEMACOMP;
1890
relaxng = NULL;
1891
}
1892
if ((timing) && (!repeat)) {
1893
endTimer("Compiling the schemas");
1894
}
1895
}
1896
if (schema != NULL) {
1897
if ((timing) && (!repeat)) {
1898
startTimer();
1899
}
1900
ret = xmlTextReaderSchemaValidate(reader, schema);
1901
if (ret < 0) {
1902
xmlGenericError(xmlGenericErrorContext,
1903
"XSD schema %s failed to compile\n", schema);
1904
progresult = XMLLINT_ERR_SCHEMACOMP;
1905
schema = NULL;
1906
}
1907
if ((timing) && (!repeat)) {
1908
endTimer("Compiling the schemas");
1909
}
1910
}
1911
#endif
1912
1913
/*
1914
* Process all nodes in sequence
1915
*/
1916
if ((timing) && (!repeat)) {
1917
startTimer();
1918
}
1919
ret = xmlTextReaderRead(reader);
1920
while (ret == 1) {
1921
if ((debug)
1922
#ifdef LIBXML_PATTERN_ENABLED
1923
|| (patternc)
1924
#endif
1925
)
1926
processNode(reader);
1927
ret = xmlTextReaderRead(reader);
1928
}
1929
if ((timing) && (!repeat)) {
1930
#ifdef LIBXML_SCHEMAS_ENABLED
1931
if (relaxng != NULL)
1932
endTimer("Parsing and validating");
1933
else
1934
#endif
1935
#ifdef LIBXML_VALID_ENABLED
1936
if (valid)
1937
endTimer("Parsing and validating");
1938
else
1939
#endif
1940
endTimer("Parsing");
1941
}
1942
1943
#ifdef LIBXML_VALID_ENABLED
1944
if (valid) {
1945
if (xmlTextReaderIsValid(reader) != 1) {
1946
xmlGenericError(xmlGenericErrorContext,
1947
"Document %s does not validate\n", filename);
1948
progresult = XMLLINT_ERR_VALID;
1949
}
1950
}
1951
#endif /* LIBXML_VALID_ENABLED */
1952
#ifdef LIBXML_SCHEMAS_ENABLED
1953
if ((relaxng != NULL) || (schema != NULL)) {
1954
if (xmlTextReaderIsValid(reader) != 1) {
1955
fprintf(stderr, "%s fails to validate\n", filename);
1956
progresult = XMLLINT_ERR_VALID;
1957
} else {
1958
fprintf(stderr, "%s validates\n", filename);
1959
}
1960
}
1961
#endif
1962
/*
1963
* Done, cleanup and status
1964
*/
1965
xmlFreeTextReader(reader);
1966
if (ret != 0) {
1967
fprintf(stderr, "%s : failed to parse\n", filename);
1968
progresult = XMLLINT_ERR_UNCLASS;
1969
}
1970
} else {
1971
fprintf(stderr, "Unable to open %s\n", filename);
1972
progresult = XMLLINT_ERR_UNCLASS;
1973
}
1974
#ifdef LIBXML_PATTERN_ENABLED
1975
if (patstream != NULL) {
1976
xmlFreeStreamCtxt(patstream);
1977
patstream = NULL;
1978
}
1979
#endif
1980
#ifdef HAVE_MMAP
1981
if (memory) {
1982
xmlFreeParserInputBuffer(input);
1983
munmap((char *) base, info.st_size);
1984
close(fd);
1985
}
1986
#endif
1987
}
1988
1989
static void walkDoc(xmlDocPtr doc) {
1990
xmlTextReaderPtr reader;
1991
int ret;
1992
1993
#ifdef LIBXML_PATTERN_ENABLED
1994
xmlNodePtr root;
1995
const xmlChar *namespaces[22];
1996
int i;
1997
xmlNsPtr ns;
1998
1999
root = xmlDocGetRootElement(doc);
2000
for (ns = root->nsDef, i = 0;ns != NULL && i < 20;ns=ns->next) {
2001
namespaces[i++] = ns->href;
2002
namespaces[i++] = ns->prefix;
2003
}
2004
namespaces[i++] = NULL;
2005
namespaces[i] = NULL;
2006
2007
if (pattern != NULL) {
2008
patternc = xmlPatterncompile((const xmlChar *) pattern, doc->dict,
2009
0, &namespaces[0]);
2010
if (patternc == NULL) {
2011
xmlGenericError(xmlGenericErrorContext,
2012
"Pattern %s failed to compile\n", pattern);
2013
progresult = XMLLINT_ERR_SCHEMAPAT;
2014
pattern = NULL;
2015
}
2016
}
2017
if (patternc != NULL) {
2018
patstream = xmlPatternGetStreamCtxt(patternc);
2019
if (patstream != NULL) {
2020
ret = xmlStreamPush(patstream, NULL, NULL);
2021
if (ret < 0) {
2022
fprintf(stderr, "xmlStreamPush() failure\n");
2023
xmlFreeStreamCtxt(patstream);
2024
patstream = NULL;
2025
}
2026
}
2027
}
2028
#endif /* LIBXML_PATTERN_ENABLED */
2029
reader = xmlReaderWalker(doc);
2030
if (reader != NULL) {
2031
if ((timing) && (!repeat)) {
2032
startTimer();
2033
}
2034
ret = xmlTextReaderRead(reader);
2035
while (ret == 1) {
2036
if ((debug)
2037
#ifdef LIBXML_PATTERN_ENABLED
2038
|| (patternc)
2039
#endif
2040
)
2041
processNode(reader);
2042
ret = xmlTextReaderRead(reader);
2043
}
2044
if ((timing) && (!repeat)) {
2045
endTimer("walking through the doc");
2046
}
2047
xmlFreeTextReader(reader);
2048
if (ret != 0) {
2049
fprintf(stderr, "failed to walk through the doc\n");
2050
progresult = XMLLINT_ERR_UNCLASS;
2051
}
2052
} else {
2053
fprintf(stderr, "Failed to crate a reader from the document\n");
2054
progresult = XMLLINT_ERR_UNCLASS;
2055
}
2056
#ifdef LIBXML_PATTERN_ENABLED
2057
if (patstream != NULL) {
2058
xmlFreeStreamCtxt(patstream);
2059
patstream = NULL;
2060
}
2061
#endif
2062
}
2063
#endif /* LIBXML_READER_ENABLED */
2064
2065
#ifdef LIBXML_XPATH_ENABLED
2066
/************************************************************************
2067
* *
2068
* XPath Query *
2069
* *
2070
************************************************************************/
2071
2072
static void doXPathDump(xmlXPathObjectPtr cur) {
2073
switch(cur->type) {
2074
case XPATH_NODESET: {
2075
int i;
2076
xmlNodePtr node;
2077
#ifdef LIBXML_OUTPUT_ENABLED
2078
xmlSaveCtxtPtr ctxt;
2079
2080
if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr <= 0)) {
2081
fprintf(stderr, "XPath set is empty\n");
2082
progresult = XMLLINT_ERR_XPATH;
2083
break;
2084
}
2085
ctxt = xmlSaveToFd(1, NULL, 0);
2086
if (ctxt == NULL) {
2087
fprintf(stderr, "Out of memory for XPath\n");
2088
progresult = XMLLINT_ERR_MEM;
2089
return;
2090
}
2091
for (i = 0;i < cur->nodesetval->nodeNr;i++) {
2092
node = cur->nodesetval->nodeTab[i];
2093
xmlSaveTree(ctxt, node);
2094
}
2095
xmlSaveClose(ctxt);
2096
#else
2097
printf("xpath returned %d nodes\n", cur->nodesetval->nodeNr);
2098
#endif
2099
break;
2100
}
2101
case XPATH_BOOLEAN:
2102
if (cur->boolval) printf("true");
2103
else printf("false");
2104
break;
2105
case XPATH_NUMBER:
2106
switch (xmlXPathIsInf(cur->floatval)) {
2107
case 1:
2108
printf("Infinity");
2109
break;
2110
case -1:
2111
printf("-Infinity");
2112
break;
2113
default:
2114
if (xmlXPathIsNaN(cur->floatval)) {
2115
printf("NaN");
2116
} else {
2117
printf("%0g", cur->floatval);
2118
}
2119
}
2120
break;
2121
case XPATH_STRING:
2122
printf("%s", (const char *) cur->stringval);
2123
break;
2124
case XPATH_UNDEFINED:
2125
fprintf(stderr, "XPath Object is uninitialized\n");
2126
progresult = XMLLINT_ERR_XPATH;
2127
break;
2128
default:
2129
fprintf(stderr, "XPath object of unexpected type\n");
2130
progresult = XMLLINT_ERR_XPATH;
2131
break;
2132
}
2133
}
2134
2135
static void doXPathQuery(xmlDocPtr doc, const char *query) {
2136
xmlXPathContextPtr ctxt;
2137
xmlXPathObjectPtr res;
2138
2139
ctxt = xmlXPathNewContext(doc);
2140
if (ctxt == NULL) {
2141
fprintf(stderr, "Out of memory for XPath\n");
2142
progresult = XMLLINT_ERR_MEM;
2143
return;
2144
}
2145
ctxt->node = (xmlNodePtr) doc;
2146
res = xmlXPathEval(BAD_CAST query, ctxt);
2147
xmlXPathFreeContext(ctxt);
2148
2149
if (res == NULL) {
2150
fprintf(stderr, "XPath evaluation failure\n");
2151
progresult = XMLLINT_ERR_XPATH;
2152
return;
2153
}
2154
doXPathDump(res);
2155
xmlXPathFreeObject(res);
2156
}
2157
#endif /* LIBXML_XPATH_ENABLED */
2158
2159
/************************************************************************
2160
* *
2161
* Tree Test processing *
2162
* *
2163
************************************************************************/
2164
static void parseAndPrintFile(char *filename, xmlParserCtxtPtr rectxt) {
2165
xmlDocPtr doc = NULL;
2166
#ifdef LIBXML_TREE_ENABLED
2167
xmlDocPtr tmp;
2168
#endif /* LIBXML_TREE_ENABLED */
2169
2170
if ((timing) && (!repeat))
2171
startTimer();
2172
2173
2174
#ifdef LIBXML_TREE_ENABLED
2175
if (filename == NULL) {
2176
if (generate) {
2177
xmlNodePtr n;
2178
2179
doc = xmlNewDoc(BAD_CAST "1.0");
2180
n = xmlNewDocNode(doc, NULL, BAD_CAST "info", NULL);
2181
xmlNodeSetContent(n, BAD_CAST "abc");
2182
xmlDocSetRootElement(doc, n);
2183
}
2184
}
2185
#endif /* LIBXML_TREE_ENABLED */
2186
#ifdef LIBXML_HTML_ENABLED
2187
#ifdef LIBXML_PUSH_ENABLED
2188
else if ((html) && (push)) {
2189
FILE *f;
2190
2191
#if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
2192
f = fopen(filename, "rb");
2193
#else
2194
f = fopen(filename, "r");
2195
#endif
2196
if (f != NULL) {
2197
int res;
2198
char chars[4096];
2199
htmlParserCtxtPtr ctxt;
2200
2201
res = fread(chars, 1, 4, f);
2202
if (res > 0) {
2203
ctxt = htmlCreatePushParserCtxt(NULL, NULL,
2204
chars, res, filename, XML_CHAR_ENCODING_NONE);
2205
while ((res = fread(chars, 1, pushsize, f)) > 0) {
2206
htmlParseChunk(ctxt, chars, res, 0);
2207
}
2208
htmlParseChunk(ctxt, chars, 0, 1);
2209
doc = ctxt->myDoc;
2210
htmlFreeParserCtxt(ctxt);
2211
}
2212
fclose(f);
2213
}
2214
}
2215
#endif /* LIBXML_PUSH_ENABLED */
2216
#ifdef HAVE_MMAP
2217
else if ((html) && (memory)) {
2218
int fd;
2219
struct stat info;
2220
const char *base;
2221
if (stat(filename, &info) < 0)
2222
return;
2223
if ((fd = open(filename, O_RDONLY)) < 0)
2224
return;
2225
base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
2226
if (base == (void *) MAP_FAILED)
2227
return;
2228
2229
doc = htmlReadMemory((char *) base, info.st_size, filename,
2230
NULL, options);
2231
2232
munmap((char *) base, info.st_size);
2233
close(fd);
2234
}
2235
#endif
2236
else if (html) {
2237
doc = htmlReadFile(filename, NULL, options);
2238
}
2239
#endif /* LIBXML_HTML_ENABLED */
2240
else {
2241
#ifdef LIBXML_PUSH_ENABLED
2242
/*
2243
* build an XML tree from a string;
2244
*/
2245
if (push) {
2246
FILE *f;
2247
2248
/* '-' Usually means stdin -<sven@zen.org> */
2249
if ((filename[0] == '-') && (filename[1] == 0)) {
2250
f = stdin;
2251
} else {
2252
#if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
2253
f = fopen(filename, "rb");
2254
#else
2255
f = fopen(filename, "r");
2256
#endif
2257
}
2258
if (f != NULL) {
2259
int ret;
2260
int res, size = 1024;
2261
char chars[1024];
2262
xmlParserCtxtPtr ctxt;
2263
2264
/* if (repeat) size = 1024; */
2265
res = fread(chars, 1, 4, f);
2266
if (res > 0) {
2267
ctxt = xmlCreatePushParserCtxt(NULL, NULL,
2268
chars, res, filename);
2269
xmlCtxtUseOptions(ctxt, options);
2270
while ((res = fread(chars, 1, size, f)) > 0) {
2271
xmlParseChunk(ctxt, chars, res, 0);
2272
}
2273
xmlParseChunk(ctxt, chars, 0, 1);
2274
doc = ctxt->myDoc;
2275
ret = ctxt->wellFormed;
2276
xmlFreeParserCtxt(ctxt);
2277
if (!ret) {
2278
xmlFreeDoc(doc);
2279
doc = NULL;
2280
}
2281
}
2282
if (f != stdin)
2283
fclose(f);
2284
}
2285
} else
2286
#endif /* LIBXML_PUSH_ENABLED */
2287
if (testIO) {
2288
if ((filename[0] == '-') && (filename[1] == 0)) {
2289
doc = xmlReadFd(0, NULL, NULL, options);
2290
} else {
2291
FILE *f;
2292
2293
#if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
2294
f = fopen(filename, "rb");
2295
#else
2296
f = fopen(filename, "r");
2297
#endif
2298
if (f != NULL) {
2299
if (rectxt == NULL)
2300
doc = xmlReadIO((xmlInputReadCallback) myRead,
2301
(xmlInputCloseCallback) myClose, f,
2302
filename, NULL, options);
2303
else
2304
doc = xmlCtxtReadIO(rectxt,
2305
(xmlInputReadCallback) myRead,
2306
(xmlInputCloseCallback) myClose, f,
2307
filename, NULL, options);
2308
} else
2309
doc = NULL;
2310
}
2311
} else if (htmlout) {
2312
xmlParserCtxtPtr ctxt;
2313
2314
if (rectxt == NULL)
2315
ctxt = xmlNewParserCtxt();
2316
else
2317
ctxt = rectxt;
2318
if (ctxt == NULL) {
2319
doc = NULL;
2320
} else {
2321
ctxt->sax->error = xmlHTMLError;
2322
ctxt->sax->warning = xmlHTMLWarning;
2323
ctxt->vctxt.error = xmlHTMLValidityError;
2324
ctxt->vctxt.warning = xmlHTMLValidityWarning;
2325
2326
doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
2327
2328
if (rectxt == NULL)
2329
xmlFreeParserCtxt(ctxt);
2330
}
2331
#ifdef HAVE_MMAP
2332
} else if (memory) {
2333
int fd;
2334
struct stat info;
2335
const char *base;
2336
if (stat(filename, &info) < 0)
2337
return;
2338
if ((fd = open(filename, O_RDONLY)) < 0)
2339
return;
2340
base = mmap(NULL, info.st_size, PROT_READ, MAP_SHARED, fd, 0) ;
2341
if (base == (void *) MAP_FAILED) {
2342
fprintf(stderr, "mmap failure for file %s\n", filename);
2343
progresult = XMLLINT_ERR_RDFILE;
2344
return;
2345
}
2346
2347
if (rectxt == NULL)
2348
doc = xmlReadMemory((char *) base, info.st_size,
2349
filename, NULL, options);
2350
else
2351
doc = xmlCtxtReadMemory(rectxt, (char *) base, info.st_size,
2352
filename, NULL, options);
2353
2354
munmap((char *) base, info.st_size);
2355
close(fd);
2356
#endif
2357
#ifdef LIBXML_VALID_ENABLED
2358
} else if (valid) {
2359
xmlParserCtxtPtr ctxt = NULL;
2360
2361
if (rectxt == NULL)
2362
ctxt = xmlNewParserCtxt();
2363
else
2364
ctxt = rectxt;
2365
if (ctxt == NULL) {
2366
doc = NULL;
2367
} else {
2368
doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
2369
2370
if (ctxt->valid == 0)
2371
progresult = XMLLINT_ERR_RDFILE;
2372
if (rectxt == NULL)
2373
xmlFreeParserCtxt(ctxt);
2374
}
2375
#endif /* LIBXML_VALID_ENABLED */
2376
} else {
2377
if (rectxt != NULL)
2378
doc = xmlCtxtReadFile(rectxt, filename, NULL, options);
2379
else {
2380
#ifdef LIBXML_SAX1_ENABLED
2381
if (sax1)
2382
doc = xmlParseFile(filename);
2383
else
2384
#endif /* LIBXML_SAX1_ENABLED */
2385
doc = xmlReadFile(filename, NULL, options);
2386
}
2387
}
2388
}
2389
2390
/*
2391
* If we don't have a document we might as well give up. Do we
2392
* want an error message here? <sven@zen.org> */
2393
if (doc == NULL) {
2394
progresult = XMLLINT_ERR_UNCLASS;
2395
return;
2396
}
2397
2398
if ((timing) && (!repeat)) {
2399
endTimer("Parsing");
2400
}
2401
2402
/*
2403
* Remove DOCTYPE nodes
2404
*/
2405
if (dropdtd) {
2406
xmlDtdPtr dtd;
2407
2408
dtd = xmlGetIntSubset(doc);
2409
if (dtd != NULL) {
2410
xmlUnlinkNode((xmlNodePtr)dtd);
2411
xmlFreeDtd(dtd);
2412
}
2413
}
2414
2415
#ifdef LIBXML_XINCLUDE_ENABLED
2416
if (xinclude) {
2417
if ((timing) && (!repeat)) {
2418
startTimer();
2419
}
2420
if (xmlXIncludeProcessFlags(doc, options) < 0)
2421
progresult = XMLLINT_ERR_UNCLASS;
2422
if ((timing) && (!repeat)) {
2423
endTimer("Xinclude processing");
2424
}
2425
}
2426
#endif
2427
2428
#ifdef LIBXML_XPATH_ENABLED
2429
if (xpathquery != NULL) {
2430
doXPathQuery(doc, xpathquery);
2431
}
2432
#endif
2433
2434
#ifdef LIBXML_DEBUG_ENABLED
2435
#ifdef LIBXML_XPATH_ENABLED
2436
/*
2437
* shell interaction
2438
*/
2439
if (shell) {
2440
xmlXPathOrderDocElems(doc);
2441
xmlShell(doc, filename, xmlShellReadline, stdout);
2442
}
2443
#endif
2444
#endif
2445
2446
#ifdef LIBXML_TREE_ENABLED
2447
/*
2448
* test intermediate copy if needed.
2449
*/
2450
if (copy) {
2451
tmp = doc;
2452
if (timing) {
2453
startTimer();
2454
}
2455
doc = xmlCopyDoc(doc, 1);
2456
if (timing) {
2457
endTimer("Copying");
2458
}
2459
if (timing) {
2460
startTimer();
2461
}
2462
xmlFreeDoc(tmp);
2463
if (timing) {
2464
endTimer("Freeing original");
2465
}
2466
}
2467
#endif /* LIBXML_TREE_ENABLED */
2468
2469
#ifdef LIBXML_VALID_ENABLED
2470
if ((insert) && (!html)) {
2471
const xmlChar* list[256];
2472
int nb, i;
2473
xmlNodePtr node;
2474
2475
if (doc->children != NULL) {
2476
node = doc->children;
2477
while ((node != NULL) && (node->last == NULL)) node = node->next;
2478
if (node != NULL) {
2479
nb = xmlValidGetValidElements(node->last, NULL, list, 256);
2480
if (nb < 0) {
2481
fprintf(stderr, "could not get valid list of elements\n");
2482
} else if (nb == 0) {
2483
fprintf(stderr, "No element can be inserted under root\n");
2484
} else {
2485
fprintf(stderr, "%d element types can be inserted under root:\n",
2486
nb);
2487
for (i = 0;i < nb;i++) {
2488
fprintf(stderr, "%s\n", (char *) list[i]);
2489
}
2490
}
2491
}
2492
}
2493
}else
2494
#endif /* LIBXML_VALID_ENABLED */
2495
#ifdef LIBXML_READER_ENABLED
2496
if (walker) {
2497
walkDoc(doc);
2498
}
2499
#endif /* LIBXML_READER_ENABLED */
2500
#ifdef LIBXML_OUTPUT_ENABLED
2501
if (noout == 0) {
2502
int ret;
2503
2504
/*
2505
* print it.
2506
*/
2507
#ifdef LIBXML_DEBUG_ENABLED
2508
if (!debug) {
2509
#endif
2510
if ((timing) && (!repeat)) {
2511
startTimer();
2512
}
2513
#ifdef LIBXML_HTML_ENABLED
2514
if ((html) && (!xmlout)) {
2515
if (compress) {
2516
htmlSaveFile(output ? output : "-", doc);
2517
}
2518
else if (encoding != NULL) {
2519
if (format == 1) {
2520
htmlSaveFileFormat(output ? output : "-", doc, encoding, 1);
2521
}
2522
else {
2523
htmlSaveFileFormat(output ? output : "-", doc, encoding, 0);
2524
}
2525
}
2526
else if (format == 1) {
2527
htmlSaveFileFormat(output ? output : "-", doc, NULL, 1);
2528
}
2529
else {
2530
FILE *out;
2531
if (output == NULL)
2532
out = stdout;
2533
else {
2534
out = fopen(output,"wb");
2535
}
2536
if (out != NULL) {
2537
if (htmlDocDump(out, doc) < 0)
2538
progresult = XMLLINT_ERR_OUT;
2539
2540
if (output != NULL)
2541
fclose(out);
2542
} else {
2543
fprintf(stderr, "failed to open %s\n", output);
2544
progresult = XMLLINT_ERR_OUT;
2545
}
2546
}
2547
if ((timing) && (!repeat)) {
2548
endTimer("Saving");
2549
}
2550
} else
2551
#endif
2552
#ifdef LIBXML_C14N_ENABLED
2553
if (canonical) {
2554
xmlChar *result = NULL;
2555
int size;
2556
2557
size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_1_0, NULL, 1, &result);
2558
if (size >= 0) {
2559
if (write(1, result, size) == -1) {
2560
fprintf(stderr, "Can't write data\n");
2561
}
2562
xmlFree(result);
2563
} else {
2564
fprintf(stderr, "Failed to canonicalize\n");
2565
progresult = XMLLINT_ERR_OUT;
2566
}
2567
} else if (canonical) {
2568
xmlChar *result = NULL;
2569
int size;
2570
2571
size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_1_1, NULL, 1, &result);
2572
if (size >= 0) {
2573
if (write(1, result, size) == -1) {
2574
fprintf(stderr, "Can't write data\n");
2575
}
2576
xmlFree(result);
2577
} else {
2578
fprintf(stderr, "Failed to canonicalize\n");
2579
progresult = XMLLINT_ERR_OUT;
2580
}
2581
} else
2582
if (exc_canonical) {
2583
xmlChar *result = NULL;
2584
int size;
2585
2586
size = xmlC14NDocDumpMemory(doc, NULL, XML_C14N_EXCLUSIVE_1_0, NULL, 1, &result);
2587
if (size >= 0) {
2588
if (write(1, result, size) == -1) {
2589
fprintf(stderr, "Can't write data\n");
2590
}
2591
xmlFree(result);
2592
} else {
2593
fprintf(stderr, "Failed to canonicalize\n");
2594
progresult = XMLLINT_ERR_OUT;
2595
}
2596
} else
2597
#endif
2598
#ifdef HAVE_MMAP
2599
if (memory) {
2600
xmlChar *result;
2601
int len;
2602
2603
if (encoding != NULL) {
2604
if (format == 1) {
2605
xmlDocDumpFormatMemoryEnc(doc, &result, &len, encoding, 1);
2606
} else {
2607
xmlDocDumpMemoryEnc(doc, &result, &len, encoding);
2608
}
2609
} else {
2610
if (format == 1)
2611
xmlDocDumpFormatMemory(doc, &result, &len, 1);
2612
else
2613
xmlDocDumpMemory(doc, &result, &len);
2614
}
2615
if (result == NULL) {
2616
fprintf(stderr, "Failed to save\n");
2617
progresult = XMLLINT_ERR_OUT;
2618
} else {
2619
if (write(1, result, len) == -1) {
2620
fprintf(stderr, "Can't write data\n");
2621
}
2622
xmlFree(result);
2623
}
2624
2625
} else
2626
#endif /* HAVE_MMAP */
2627
if (compress) {
2628
xmlSaveFile(output ? output : "-", doc);
2629
} else if (oldout) {
2630
if (encoding != NULL) {
2631
if (format == 1) {
2632
ret = xmlSaveFormatFileEnc(output ? output : "-", doc,
2633
encoding, 1);
2634
}
2635
else {
2636
ret = xmlSaveFileEnc(output ? output : "-", doc,
2637
encoding);
2638
}
2639
if (ret < 0) {
2640
fprintf(stderr, "failed save to %s\n",
2641
output ? output : "-");
2642
progresult = XMLLINT_ERR_OUT;
2643
}
2644
} else if (format == 1) {
2645
ret = xmlSaveFormatFile(output ? output : "-", doc, 1);
2646
if (ret < 0) {
2647
fprintf(stderr, "failed save to %s\n",
2648
output ? output : "-");
2649
progresult = XMLLINT_ERR_OUT;
2650
}
2651
} else {
2652
FILE *out;
2653
if (output == NULL)
2654
out = stdout;
2655
else {
2656
out = fopen(output,"wb");
2657
}
2658
if (out != NULL) {
2659
if (xmlDocDump(out, doc) < 0)
2660
progresult = XMLLINT_ERR_OUT;
2661
2662
if (output != NULL)
2663
fclose(out);
2664
} else {
2665
fprintf(stderr, "failed to open %s\n", output);
2666
progresult = XMLLINT_ERR_OUT;
2667
}
2668
}
2669
} else {
2670
xmlSaveCtxtPtr ctxt;
2671
int saveOpts = 0;
2672
2673
if (format == 1)
2674
saveOpts |= XML_SAVE_FORMAT;
2675
else if (format == 2)
2676
saveOpts |= XML_SAVE_WSNONSIG;
2677
2678
#if defined(LIBXML_HTML_ENABLED) || defined(LIBXML_VALID_ENABLED)
2679
if (xmlout)
2680
saveOpts |= XML_SAVE_AS_XML;
2681
#endif
2682
2683
if (output == NULL)
2684
ctxt = xmlSaveToFd(1, encoding, saveOpts);
2685
else
2686
ctxt = xmlSaveToFilename(output, encoding, saveOpts);
2687
2688
if (ctxt != NULL) {
2689
if (xmlSaveDoc(ctxt, doc) < 0) {
2690
fprintf(stderr, "failed save to %s\n",
2691
output ? output : "-");
2692
progresult = XMLLINT_ERR_OUT;
2693
}
2694
xmlSaveClose(ctxt);
2695
} else {
2696
progresult = XMLLINT_ERR_OUT;
2697
}
2698
}
2699
if ((timing) && (!repeat)) {
2700
endTimer("Saving");
2701
}
2702
#ifdef LIBXML_DEBUG_ENABLED
2703
} else {
2704
FILE *out;
2705
if (output == NULL)
2706
out = stdout;
2707
else {
2708
out = fopen(output,"wb");
2709
}
2710
if (out != NULL) {
2711
xmlDebugDumpDocument(out, doc);
2712
2713
if (output != NULL)
2714
fclose(out);
2715
} else {
2716
fprintf(stderr, "failed to open %s\n", output);
2717
progresult = XMLLINT_ERR_OUT;
2718
}
2719
}
2720
#endif
2721
}
2722
#endif /* LIBXML_OUTPUT_ENABLED */
2723
2724
#ifdef LIBXML_VALID_ENABLED
2725
/*
2726
* A posteriori validation test
2727
*/
2728
if ((dtdvalid != NULL) || (dtdvalidfpi != NULL)) {
2729
xmlDtdPtr dtd;
2730
2731
if ((timing) && (!repeat)) {
2732
startTimer();
2733
}
2734
if (dtdvalid != NULL)
2735
dtd = xmlParseDTD(NULL, (const xmlChar *)dtdvalid);
2736
else
2737
dtd = xmlParseDTD((const xmlChar *)dtdvalidfpi, NULL);
2738
if ((timing) && (!repeat)) {
2739
endTimer("Parsing DTD");
2740
}
2741
if (dtd == NULL) {
2742
if (dtdvalid != NULL)
2743
xmlGenericError(xmlGenericErrorContext,
2744
"Could not parse DTD %s\n", dtdvalid);
2745
else
2746
xmlGenericError(xmlGenericErrorContext,
2747
"Could not parse DTD %s\n", dtdvalidfpi);
2748
progresult = XMLLINT_ERR_DTD;
2749
} else {
2750
xmlValidCtxtPtr cvp;
2751
2752
if ((cvp = xmlNewValidCtxt()) == NULL) {
2753
xmlGenericError(xmlGenericErrorContext,
2754
"Couldn't allocate validation context\n");
2755
exit(-1);
2756
}
2757
cvp->userData = (void *) stderr;
2758
cvp->error = (xmlValidityErrorFunc) fprintf;
2759
cvp->warning = (xmlValidityWarningFunc) fprintf;
2760
2761
if ((timing) && (!repeat)) {
2762
startTimer();
2763
}
2764
if (!xmlValidateDtd(cvp, doc, dtd)) {
2765
if (dtdvalid != NULL)
2766
xmlGenericError(xmlGenericErrorContext,
2767
"Document %s does not validate against %s\n",
2768
filename, dtdvalid);
2769
else
2770
xmlGenericError(xmlGenericErrorContext,
2771
"Document %s does not validate against %s\n",
2772
filename, dtdvalidfpi);
2773
progresult = XMLLINT_ERR_VALID;
2774
}
2775
if ((timing) && (!repeat)) {
2776
endTimer("Validating against DTD");
2777
}
2778
xmlFreeValidCtxt(cvp);
2779
xmlFreeDtd(dtd);
2780
}
2781
} else if (postvalid) {
2782
xmlValidCtxtPtr cvp;
2783
2784
if ((cvp = xmlNewValidCtxt()) == NULL) {
2785
xmlGenericError(xmlGenericErrorContext,
2786
"Couldn't allocate validation context\n");
2787
exit(-1);
2788
}
2789
2790
if ((timing) && (!repeat)) {
2791
startTimer();
2792
}
2793
cvp->userData = (void *) stderr;
2794
cvp->error = (xmlValidityErrorFunc) fprintf;
2795
cvp->warning = (xmlValidityWarningFunc) fprintf;
2796
if (!xmlValidateDocument(cvp, doc)) {
2797
xmlGenericError(xmlGenericErrorContext,
2798
"Document %s does not validate\n", filename);
2799
progresult = XMLLINT_ERR_VALID;
2800
}
2801
if ((timing) && (!repeat)) {
2802
endTimer("Validating");
2803
}
2804
xmlFreeValidCtxt(cvp);
2805
}
2806
#endif /* LIBXML_VALID_ENABLED */
2807
#ifdef LIBXML_SCHEMATRON_ENABLED
2808
if (wxschematron != NULL) {
2809
xmlSchematronValidCtxtPtr ctxt;
2810
int ret;
2811
int flag;
2812
2813
if ((timing) && (!repeat)) {
2814
startTimer();
2815
}
2816
2817
if (debug)
2818
flag = XML_SCHEMATRON_OUT_XML;
2819
else
2820
flag = XML_SCHEMATRON_OUT_TEXT;
2821
if (noout)
2822
flag |= XML_SCHEMATRON_OUT_QUIET;
2823
ctxt = xmlSchematronNewValidCtxt(wxschematron, flag);
2824
#if 0
2825
xmlSchematronSetValidErrors(ctxt,
2826
(xmlSchematronValidityErrorFunc) fprintf,
2827
(xmlSchematronValidityWarningFunc) fprintf,
2828
stderr);
2829
#endif
2830
ret = xmlSchematronValidateDoc(ctxt, doc);
2831
if (ret == 0) {
2832
fprintf(stderr, "%s validates\n", filename);
2833
} else if (ret > 0) {
2834
fprintf(stderr, "%s fails to validate\n", filename);
2835
progresult = XMLLINT_ERR_VALID;
2836
} else {
2837
fprintf(stderr, "%s validation generated an internal error\n",
2838
filename);
2839
progresult = XMLLINT_ERR_VALID;
2840
}
2841
xmlSchematronFreeValidCtxt(ctxt);
2842
if ((timing) && (!repeat)) {
2843
endTimer("Validating");
2844
}
2845
}
2846
#endif
2847
#ifdef LIBXML_SCHEMAS_ENABLED
2848
if (relaxngschemas != NULL) {
2849
xmlRelaxNGValidCtxtPtr ctxt;
2850
int ret;
2851
2852
if ((timing) && (!repeat)) {
2853
startTimer();
2854
}
2855
2856
ctxt = xmlRelaxNGNewValidCtxt(relaxngschemas);
2857
xmlRelaxNGSetValidErrors(ctxt,
2858
(xmlRelaxNGValidityErrorFunc) fprintf,
2859
(xmlRelaxNGValidityWarningFunc) fprintf,
2860
stderr);
2861
ret = xmlRelaxNGValidateDoc(ctxt, doc);
2862
if (ret == 0) {
2863
fprintf(stderr, "%s validates\n", filename);
2864
} else if (ret > 0) {
2865
fprintf(stderr, "%s fails to validate\n", filename);
2866
progresult = XMLLINT_ERR_VALID;
2867
} else {
2868
fprintf(stderr, "%s validation generated an internal error\n",
2869
filename);
2870
progresult = XMLLINT_ERR_VALID;
2871
}
2872
xmlRelaxNGFreeValidCtxt(ctxt);
2873
if ((timing) && (!repeat)) {
2874
endTimer("Validating");
2875
}
2876
} else if (wxschemas != NULL) {
2877
xmlSchemaValidCtxtPtr ctxt;
2878
int ret;
2879
2880
if ((timing) && (!repeat)) {
2881
startTimer();
2882
}
2883
2884
ctxt = xmlSchemaNewValidCtxt(wxschemas);
2885
xmlSchemaSetValidErrors(ctxt,
2886
(xmlSchemaValidityErrorFunc) fprintf,
2887
(xmlSchemaValidityWarningFunc) fprintf,
2888
stderr);
2889
ret = xmlSchemaValidateDoc(ctxt, doc);
2890
if (ret == 0) {
2891
fprintf(stderr, "%s validates\n", filename);
2892
} else if (ret > 0) {
2893
fprintf(stderr, "%s fails to validate\n", filename);
2894
progresult = XMLLINT_ERR_VALID;
2895
} else {
2896
fprintf(stderr, "%s validation generated an internal error\n",
2897
filename);
2898
progresult = XMLLINT_ERR_VALID;
2899
}
2900
xmlSchemaFreeValidCtxt(ctxt);
2901
if ((timing) && (!repeat)) {
2902
endTimer("Validating");
2903
}
2904
}
2905
#endif
2906
2907
#ifdef LIBXML_DEBUG_ENABLED
2908
#if defined(LIBXML_HTML_ENABLED) || defined(LIBXML_VALID_ENABLED)
2909
if ((debugent) && (!html))
2910
xmlDebugDumpEntities(stderr, doc);
2911
#endif
2912
#endif
2913
2914
/*
2915
* free it.
2916
*/
2917
if ((timing) && (!repeat)) {
2918
startTimer();
2919
}
2920
xmlFreeDoc(doc);
2921
if ((timing) && (!repeat)) {
2922
endTimer("Freeing");
2923
}
2924
}
2925
2926
/************************************************************************
2927
* *
2928
* Usage and Main *
2929
* *
2930
************************************************************************/
2931
2932
static void showVersion(const char *name) {
2933
fprintf(stderr, "%s: using libxml version %s\n", name, xmlParserVersion);
2934
fprintf(stderr, " compiled with: ");
2935
if (xmlHasFeature(XML_WITH_THREAD)) fprintf(stderr, "Threads ");
2936
if (xmlHasFeature(XML_WITH_TREE)) fprintf(stderr, "Tree ");
2937
if (xmlHasFeature(XML_WITH_OUTPUT)) fprintf(stderr, "Output ");
2938
if (xmlHasFeature(XML_WITH_PUSH)) fprintf(stderr, "Push ");
2939
if (xmlHasFeature(XML_WITH_READER)) fprintf(stderr, "Reader ");
2940
if (xmlHasFeature(XML_WITH_PATTERN)) fprintf(stderr, "Patterns ");
2941
if (xmlHasFeature(XML_WITH_WRITER)) fprintf(stderr, "Writer ");
2942
if (xmlHasFeature(XML_WITH_SAX1)) fprintf(stderr, "SAXv1 ");
2943
if (xmlHasFeature(XML_WITH_FTP)) fprintf(stderr, "FTP ");
2944
if (xmlHasFeature(XML_WITH_HTTP)) fprintf(stderr, "HTTP ");
2945
if (xmlHasFeature(XML_WITH_VALID)) fprintf(stderr, "DTDValid ");
2946
if (xmlHasFeature(XML_WITH_HTML)) fprintf(stderr, "HTML ");
2947
if (xmlHasFeature(XML_WITH_LEGACY)) fprintf(stderr, "Legacy ");
2948
if (xmlHasFeature(XML_WITH_C14N)) fprintf(stderr, "C14N ");
2949
if (xmlHasFeature(XML_WITH_CATALOG)) fprintf(stderr, "Catalog ");
2950
if (xmlHasFeature(XML_WITH_XPATH)) fprintf(stderr, "XPath ");
2951
if (xmlHasFeature(XML_WITH_XPTR)) fprintf(stderr, "XPointer ");
2952
if (xmlHasFeature(XML_WITH_XINCLUDE)) fprintf(stderr, "XInclude ");
2953
if (xmlHasFeature(XML_WITH_ICONV)) fprintf(stderr, "Iconv ");
2954
if (xmlHasFeature(XML_WITH_ISO8859X)) fprintf(stderr, "ISO8859X ");
2955
if (xmlHasFeature(XML_WITH_UNICODE)) fprintf(stderr, "Unicode ");
2956
if (xmlHasFeature(XML_WITH_REGEXP)) fprintf(stderr, "Regexps ");
2957
if (xmlHasFeature(XML_WITH_AUTOMATA)) fprintf(stderr, "Automata ");
2958
if (xmlHasFeature(XML_WITH_EXPR)) fprintf(stderr, "Expr ");
2959
if (xmlHasFeature(XML_WITH_SCHEMAS)) fprintf(stderr, "Schemas ");
2960
if (xmlHasFeature(XML_WITH_SCHEMATRON)) fprintf(stderr, "Schematron ");
2961
if (xmlHasFeature(XML_WITH_MODULES)) fprintf(stderr, "Modules ");
2962
if (xmlHasFeature(XML_WITH_DEBUG)) fprintf(stderr, "Debug ");
2963
if (xmlHasFeature(XML_WITH_DEBUG_MEM)) fprintf(stderr, "MemDebug ");
2964
if (xmlHasFeature(XML_WITH_DEBUG_RUN)) fprintf(stderr, "RunDebug ");
2965
if (xmlHasFeature(XML_WITH_ZLIB)) fprintf(stderr, "Zlib ");
2966
if (xmlHasFeature(XML_WITH_LZMA)) fprintf(stderr, "Lzma ");
2967
fprintf(stderr, "\n");
2968
}
2969
2970
static void usage(const char *name) {
2971
printf("Usage : %s [options] XMLfiles ...\n", name);
2972
#ifdef LIBXML_OUTPUT_ENABLED
2973
printf("\tParse the XML files and output the result of the parsing\n");
2974
#else
2975
printf("\tParse the XML files\n");
2976
#endif /* LIBXML_OUTPUT_ENABLED */
2977
printf("\t--version : display the version of the XML library used\n");
2978
#ifdef LIBXML_DEBUG_ENABLED
2979
printf("\t--debug : dump a debug tree of the in-memory document\n");
2980
printf("\t--shell : run a navigating shell\n");
2981
printf("\t--debugent : debug the entities defined in the document\n");
2982
#else
2983
#ifdef LIBXML_READER_ENABLED
2984
printf("\t--debug : dump the nodes content when using --stream\n");
2985
#endif /* LIBXML_READER_ENABLED */
2986
#endif
2987
#ifdef LIBXML_TREE_ENABLED
2988
printf("\t--copy : used to test the internal copy implementation\n");
2989
#endif /* LIBXML_TREE_ENABLED */
2990
printf("\t--recover : output what was parsable on broken XML documents\n");
2991
printf("\t--huge : remove any internal arbitrary parser limits\n");
2992
printf("\t--noent : substitute entity references by their value\n");
2993
printf("\t--noenc : ignore any encoding specified inside the document\n");
2994
printf("\t--noout : don't output the result tree\n");
2995
printf("\t--path 'paths': provide a set of paths for resources\n");
2996
printf("\t--load-trace : print trace of all external entites loaded\n");
2997
printf("\t--nonet : refuse to fetch DTDs or entities over network\n");
2998
printf("\t--nocompact : do not generate compact text nodes\n");
2999
printf("\t--htmlout : output results as HTML\n");
3000
printf("\t--nowrap : do not put HTML doc wrapper\n");
3001
#ifdef LIBXML_VALID_ENABLED
3002
printf("\t--valid : validate the document in addition to std well-formed check\n");
3003
printf("\t--postvalid : do a posteriori validation, i.e after parsing\n");
3004
printf("\t--dtdvalid URL : do a posteriori validation against a given DTD\n");
3005
printf("\t--dtdvalidfpi FPI : same but name the DTD with a Public Identifier\n");
3006
#endif /* LIBXML_VALID_ENABLED */
3007
printf("\t--timing : print some timings\n");
3008
printf("\t--output file or -o file: save to a given file\n");
3009
printf("\t--repeat : repeat 100 times, for timing or profiling\n");
3010
printf("\t--insert : ad-hoc test for valid insertions\n");
3011
#ifdef LIBXML_OUTPUT_ENABLED
3012
#ifdef HAVE_ZLIB_H
3013
printf("\t--compress : turn on gzip compression of output\n");
3014
#endif
3015
#endif /* LIBXML_OUTPUT_ENABLED */
3016
#ifdef LIBXML_HTML_ENABLED
3017
printf("\t--html : use the HTML parser\n");
3018
printf("\t--xmlout : force to use the XML serializer when using --html\n");
3019
printf("\t--nodefdtd : do not default HTML doctype\n");
3020
#endif
3021
#ifdef LIBXML_PUSH_ENABLED
3022
printf("\t--push : use the push mode of the parser\n");
3023
printf("\t--pushsmall : use the push mode of the parser using tiny increments\n");
3024
#endif /* LIBXML_PUSH_ENABLED */
3025
#ifdef HAVE_MMAP
3026
printf("\t--memory : parse from memory\n");
3027
#endif
3028
printf("\t--maxmem nbbytes : limits memory allocation to nbbytes bytes\n");
3029
printf("\t--nowarning : do not emit warnings from parser/validator\n");
3030
printf("\t--noblanks : drop (ignorable?) blanks spaces\n");
3031
printf("\t--nocdata : replace cdata section with text nodes\n");
3032
#ifdef LIBXML_OUTPUT_ENABLED
3033
printf("\t--format : reformat/reindent the input\n");
3034
printf("\t--encode encoding : output in the given encoding\n");
3035
printf("\t--dropdtd : remove the DOCTYPE of the input docs\n");
3036
printf("\t--pretty STYLE : pretty-print in a particular style\n");
3037
printf("\t 0 Do not pretty print\n");
3038
printf("\t 1 Format the XML content, as --format\n");
3039
printf("\t 2 Add whitespace inside tags, preserving content\n");
3040
#endif /* LIBXML_OUTPUT_ENABLED */
3041
printf("\t--c14n : save in W3C canonical format v1.0 (with comments)\n");
3042
printf("\t--c14n11 : save in W3C canonical format v1.1 (with comments)\n");
3043
printf("\t--exc-c14n : save in W3C exclusive canonical format (with comments)\n");
3044
#ifdef LIBXML_C14N_ENABLED
3045
#endif /* LIBXML_C14N_ENABLED */
3046
printf("\t--nsclean : remove redundant namespace declarations\n");
3047
printf("\t--testIO : test user I/O support\n");
3048
#ifdef LIBXML_CATALOG_ENABLED
3049
printf("\t--catalogs : use SGML catalogs from $SGML_CATALOG_FILES\n");
3050
printf("\t otherwise XML Catalogs starting from \n");
3051
printf("\t %s are activated by default\n", XML_XML_DEFAULT_CATALOG);
3052
printf("\t--nocatalogs: deactivate all catalogs\n");
3053
#endif
3054
printf("\t--auto : generate a small doc on the fly\n");
3055
#ifdef LIBXML_XINCLUDE_ENABLED
3056
printf("\t--xinclude : do XInclude processing\n");
3057
printf("\t--noxincludenode : same but do not generate XInclude nodes\n");
3058
printf("\t--nofixup-base-uris : do not fixup xml:base uris\n");
3059
#endif
3060
printf("\t--loaddtd : fetch external DTD\n");
3061
printf("\t--dtdattr : loaddtd + populate the tree with inherited attributes \n");
3062
#ifdef LIBXML_READER_ENABLED
3063
printf("\t--stream : use the streaming interface to process very large files\n");
3064
printf("\t--walker : create a reader and walk though the resulting doc\n");
3065
#endif /* LIBXML_READER_ENABLED */
3066
#ifdef LIBXML_PATTERN_ENABLED
3067
printf("\t--pattern pattern_value : test the pattern support\n");
3068
#endif
3069
printf("\t--chkregister : verify the node registration code\n");
3070
#ifdef LIBXML_SCHEMAS_ENABLED
3071
printf("\t--relaxng schema : do RelaxNG validation against the schema\n");
3072
printf("\t--schema schema : do validation against the WXS schema\n");
3073
#endif
3074
#ifdef LIBXML_SCHEMATRON_ENABLED
3075
printf("\t--schematron schema : do validation against a schematron\n");
3076
#endif
3077
#ifdef LIBXML_SAX1_ENABLED
3078
printf("\t--sax1: use the old SAX1 interfaces for processing\n");
3079
#endif
3080
printf("\t--sax: do not build a tree but work just at the SAX level\n");
3081
printf("\t--oldxml10: use XML-1.0 parsing rules before the 5th edition\n");
3082
#ifdef LIBXML_XPATH_ENABLED
3083
printf("\t--xpath expr: evaluate the XPath expression, imply --noout\n");
3084
#endif
3085
3086
printf("\nLibxml project home page: http://xmlsoft.org/\n");
3087
printf("To report bugs or get some help check: http://xmlsoft.org/bugs.html\n");
3088
}
3089
3090
static void registerNode(xmlNodePtr node)
3091
{
3092
node->_private = malloc(sizeof(long));
3093
if (node->_private == NULL) {
3094
fprintf(stderr, "Out of memory in xmllint:registerNode()\n");
3095
exit(XMLLINT_ERR_MEM);
3096
}
3097
*(long*)node->_private = (long) 0x81726354;
3098
nbregister++;
3099
}
3100
3101
static void deregisterNode(xmlNodePtr node)
3102
{
3103
assert(node->_private != NULL);
3104
assert(*(long*)node->_private == (long) 0x81726354);
3105
free(node->_private);
3106
nbregister--;
3107
}
3108
3109
int
3110
main(int argc, char **argv) {
3111
int i, acount;
3112
int files = 0;
3113
int version = 0;
3114
const char* indent;
3115
3116
if (argc <= 1) {
3117
usage(argv[0]);
3118
return(1);
3119
}
3120
LIBXML_TEST_VERSION
3121
for (i = 1; i < argc ; i++) {
3122
if (!strcmp(argv[i], "-"))
3123
break;
3124
3125
if (argv[i][0] != '-')
3126
continue;
3127
if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
3128
debug++;
3129
else
3130
#ifdef LIBXML_DEBUG_ENABLED
3131
if ((!strcmp(argv[i], "-shell")) ||
3132
(!strcmp(argv[i], "--shell"))) {
3133
shell++;
3134
noout = 1;
3135
} else
3136
#endif
3137
#ifdef LIBXML_TREE_ENABLED
3138
if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
3139
copy++;
3140
else
3141
#endif /* LIBXML_TREE_ENABLED */
3142
if ((!strcmp(argv[i], "-recover")) ||
3143
(!strcmp(argv[i], "--recover"))) {
3144
recovery++;
3145
options |= XML_PARSE_RECOVER;
3146
} else if ((!strcmp(argv[i], "-huge")) ||
3147
(!strcmp(argv[i], "--huge"))) {
3148
options |= XML_PARSE_HUGE;
3149
} else if ((!strcmp(argv[i], "-noent")) ||
3150
(!strcmp(argv[i], "--noent"))) {
3151
noent++;
3152
options |= XML_PARSE_NOENT;
3153
} else if ((!strcmp(argv[i], "-noenc")) ||
3154
(!strcmp(argv[i], "--noenc"))) {
3155
noenc++;
3156
options |= XML_PARSE_IGNORE_ENC;
3157
} else if ((!strcmp(argv[i], "-nsclean")) ||
3158
(!strcmp(argv[i], "--nsclean"))) {
3159
options |= XML_PARSE_NSCLEAN;
3160
} else if ((!strcmp(argv[i], "-nocdata")) ||
3161
(!strcmp(argv[i], "--nocdata"))) {
3162
options |= XML_PARSE_NOCDATA;
3163
} else if ((!strcmp(argv[i], "-nodict")) ||
3164
(!strcmp(argv[i], "--nodict"))) {
3165
options |= XML_PARSE_NODICT;
3166
} else if ((!strcmp(argv[i], "-version")) ||
3167
(!strcmp(argv[i], "--version"))) {
3168
showVersion(argv[0]);
3169
version = 1;
3170
} else if ((!strcmp(argv[i], "-noout")) ||
3171
(!strcmp(argv[i], "--noout")))
3172
noout++;
3173
#ifdef LIBXML_OUTPUT_ENABLED
3174
else if ((!strcmp(argv[i], "-o")) ||
3175
(!strcmp(argv[i], "-output")) ||
3176
(!strcmp(argv[i], "--output"))) {
3177
i++;
3178
output = argv[i];
3179
}
3180
#endif /* LIBXML_OUTPUT_ENABLED */
3181
else if ((!strcmp(argv[i], "-htmlout")) ||
3182
(!strcmp(argv[i], "--htmlout")))
3183
htmlout++;
3184
else if ((!strcmp(argv[i], "-nowrap")) ||
3185
(!strcmp(argv[i], "--nowrap")))
3186
nowrap++;
3187
#ifdef LIBXML_HTML_ENABLED
3188
else if ((!strcmp(argv[i], "-html")) ||
3189
(!strcmp(argv[i], "--html"))) {
3190
html++;
3191
}
3192
else if ((!strcmp(argv[i], "-xmlout")) ||
3193
(!strcmp(argv[i], "--xmlout"))) {
3194
xmlout++;
3195
} else if ((!strcmp(argv[i], "-nodefdtd")) ||
3196
(!strcmp(argv[i], "--nodefdtd"))) {
3197
nodefdtd++;
3198
options |= HTML_PARSE_NODEFDTD;
3199
}
3200
#endif /* LIBXML_HTML_ENABLED */
3201
else if ((!strcmp(argv[i], "-loaddtd")) ||
3202
(!strcmp(argv[i], "--loaddtd"))) {
3203
loaddtd++;
3204
options |= XML_PARSE_DTDLOAD;
3205
} else if ((!strcmp(argv[i], "-dtdattr")) ||
3206
(!strcmp(argv[i], "--dtdattr"))) {
3207
loaddtd++;
3208
dtdattrs++;
3209
options |= XML_PARSE_DTDATTR;
3210
}
3211
#ifdef LIBXML_VALID_ENABLED
3212
else if ((!strcmp(argv[i], "-valid")) ||
3213
(!strcmp(argv[i], "--valid"))) {
3214
valid++;
3215
options |= XML_PARSE_DTDVALID;
3216
} else if ((!strcmp(argv[i], "-postvalid")) ||
3217
(!strcmp(argv[i], "--postvalid"))) {
3218
postvalid++;
3219
loaddtd++;
3220
options |= XML_PARSE_DTDLOAD;
3221
} else if ((!strcmp(argv[i], "-dtdvalid")) ||
3222
(!strcmp(argv[i], "--dtdvalid"))) {
3223
i++;
3224
dtdvalid = argv[i];
3225
loaddtd++;
3226
options |= XML_PARSE_DTDLOAD;
3227
} else if ((!strcmp(argv[i], "-dtdvalidfpi")) ||
3228
(!strcmp(argv[i], "--dtdvalidfpi"))) {
3229
i++;
3230
dtdvalidfpi = argv[i];
3231
loaddtd++;
3232
options |= XML_PARSE_DTDLOAD;
3233
}
3234
#endif /* LIBXML_VALID_ENABLED */
3235
else if ((!strcmp(argv[i], "-dropdtd")) ||
3236
(!strcmp(argv[i], "--dropdtd")))
3237
dropdtd++;
3238
else if ((!strcmp(argv[i], "-insert")) ||
3239
(!strcmp(argv[i], "--insert")))
3240
insert++;
3241
else if ((!strcmp(argv[i], "-timing")) ||
3242
(!strcmp(argv[i], "--timing")))
3243
timing++;
3244
else if ((!strcmp(argv[i], "-auto")) ||
3245
(!strcmp(argv[i], "--auto")))
3246
generate++;
3247
else if ((!strcmp(argv[i], "-repeat")) ||
3248
(!strcmp(argv[i], "--repeat"))) {
3249
if (repeat)
3250
repeat *= 10;
3251
else
3252
repeat = 100;
3253
}
3254
#ifdef LIBXML_PUSH_ENABLED
3255
else if ((!strcmp(argv[i], "-push")) ||
3256
(!strcmp(argv[i], "--push")))
3257
push++;
3258
else if ((!strcmp(argv[i], "-pushsmall")) ||
3259
(!strcmp(argv[i], "--pushsmall"))) {
3260
push++;
3261
pushsize = 10;
3262
}
3263
#endif /* LIBXML_PUSH_ENABLED */
3264
#ifdef HAVE_MMAP
3265
else if ((!strcmp(argv[i], "-memory")) ||
3266
(!strcmp(argv[i], "--memory")))
3267
memory++;
3268
#endif
3269
else if ((!strcmp(argv[i], "-testIO")) ||
3270
(!strcmp(argv[i], "--testIO")))
3271
testIO++;
3272
#ifdef LIBXML_XINCLUDE_ENABLED
3273
else if ((!strcmp(argv[i], "-xinclude")) ||
3274
(!strcmp(argv[i], "--xinclude"))) {
3275
xinclude++;
3276
options |= XML_PARSE_XINCLUDE;
3277
}
3278
else if ((!strcmp(argv[i], "-noxincludenode")) ||
3279
(!strcmp(argv[i], "--noxincludenode"))) {
3280
xinclude++;
3281
options |= XML_PARSE_XINCLUDE;
3282
options |= XML_PARSE_NOXINCNODE;
3283
}
3284
else if ((!strcmp(argv[i], "-nofixup-base-uris")) ||
3285
(!strcmp(argv[i], "--nofixup-base-uris"))) {
3286
xinclude++;
3287
options |= XML_PARSE_XINCLUDE;
3288
options |= XML_PARSE_NOBASEFIX;
3289
}
3290
#endif
3291
#ifdef LIBXML_OUTPUT_ENABLED
3292
#ifdef HAVE_ZLIB_H
3293
else if ((!strcmp(argv[i], "-compress")) ||
3294
(!strcmp(argv[i], "--compress"))) {
3295
compress++;
3296
xmlSetCompressMode(9);
3297
}
3298
#endif
3299
#endif /* LIBXML_OUTPUT_ENABLED */
3300
else if ((!strcmp(argv[i], "-nowarning")) ||
3301
(!strcmp(argv[i], "--nowarning"))) {
3302
xmlGetWarningsDefaultValue = 0;
3303
xmlPedanticParserDefault(0);
3304
options |= XML_PARSE_NOWARNING;
3305
}
3306
else if ((!strcmp(argv[i], "-pedantic")) ||
3307
(!strcmp(argv[i], "--pedantic"))) {
3308
xmlGetWarningsDefaultValue = 1;
3309
xmlPedanticParserDefault(1);
3310
options |= XML_PARSE_PEDANTIC;
3311
}
3312
#ifdef LIBXML_DEBUG_ENABLED
3313
else if ((!strcmp(argv[i], "-debugent")) ||
3314
(!strcmp(argv[i], "--debugent"))) {
3315
debugent++;
3316
xmlParserDebugEntities = 1;
3317
}
3318
#endif
3319
#ifdef LIBXML_C14N_ENABLED
3320
else if ((!strcmp(argv[i], "-c14n")) ||
3321
(!strcmp(argv[i], "--c14n"))) {
3322
canonical++;
3323
options |= XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_DTDLOAD;
3324
}
3325
else if ((!strcmp(argv[i], "-c14n11")) ||
3326
(!strcmp(argv[i], "--c14n11"))) {
3327
canonical_11++;
3328
options |= XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_DTDLOAD;
3329
}
3330
else if ((!strcmp(argv[i], "-exc-c14n")) ||
3331
(!strcmp(argv[i], "--exc-c14n"))) {
3332
exc_canonical++;
3333
options |= XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_DTDLOAD;
3334
}
3335
#endif
3336
#ifdef LIBXML_CATALOG_ENABLED
3337
else if ((!strcmp(argv[i], "-catalogs")) ||
3338
(!strcmp(argv[i], "--catalogs"))) {
3339
catalogs++;
3340
} else if ((!strcmp(argv[i], "-nocatalogs")) ||
3341
(!strcmp(argv[i], "--nocatalogs"))) {
3342
nocatalogs++;
3343
}
3344
#endif
3345
else if ((!strcmp(argv[i], "-encode")) ||
3346
(!strcmp(argv[i], "--encode"))) {
3347
i++;
3348
encoding = argv[i];
3349
/*
3350
* OK it's for testing purposes
3351
*/
3352
xmlAddEncodingAlias("UTF-8", "DVEnc");
3353
}
3354
else if ((!strcmp(argv[i], "-noblanks")) ||
3355
(!strcmp(argv[i], "--noblanks"))) {
3356
noblanks++;
3357
xmlKeepBlanksDefault(0);
3358
options |= XML_PARSE_NOBLANKS;
3359
}
3360
else if ((!strcmp(argv[i], "-maxmem")) ||
3361
(!strcmp(argv[i], "--maxmem"))) {
3362
i++;
3363
if (sscanf(argv[i], "%d", &maxmem) == 1) {
3364
xmlMemSetup(myFreeFunc, myMallocFunc, myReallocFunc,
3365
myStrdupFunc);
3366
} else {
3367
maxmem = 0;
3368
}
3369
}
3370
else if ((!strcmp(argv[i], "-format")) ||
3371
(!strcmp(argv[i], "--format"))) {
3372
noblanks++;
3373
#ifdef LIBXML_OUTPUT_ENABLED
3374
format = 1;
3375
#endif /* LIBXML_OUTPUT_ENABLED */
3376
xmlKeepBlanksDefault(0);
3377
}
3378
else if ((!strcmp(argv[i], "-pretty")) ||
3379
(!strcmp(argv[i], "--pretty"))) {
3380
i++;
3381
#ifdef LIBXML_OUTPUT_ENABLED
3382
format = atoi(argv[i]);
3383
if (format == 1) {
3384
noblanks++;
3385
xmlKeepBlanksDefault(0);
3386
}
3387
#endif /* LIBXML_OUTPUT_ENABLED */
3388
}
3389
#ifdef LIBXML_READER_ENABLED
3390
else if ((!strcmp(argv[i], "-stream")) ||
3391
(!strcmp(argv[i], "--stream"))) {
3392
stream++;
3393
}
3394
else if ((!strcmp(argv[i], "-walker")) ||
3395
(!strcmp(argv[i], "--walker"))) {
3396
walker++;
3397
noout++;
3398
}
3399
#endif /* LIBXML_READER_ENABLED */
3400
#ifdef LIBXML_SAX1_ENABLED
3401
else if ((!strcmp(argv[i], "-sax1")) ||
3402
(!strcmp(argv[i], "--sax1"))) {
3403
sax1++;
3404
options |= XML_PARSE_SAX1;
3405
}
3406
#endif /* LIBXML_SAX1_ENABLED */
3407
else if ((!strcmp(argv[i], "-sax")) ||
3408
(!strcmp(argv[i], "--sax"))) {
3409
sax++;
3410
}
3411
else if ((!strcmp(argv[i], "-chkregister")) ||
3412
(!strcmp(argv[i], "--chkregister"))) {
3413
chkregister++;
3414
#ifdef LIBXML_SCHEMAS_ENABLED
3415
} else if ((!strcmp(argv[i], "-relaxng")) ||
3416
(!strcmp(argv[i], "--relaxng"))) {
3417
i++;
3418
relaxng = argv[i];
3419
noent++;
3420
options |= XML_PARSE_NOENT;
3421
} else if ((!strcmp(argv[i], "-schema")) ||
3422
(!strcmp(argv[i], "--schema"))) {
3423
i++;
3424
schema = argv[i];
3425
noent++;
3426
#endif
3427
#ifdef LIBXML_SCHEMATRON_ENABLED
3428
} else if ((!strcmp(argv[i], "-schematron")) ||
3429
(!strcmp(argv[i], "--schematron"))) {
3430
i++;
3431
schematron = argv[i];
3432
noent++;
3433
#endif
3434
} else if ((!strcmp(argv[i], "-nonet")) ||
3435
(!strcmp(argv[i], "--nonet"))) {
3436
options |= XML_PARSE_NONET;
3437
xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
3438
} else if ((!strcmp(argv[i], "-nocompact")) ||
3439
(!strcmp(argv[i], "--nocompact"))) {
3440
options &= ~XML_PARSE_COMPACT;
3441
} else if ((!strcmp(argv[i], "-load-trace")) ||
3442
(!strcmp(argv[i], "--load-trace"))) {
3443
load_trace++;
3444
} else if ((!strcmp(argv[i], "-path")) ||
3445
(!strcmp(argv[i], "--path"))) {
3446
i++;
3447
parsePath(BAD_CAST argv[i]);
3448
#ifdef LIBXML_PATTERN_ENABLED
3449
} else if ((!strcmp(argv[i], "-pattern")) ||
3450
(!strcmp(argv[i], "--pattern"))) {
3451
i++;
3452
pattern = argv[i];
3453
#endif
3454
#ifdef LIBXML_XPATH_ENABLED
3455
} else if ((!strcmp(argv[i], "-xpath")) ||
3456
(!strcmp(argv[i], "--xpath"))) {
3457
i++;
3458
noout++;
3459
xpathquery = argv[i];
3460
#endif
3461
} else if ((!strcmp(argv[i], "-oldxml10")) ||
3462
(!strcmp(argv[i], "--oldxml10"))) {
3463
oldxml10++;
3464
options |= XML_PARSE_OLD10;
3465
} else {
3466
fprintf(stderr, "Unknown option %s\n", argv[i]);
3467
usage(argv[0]);
3468
return(1);
3469
}
3470
}
3471
3472
#ifdef LIBXML_CATALOG_ENABLED
3473
if (nocatalogs == 0) {
3474
if (catalogs) {
3475
const char *catal;
3476
3477
catal = getenv("SGML_CATALOG_FILES");
3478
if (catal != NULL) {
3479
xmlLoadCatalogs(catal);
3480
} else {
3481
fprintf(stderr, "Variable $SGML_CATALOG_FILES not set\n");
3482
}
3483
}
3484
}
3485
#endif
3486
3487
#ifdef LIBXML_SAX1_ENABLED
3488
if (sax1)
3489
xmlSAXDefaultVersion(1);
3490
else
3491
xmlSAXDefaultVersion(2);
3492
#endif /* LIBXML_SAX1_ENABLED */
3493
3494
if (chkregister) {
3495
xmlRegisterNodeDefault(registerNode);
3496
xmlDeregisterNodeDefault(deregisterNode);
3497
}
3498
3499
indent = getenv("XMLLINT_INDENT");
3500
if(indent != NULL) {
3501
xmlTreeIndentString = indent;
3502
}
3503
3504
3505
defaultEntityLoader = xmlGetExternalEntityLoader();
3506
xmlSetExternalEntityLoader(xmllintExternalEntityLoader);
3507
3508
xmlLineNumbersDefault(1);
3509
if (loaddtd != 0)
3510
xmlLoadExtDtdDefaultValue |= XML_DETECT_IDS;
3511
if (dtdattrs)
3512
xmlLoadExtDtdDefaultValue |= XML_COMPLETE_ATTRS;
3513
if (noent != 0) xmlSubstituteEntitiesDefault(1);
3514
#ifdef LIBXML_VALID_ENABLED
3515
if (valid != 0) xmlDoValidityCheckingDefaultValue = 1;
3516
#endif /* LIBXML_VALID_ENABLED */
3517
if ((htmlout) && (!nowrap)) {
3518
xmlGenericError(xmlGenericErrorContext,
3519
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\"\n");
3520
xmlGenericError(xmlGenericErrorContext,
3521
"\t\"http://www.w3.org/TR/REC-html40/loose.dtd\">\n");
3522
xmlGenericError(xmlGenericErrorContext,
3523
"<html><head><title>%s output</title></head>\n",
3524
argv[0]);
3525
xmlGenericError(xmlGenericErrorContext,
3526
"<body bgcolor=\"#ffffff\"><h1 align=\"center\">%s output</h1>\n",
3527
argv[0]);
3528
}
3529
3530
#ifdef LIBXML_SCHEMATRON_ENABLED
3531
if ((schematron != NULL) && (sax == 0)
3532
#ifdef LIBXML_READER_ENABLED
3533
&& (stream == 0)
3534
#endif /* LIBXML_READER_ENABLED */
3535
) {
3536
xmlSchematronParserCtxtPtr ctxt;
3537
3538
/* forces loading the DTDs */
3539
xmlLoadExtDtdDefaultValue |= 1;
3540
options |= XML_PARSE_DTDLOAD;
3541
if (timing) {
3542
startTimer();
3543
}
3544
ctxt = xmlSchematronNewParserCtxt(schematron);
3545
#if 0
3546
xmlSchematronSetParserErrors(ctxt,
3547
(xmlSchematronValidityErrorFunc) fprintf,
3548
(xmlSchematronValidityWarningFunc) fprintf,
3549
stderr);
3550
#endif
3551
wxschematron = xmlSchematronParse(ctxt);
3552
if (wxschematron == NULL) {
3553
xmlGenericError(xmlGenericErrorContext,
3554
"Schematron schema %s failed to compile\n", schematron);
3555
progresult = XMLLINT_ERR_SCHEMACOMP;
3556
schematron = NULL;
3557
}
3558
xmlSchematronFreeParserCtxt(ctxt);
3559
if (timing) {
3560
endTimer("Compiling the schemas");
3561
}
3562
}
3563
#endif
3564
#ifdef LIBXML_SCHEMAS_ENABLED
3565
if ((relaxng != NULL) && (sax == 0)
3566
#ifdef LIBXML_READER_ENABLED
3567
&& (stream == 0)
3568
#endif /* LIBXML_READER_ENABLED */
3569
) {
3570
xmlRelaxNGParserCtxtPtr ctxt;
3571
3572
/* forces loading the DTDs */
3573
xmlLoadExtDtdDefaultValue |= 1;
3574
options |= XML_PARSE_DTDLOAD;
3575
if (timing) {
3576
startTimer();
3577
}
3578
ctxt = xmlRelaxNGNewParserCtxt(relaxng);
3579
xmlRelaxNGSetParserErrors(ctxt,
3580
(xmlRelaxNGValidityErrorFunc) fprintf,
3581
(xmlRelaxNGValidityWarningFunc) fprintf,
3582
stderr);
3583
relaxngschemas = xmlRelaxNGParse(ctxt);
3584
if (relaxngschemas == NULL) {
3585
xmlGenericError(xmlGenericErrorContext,
3586
"Relax-NG schema %s failed to compile\n", relaxng);
3587
progresult = XMLLINT_ERR_SCHEMACOMP;
3588
relaxng = NULL;
3589
}
3590
xmlRelaxNGFreeParserCtxt(ctxt);
3591
if (timing) {
3592
endTimer("Compiling the schemas");
3593
}
3594
} else if ((schema != NULL)
3595
#ifdef LIBXML_READER_ENABLED
3596
&& (stream == 0)
3597
#endif
3598
) {
3599
xmlSchemaParserCtxtPtr ctxt;
3600
3601
if (timing) {
3602
startTimer();
3603
}
3604
ctxt = xmlSchemaNewParserCtxt(schema);
3605
xmlSchemaSetParserErrors(ctxt,
3606
(xmlSchemaValidityErrorFunc) fprintf,
3607
(xmlSchemaValidityWarningFunc) fprintf,
3608
stderr);
3609
wxschemas = xmlSchemaParse(ctxt);
3610
if (wxschemas == NULL) {
3611
xmlGenericError(xmlGenericErrorContext,
3612
"WXS schema %s failed to compile\n", schema);
3613
progresult = XMLLINT_ERR_SCHEMACOMP;
3614
schema = NULL;
3615
}
3616
xmlSchemaFreeParserCtxt(ctxt);
3617
if (timing) {
3618
endTimer("Compiling the schemas");
3619
}
3620
}
3621
#endif /* LIBXML_SCHEMAS_ENABLED */
3622
#ifdef LIBXML_PATTERN_ENABLED
3623
if ((pattern != NULL)
3624
#ifdef LIBXML_READER_ENABLED
3625
&& (walker == 0)
3626
#endif
3627
) {
3628
patternc = xmlPatterncompile((const xmlChar *) pattern, NULL, 0, NULL);
3629
if (patternc == NULL) {
3630
xmlGenericError(xmlGenericErrorContext,
3631
"Pattern %s failed to compile\n", pattern);
3632
progresult = XMLLINT_ERR_SCHEMAPAT;
3633
pattern = NULL;
3634
}
3635
}
3636
#endif /* LIBXML_PATTERN_ENABLED */
3637
for (i = 1; i < argc ; i++) {
3638
if ((!strcmp(argv[i], "-encode")) ||
3639
(!strcmp(argv[i], "--encode"))) {
3640
i++;
3641
continue;
3642
} else if ((!strcmp(argv[i], "-o")) ||
3643
(!strcmp(argv[i], "-output")) ||
3644
(!strcmp(argv[i], "--output"))) {
3645
i++;
3646
continue;
3647
}
3648
#ifdef LIBXML_VALID_ENABLED
3649
if ((!strcmp(argv[i], "-dtdvalid")) ||
3650
(!strcmp(argv[i], "--dtdvalid"))) {
3651
i++;
3652
continue;
3653
}
3654
if ((!strcmp(argv[i], "-path")) ||
3655
(!strcmp(argv[i], "--path"))) {
3656
i++;
3657
continue;
3658
}
3659
if ((!strcmp(argv[i], "-dtdvalidfpi")) ||
3660
(!strcmp(argv[i], "--dtdvalidfpi"))) {
3661
i++;
3662
continue;
3663
}
3664
#endif /* LIBXML_VALID_ENABLED */
3665
if ((!strcmp(argv[i], "-relaxng")) ||
3666
(!strcmp(argv[i], "--relaxng"))) {
3667
i++;
3668
continue;
3669
}
3670
if ((!strcmp(argv[i], "-maxmem")) ||
3671
(!strcmp(argv[i], "--maxmem"))) {
3672
i++;
3673
continue;
3674
}
3675
if ((!strcmp(argv[i], "-pretty")) ||
3676
(!strcmp(argv[i], "--pretty"))) {
3677
i++;
3678
continue;
3679
}
3680
if ((!strcmp(argv[i], "-schema")) ||
3681
(!strcmp(argv[i], "--schema"))) {
3682
i++;
3683
continue;
3684
}
3685
if ((!strcmp(argv[i], "-schematron")) ||
3686
(!strcmp(argv[i], "--schematron"))) {
3687
i++;
3688
continue;
3689
}
3690
#ifdef LIBXML_PATTERN_ENABLED
3691
if ((!strcmp(argv[i], "-pattern")) ||
3692
(!strcmp(argv[i], "--pattern"))) {
3693
i++;
3694
continue;
3695
}
3696
#endif
3697
#ifdef LIBXML_XPATH_ENABLED
3698
if ((!strcmp(argv[i], "-xpath")) ||
3699
(!strcmp(argv[i], "--xpath"))) {
3700
i++;
3701
continue;
3702
}
3703
#endif
3704
if ((timing) && (repeat))
3705
startTimer();
3706
/* Remember file names. "-" means stdin. <sven@zen.org> */
3707
if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0)) {
3708
if (repeat) {
3709
xmlParserCtxtPtr ctxt = NULL;
3710
3711
for (acount = 0;acount < repeat;acount++) {
3712
#ifdef LIBXML_READER_ENABLED
3713
if (stream != 0) {
3714
streamFile(argv[i]);
3715
} else {
3716
#endif /* LIBXML_READER_ENABLED */
3717
if (sax) {
3718
testSAX(argv[i]);
3719
} else {
3720
if (ctxt == NULL)
3721
ctxt = xmlNewParserCtxt();
3722
parseAndPrintFile(argv[i], ctxt);
3723
}
3724
#ifdef LIBXML_READER_ENABLED
3725
}
3726
#endif /* LIBXML_READER_ENABLED */
3727
}
3728
if (ctxt != NULL)
3729
xmlFreeParserCtxt(ctxt);
3730
} else {
3731
nbregister = 0;
3732
3733
#ifdef LIBXML_READER_ENABLED
3734
if (stream != 0)
3735
streamFile(argv[i]);
3736
else
3737
#endif /* LIBXML_READER_ENABLED */
3738
if (sax) {
3739
testSAX(argv[i]);
3740
} else {
3741
parseAndPrintFile(argv[i], NULL);
3742
}
3743
3744
if ((chkregister) && (nbregister != 0)) {
3745
fprintf(stderr, "Registration count off: %d\n", nbregister);
3746
progresult = XMLLINT_ERR_RDREGIS;
3747
}
3748
}
3749
files ++;
3750
if ((timing) && (repeat)) {
3751
endTimer("%d iterations", repeat);
3752
}
3753
}
3754
}
3755
if (generate)
3756
parseAndPrintFile(NULL, NULL);
3757
if ((htmlout) && (!nowrap)) {
3758
xmlGenericError(xmlGenericErrorContext, "</body></html>\n");
3759
}
3760
if ((files == 0) && (!generate) && (version == 0)) {
3761
usage(argv[0]);
3762
}
3763
#ifdef LIBXML_SCHEMATRON_ENABLED
3764
if (wxschematron != NULL)
3765
xmlSchematronFree(wxschematron);
3766
#endif
3767
#ifdef LIBXML_SCHEMAS_ENABLED
3768
if (relaxngschemas != NULL)
3769
xmlRelaxNGFree(relaxngschemas);
3770
if (wxschemas != NULL)
3771
xmlSchemaFree(wxschemas);
3772
xmlRelaxNGCleanupTypes();
3773
#endif
3774
#ifdef LIBXML_PATTERN_ENABLED
3775
if (patternc != NULL)
3776
xmlFreePattern(patternc);
3777
#endif
3778
xmlCleanupParser();
3779
xmlMemoryDump();
3780
3781
return(progresult);
3782
}
3783
Loggerhead is a web-based interface for Breezy
Version: 2.0.1