/
xmlerror.pxi
1386 lines (1291 loc) · 38.6 KB
/
xmlerror.pxi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# DEBUG and error logging
cimport xmlerror
# module level API functions
def clear_error_log():
"""clear_error_log()
Clear the global error log. Note that this log is already bound to a
fixed size.
"""
__GLOBAL_ERROR_LOG.clear()
# dummy function: no debug output at all
cdef void _nullGenericErrorFunc(void* ctxt, char* msg, ...):
pass
# setup for global log:
cdef void _initThreadLogging():
# disable generic error lines from libxml2
xmlerror.xmlThrDefSetGenericErrorFunc(NULL, _nullGenericErrorFunc)
xmlerror.xmlSetGenericErrorFunc(NULL, _nullGenericErrorFunc)
# divert error messages to the global error log
xmlerror.xmlThrDefSetStructuredErrorFunc(NULL, _receiveError)
connectErrorLog(NULL)
cdef void connectErrorLog(void* log):
xmlerror.xmlSetStructuredErrorFunc(log, _receiveError)
xslt.xsltSetGenericErrorFunc(log, _receiveXSLTError)
# Logging classes
cdef class _LogEntry:
cdef readonly object domain
cdef readonly object type
cdef readonly object level
cdef readonly object line
cdef readonly object column
cdef readonly object message
cdef readonly object filename
cdef _setError(self, xmlerror.xmlError* error):
cdef int size
self.domain = error.domain
self.type = error.code
self.level = <int>error.level
self.line = error.line
self.column = error.int2
size = cstd.strlen(error.message)
if size > 0 and error.message[size-1] == c'\n':
size = size - 1 # strip EOL
self.message = python.PyString_FromStringAndSize(error.message, size)
if error.file is NULL:
self.filename = '<string>'
else:
self.filename = python.PyString_FromString(error.file)
cdef _setGeneric(self, int domain, int type, int level, int line,
message, filename):
self.domain = domain
self.type = type
self.level = level
self.line = line
self.column = 0
self.message = message
self.filename = filename
def __repr__(self):
return "%s:%d:%d:%s:%s:%s: %s" % (
self.filename, self.line, self.column, self.level_name,
self.domain_name, self.type_name, self.message)
property domain_name:
def __get__(self):
return ErrorDomains._getName(self.domain, "unknown")
property type_name:
def __get__(self):
if self.domain == ErrorDomains.RELAXNGV:
getName = RelaxNGErrorTypes._getName
else:
getName = ErrorTypes._getName
return getName(self.type, "unknown")
property level_name:
def __get__(self):
return ErrorLevels._getName(self.level, "unknown")
cdef class _BaseErrorLog:
cdef _LogEntry _first_error
cdef readonly object last_error
def __init__(self, first_error, last_error):
self._first_error = first_error
self.last_error = last_error
def copy(self):
return _BaseErrorLog(self._first_error, self.last_error)
def __repr__(self):
return ''
cdef void _receive(self, xmlerror.xmlError* error):
cdef bint is_error
cdef _LogEntry entry
entry = _LogEntry()
entry._setError(error)
is_error = error.level == xmlerror.XML_ERR_ERROR or \
error.level == xmlerror.XML_ERR_FATAL
if __GLOBAL_ERROR_LOG is not self:
__GLOBAL_ERROR_LOG.receive(entry)
if is_error:
__GLOBAL_ERROR_LOG.last_error = entry
self.receive(entry)
if is_error:
self.last_error = entry
cdef void _receiveGeneric(self, int domain, int type, int level, int line,
message, filename):
cdef bint is_error
cdef _LogEntry entry
entry = _LogEntry()
entry._setGeneric(domain, type, level, line, message, filename)
is_error = level == xmlerror.XML_ERR_ERROR or \
level == xmlerror.XML_ERR_FATAL
if __GLOBAL_ERROR_LOG is not self:
__GLOBAL_ERROR_LOG.receive(entry)
if is_error:
__GLOBAL_ERROR_LOG.last_error = entry
self.receive(entry)
if is_error:
self.last_error = entry
cdef _buildParseException(self, exctype, default_message):
code = xmlerror.XML_ERR_INTERNAL_ERROR
if self._first_error is None:
return exctype(default_message, code, 0, 0)
if self._first_error is None or \
self._first_error.message is None or \
not self._first_error.message:
message = default_message
line = 0
column = 0
else:
message = self._first_error.message
code = self._first_error.type
line = self._first_error.line
column = self._first_error.column
if line > 0:
if column > 0:
message = "%s, line %d, column %d" % (message, line, column)
else:
message = "%s, line %d" % (message, line)
return exctype(message, code, line, column)
cdef _buildExceptionMessage(self, default_message):
if self._first_error is None:
return default_message
if self._first_error.message is not None and self._first_error.message:
message = self._first_error.message
elif default_message is None:
return None
else:
message = default_message
if self._first_error.line > 0:
if self._first_error.column > 0:
message = "%s, line %d, column %d" % (
message, self._first_error.line, self._first_error.column)
else:
message = "%s, line %d" % (message, self._first_error.line)
return message
cdef class _ListErrorLog(_BaseErrorLog):
"Immutable base version of a list based error log."
cdef object _entries
def __init__(self, entries, first_error, last_error):
if entries:
if first_error is None:
first_error = entries[0]
if last_error is None:
last_error = entries[-1]
_BaseErrorLog.__init__(self, first_error, last_error)
self._entries = entries
def copy(self):
"""Creates a shallow copy of this error log. Reuses the list of
entries.
"""
return _ListErrorLog(self._entries, self._first_error, self.last_error)
def __iter__(self):
return iter(self._entries)
def __repr__(self):
l = []
for entry in self._entries:
python.PyList_Append(l, repr(entry))
return '\n'.join(l)
def __getitem__(self, index):
return self._entries[index]
def __len__(self):
return len(self._entries)
def __contains__(self, error_type):
for entry in self._entries:
if entry.type == error_type:
return True
return False
def __nonzero__(self):
cdef bint result
result = self._entries
return result
def filter_domains(self, domains):
"""Filter the errors by the given domains and return a new error log
containing the matches.
"""
cdef _LogEntry entry
filtered = []
if not python.PySequence_Check(domains):
domains = (domains,)
for entry in self._entries:
if entry.domain in domains:
python.PyList_Append(filtered, entry)
return _ListErrorLog(filtered, None, None)
def filter_types(self, types):
"""filter_types(self, types)
Filter the errors by the given types and return a new error
log containing the matches.
"""
cdef _LogEntry entry
if not python.PySequence_Check(types):
types = (types,)
filtered = []
for entry in self._entries:
if entry.type in types:
python.PyList_Append(filtered, entry)
return _ListErrorLog(filtered, None, None)
def filter_levels(self, levels):
"""filter_levels(self, levels)
Filter the errors by the given error levels and return a new
error log containing the matches.
"""
cdef _LogEntry entry
if not python.PySequence_Check(levels):
levels = (levels,)
filtered = []
for entry in self._entries:
if entry.level in levels:
python.PyList_Append(filtered, entry)
return _ListErrorLog(filtered, None, None)
def filter_from_level(self, level):
"""filter_from_level(self, level)
Return a log with all messages of the requested level of worse.
"""
cdef _LogEntry entry
filtered = []
for entry in self._entries:
if entry.level >= level:
python.PyList_Append(filtered, entry)
return _ListErrorLog(filtered, None, None)
def filter_from_fatals(self):
"""filter_from_fatals(self)
Convenience method to get all fatal error messages.
"""
return self.filter_from_level(ErrorLevels.FATAL)
def filter_from_errors(self):
"""filter_from_errors(self)
Convenience method to get all error messages or worse.
"""
return self.filter_from_level(ErrorLevels.ERROR)
def filter_from_warnings(self):
"""filter_from_warnings(self)
Convenience method to get all warnings or worse.
"""
return self.filter_from_level(ErrorLevels.WARNING)
cdef class _ErrorLog(_ListErrorLog):
def __init__(self):
_ListErrorLog.__init__(self, [], None, None)
cdef void connect(self):
self._first_error = None
del self._entries[:]
connectErrorLog(<void*>self)
cdef void disconnect(self):
connectErrorLog(NULL)
def clear(self):
self._first_error = None
del self._entries[:]
def copy(self):
"""Creates a shallow copy of this error log and the list of entries.
"""
return _ListErrorLog(self._entries[:], self._first_error,
self.last_error)
def __iter__(self):
return iter(self._entries[:])
def receive(self, entry):
if self._first_error is None:
self._first_error = entry
python.PyList_Append(self._entries, entry)
cdef class _DomainErrorLog(_ErrorLog):
def __init__(self, domains):
_ErrorLog.__init__(self)
self._accepted_domains = tuple(domains)
def receive(self, entry):
if entry.domain in self._accepted_domains:
_ErrorLog.receive(self, entry)
cdef class _RotatingErrorLog(_ErrorLog):
cdef int _max_len
def __init__(self, max_len):
_ErrorLog.__init__(self)
self._max_len = max_len
def receive(self, entry):
entries = self._entries
if python.PyList_GET_SIZE(entries) > self._max_len:
del entries[0]
python.PyList_Append(entries, entry)
cdef class PyErrorLog(_BaseErrorLog):
"""PyErrorLog(self, logger_name=None)
A global error log that connects to the Python stdlib logging package.
The constructor accepts an optional logger name.
If you want to change the mapping between libxml2's ErrorLevels and Python
logging levels, you can modify the level_map dictionary from a subclass.
The default mapping is::
ErrorLevels.WARNING = logging.WARNING
ErrorLevels.ERROR = logging.ERROR
ErrorLevels.FATAL = logging.CRITICAL
You can also override the method ``receive()`` that takes a LogEntry
object and calls ``self.log(log_entry, format_string, arg1, arg2, ...)``
with appropriate data.
"""
cdef readonly object level_map
cdef object _map_level
cdef object _log
def __init__(self, logger_name=None):
_BaseErrorLog.__init__(self, None, None)
import logging
self.level_map = {
ErrorLevels.WARNING : logging.WARNING,
ErrorLevels.ERROR : logging.ERROR,
ErrorLevels.FATAL : logging.CRITICAL
}
self._map_level = self.level_map.get
if logger_name:
logger = logging.getLogger(logger_name)
else:
logger = logging.getLogger()
self._log = logger.log
def copy(self):
"""Dummy method that returns an empty error log.
"""
return _ListErrorLog([], None, None)
def log(self, entry, message_format_string, *args):
self._log(
self._map_level(entry.level, 0),
message_format_string, *args
)
def receive(self, entry):
self.log(entry, entry)
# global list log to collect error output messages from libxml2/libxslt
cdef _BaseErrorLog __GLOBAL_ERROR_LOG
__GLOBAL_ERROR_LOG = _RotatingErrorLog(__MAX_LOG_SIZE)
cdef __copyGlobalErrorLog():
"Helper function for properties in exceptions."
return __GLOBAL_ERROR_LOG.copy()
def use_global_python_log(PyErrorLog log not None):
"""use_global_python_log(log)
Replace the global error log by an etree.PyErrorLog that uses the
standard Python logging package.
Note that this disables access to the global error log from exceptions.
Parsers, XSLT etc. will continue to provide their normal local error log.
"""
global __GLOBAL_ERROR_LOG
__GLOBAL_ERROR_LOG = log
# local log functions: forward error to logger object
cdef void _forwardError(void* c_log_handler, xmlerror.xmlError* error) with gil:
cdef _BaseErrorLog log_handler
if c_log_handler is not NULL:
log_handler = <_BaseErrorLog>c_log_handler
else:
log_handler = __GLOBAL_ERROR_LOG
log_handler._receive(error)
cdef void _receiveError(void* c_log_handler, xmlerror.xmlError* error) nogil:
# no Python objects here, may be called without thread context !
# when we declare a Python object, Pyrex will INCREF(None) !
if __DEBUG != 0:
_forwardError(c_log_handler, error)
cdef void _receiveXSLTError(void* c_log_handler, char* msg, ...) nogil:
# no Python objects here, may be called without thread context !
# when we declare a Python object, Pyrex will INCREF(None) !
cdef xmlerror.xmlError c_error
cdef cstd.va_list args
cdef char* c_text
cdef char* c_message
cdef char* c_element
cdef int i, text_size, element_size
if __DEBUG == 0 or msg is NULL:
return
if msg[0] == c'\n' or msg[0] == c'\0':
return
cstd.va_start(args, msg)
if msg[0] == c'%' and msg[1] == c's':
c_text = cstd.va_charptr(args)
else:
c_text = NULL
if cstd.strstr(msg, 'file %s'):
c_error.file = cstd.va_charptr(args)
if c_error.file and \
cstd.strncmp(c_error.file,
'string://__STRING__XSLT', 23) == 0:
c_error.file = '<xslt>'
else:
c_error.file = NULL
if cstd.strstr(msg, 'line %d'):
c_error.line = cstd.va_int(args)
else:
c_error.line = 0
if cstd.strstr(msg, 'element %s'):
c_element = cstd.va_charptr(args)
else:
c_element = NULL
cstd.va_end(args)
c_message = NULL
if c_text is NULL:
if c_element is not NULL and \
cstd.strchr(msg, c'%') == cstd.strrchr(msg, c'%'):
# special case: a single occurrence of 'element %s'
text_size = cstd.strlen(msg)
element_size = cstd.strlen(c_element)
c_message = <char*>cstd.malloc(
(text_size + element_size + 1) * sizeof(char))
cstd.sprintf(c_message, msg, c_element)
c_error.message = c_message
else:
c_error.message = ''
elif c_element is NULL:
c_error.message = c_text
else:
text_size = cstd.strlen(c_text)
element_size = cstd.strlen(c_element)
c_message = <char*>cstd.malloc(
(text_size + 12 + element_size + 1) * sizeof(char))
cstd.sprintf(c_message, "%s, element '%s'", c_text, c_element)
c_error.message = c_message
c_error.domain = xmlerror.XML_FROM_XSLT
c_error.code = xmlerror.XML_ERR_OK # what else?
c_error.level = xmlerror.XML_ERR_ERROR # what else?
c_error.int2 = 0
_forwardError(c_log_handler, &c_error)
if c_message is not NULL:
cstd.free(c_message)
################################################################################
## CONSTANTS FROM "xmlerror.h" (or rather libxml-xmlerror.html)
################################################################################
cdef void __initErrorConstants():
"Called at setup time to parse the constants and build the classes below."
find_constants = re.compile(r"\s*([a-zA-Z0-9_]+)\s*=\s*([0-9]+)").findall
const_defs = ((ErrorLevels, __ERROR_LEVELS),
(ErrorDomains, __ERROR_DOMAINS),
(ErrorTypes, __PARSER_ERROR_TYPES),
(RelaxNGErrorTypes, __RELAXNG_ERROR_TYPES))
for cls, constant_tuple in const_defs:
reverse_dict = {}
cls._names = reverse_dict
cls._getName = reverse_dict.get
for constants in constant_tuple:
#print len(constants) + 1
for name, value in find_constants(constants):
value = python.PyNumber_Int(value)
python.PyObject_SetAttr(cls, name, value)
python.PyDict_SetItem(reverse_dict, value, name)
class ErrorLevels:
"Libxml2 error levels"
class ErrorDomains:
"Libxml2 error domains"
class ErrorTypes:
"Libxml2 error types"
class RelaxNGErrorTypes:
"Libxml2 RelaxNG error types"
# --- BEGIN: GENERATED CONSTANTS ---
# This section is generated by the script 'update-error-constants.py'.
# Constants are stored in tuples of strings, for which Pyrex generates very
# efficient setup code. To parse them, iterate over the tuples and parse each
# line in each string independently. Tuples of strings (instead of a plain
# string) are required as some C-compilers of a certain well-known OS vendor
# cannot handle strings that are a few thousand bytes in length.
cdef object __ERROR_LEVELS
__ERROR_LEVELS = ("""\
NONE=0
WARNING=1
ERROR=2
FATAL=3
""",)
cdef object __ERROR_DOMAINS
__ERROR_DOMAINS = ("""\
NONE=0
PARSER=1
TREE=2
NAMESPACE=3
DTD=4
HTML=5
MEMORY=6
OUTPUT=7
IO=8
FTP=9
HTTP=10
XINCLUDE=11
XPATH=12
XPOINTER=13
REGEXP=14
DATATYPE=15
SCHEMASP=16
SCHEMASV=17
RELAXNGP=18
RELAXNGV=19
CATALOG=20
C14N=21
XSLT=22
VALID=23
CHECK=24
WRITER=25
MODULE=26
I18N=27
SCHEMATRONV=28
""",)
cdef object __PARSER_ERROR_TYPES
__PARSER_ERROR_TYPES = ("""\
ERR_OK=0
ERR_INTERNAL_ERROR=1
ERR_NO_MEMORY=2
ERR_DOCUMENT_START=3
ERR_DOCUMENT_EMPTY=4
ERR_DOCUMENT_END=5
ERR_INVALID_HEX_CHARREF=6
ERR_INVALID_DEC_CHARREF=7
ERR_INVALID_CHARREF=8
ERR_INVALID_CHAR=9
ERR_CHARREF_AT_EOF=10
ERR_CHARREF_IN_PROLOG=11
ERR_CHARREF_IN_EPILOG=12
ERR_CHARREF_IN_DTD=13
ERR_ENTITYREF_AT_EOF=14
ERR_ENTITYREF_IN_PROLOG=15
ERR_ENTITYREF_IN_EPILOG=16
ERR_ENTITYREF_IN_DTD=17
ERR_PEREF_AT_EOF=18
ERR_PEREF_IN_PROLOG=19
ERR_PEREF_IN_EPILOG=20
ERR_PEREF_IN_INT_SUBSET=21
ERR_ENTITYREF_NO_NAME=22
ERR_ENTITYREF_SEMICOL_MISSING=23
ERR_PEREF_NO_NAME=24
ERR_PEREF_SEMICOL_MISSING=25
ERR_UNDECLARED_ENTITY=26
WAR_UNDECLARED_ENTITY=27
ERR_UNPARSED_ENTITY=28
ERR_ENTITY_IS_EXTERNAL=29
ERR_ENTITY_IS_PARAMETER=30
ERR_UNKNOWN_ENCODING=31
ERR_UNSUPPORTED_ENCODING=32
ERR_STRING_NOT_STARTED=33
ERR_STRING_NOT_CLOSED=34
ERR_NS_DECL_ERROR=35
ERR_ENTITY_NOT_STARTED=36
ERR_ENTITY_NOT_FINISHED=37
ERR_LT_IN_ATTRIBUTE=38
ERR_ATTRIBUTE_NOT_STARTED=39
ERR_ATTRIBUTE_NOT_FINISHED=40
ERR_ATTRIBUTE_WITHOUT_VALUE=41
ERR_ATTRIBUTE_REDEFINED=42
ERR_LITERAL_NOT_STARTED=43
ERR_LITERAL_NOT_FINISHED=44
ERR_COMMENT_NOT_FINISHED=45
ERR_PI_NOT_STARTED=46
ERR_PI_NOT_FINISHED=47
ERR_NOTATION_NOT_STARTED=48
ERR_NOTATION_NOT_FINISHED=49
ERR_ATTLIST_NOT_STARTED=50
ERR_ATTLIST_NOT_FINISHED=51
ERR_MIXED_NOT_STARTED=52
ERR_MIXED_NOT_FINISHED=53
ERR_ELEMCONTENT_NOT_STARTED=54
ERR_ELEMCONTENT_NOT_FINISHED=55
ERR_XMLDECL_NOT_STARTED=56
ERR_XMLDECL_NOT_FINISHED=57
ERR_CONDSEC_NOT_STARTED=58
ERR_CONDSEC_NOT_FINISHED=59
ERR_EXT_SUBSET_NOT_FINISHED=60
ERR_DOCTYPE_NOT_FINISHED=61
ERR_MISPLACED_CDATA_END=62
ERR_CDATA_NOT_FINISHED=63
ERR_RESERVED_XML_NAME=64
ERR_SPACE_REQUIRED=65
ERR_SEPARATOR_REQUIRED=66
ERR_NMTOKEN_REQUIRED=67
ERR_NAME_REQUIRED=68
ERR_PCDATA_REQUIRED=69
ERR_URI_REQUIRED=70
ERR_PUBID_REQUIRED=71
ERR_LT_REQUIRED=72
ERR_GT_REQUIRED=73
ERR_LTSLASH_REQUIRED=74
ERR_EQUAL_REQUIRED=75
ERR_TAG_NAME_MISMATCH=76
ERR_TAG_NOT_FINISHED=77
ERR_STANDALONE_VALUE=78
""",
"""\
ERR_ENCODING_NAME=79
ERR_HYPHEN_IN_COMMENT=80
ERR_INVALID_ENCODING=81
ERR_EXT_ENTITY_STANDALONE=82
ERR_CONDSEC_INVALID=83
ERR_VALUE_REQUIRED=84
ERR_NOT_WELL_BALANCED=85
ERR_EXTRA_CONTENT=86
ERR_ENTITY_CHAR_ERROR=87
ERR_ENTITY_PE_INTERNAL=88
ERR_ENTITY_LOOP=89
ERR_ENTITY_BOUNDARY=90
ERR_INVALID_URI=91
ERR_URI_FRAGMENT=92
WAR_CATALOG_PI=93
ERR_NO_DTD=94
ERR_CONDSEC_INVALID_KEYWORD=95
ERR_VERSION_MISSING=96
WAR_UNKNOWN_VERSION=97
WAR_LANG_VALUE=98
WAR_NS_URI=99
WAR_NS_URI_RELATIVE=100
ERR_MISSING_ENCODING=101
WAR_SPACE_VALUE=102
ERR_NOT_STANDALONE=103
ERR_ENTITY_PROCESSING=104
ERR_NOTATION_PROCESSING=105
WAR_NS_COLUMN=106
WAR_ENTITY_REDEFINED=107
NS_ERR_XML_NAMESPACE=200
NS_ERR_UNDEFINED_NAMESPACE=201
NS_ERR_QNAME=202
NS_ERR_ATTRIBUTE_REDEFINED=203
NS_ERR_EMPTY=204
DTD_ATTRIBUTE_DEFAULT=500
DTD_ATTRIBUTE_REDEFINED=501
DTD_ATTRIBUTE_VALUE=502
DTD_CONTENT_ERROR=503
DTD_CONTENT_MODEL=504
DTD_CONTENT_NOT_DETERMINIST=505
DTD_DIFFERENT_PREFIX=506
DTD_ELEM_DEFAULT_NAMESPACE=507
DTD_ELEM_NAMESPACE=508
DTD_ELEM_REDEFINED=509
DTD_EMPTY_NOTATION=510
DTD_ENTITY_TYPE=511
DTD_ID_FIXED=512
DTD_ID_REDEFINED=513
DTD_ID_SUBSET=514
DTD_INVALID_CHILD=515
DTD_INVALID_DEFAULT=516
DTD_LOAD_ERROR=517
DTD_MISSING_ATTRIBUTE=518
DTD_MIXED_CORRUPT=519
DTD_MULTIPLE_ID=520
DTD_NO_DOC=521
DTD_NO_DTD=522
DTD_NO_ELEM_NAME=523
DTD_NO_PREFIX=524
DTD_NO_ROOT=525
DTD_NOTATION_REDEFINED=526
DTD_NOTATION_VALUE=527
DTD_NOT_EMPTY=528
DTD_NOT_PCDATA=529
DTD_NOT_STANDALONE=530
DTD_ROOT_NAME=531
DTD_STANDALONE_WHITE_SPACE=532
DTD_UNKNOWN_ATTRIBUTE=533
DTD_UNKNOWN_ELEM=534
DTD_UNKNOWN_ENTITY=535
DTD_UNKNOWN_ID=536
DTD_UNKNOWN_NOTATION=537
DTD_STANDALONE_DEFAULTED=538
DTD_XMLID_VALUE=539
DTD_XMLID_TYPE=540
HTML_STRUCURE_ERROR=800
HTML_UNKNOWN_TAG=801
RNGP_ANYNAME_ATTR_ANCESTOR=1000
RNGP_ATTR_CONFLICT=1001
RNGP_ATTRIBUTE_CHILDREN=1002
RNGP_ATTRIBUTE_CONTENT=1003
RNGP_ATTRIBUTE_EMPTY=1004
RNGP_ATTRIBUTE_NOOP=1005
RNGP_CHOICE_CONTENT=1006
RNGP_CHOICE_EMPTY=1007
""",
"""\
RNGP_CREATE_FAILURE=1008
RNGP_DATA_CONTENT=1009
RNGP_DEF_CHOICE_AND_INTERLEAVE=1010
RNGP_DEFINE_CREATE_FAILED=1011
RNGP_DEFINE_EMPTY=1012
RNGP_DEFINE_MISSING=1013
RNGP_DEFINE_NAME_MISSING=1014
RNGP_ELEM_CONTENT_EMPTY=1015
RNGP_ELEM_CONTENT_ERROR=1016
RNGP_ELEMENT_EMPTY=1017
RNGP_ELEMENT_CONTENT=1018
RNGP_ELEMENT_NAME=1019
RNGP_ELEMENT_NO_CONTENT=1020
RNGP_ELEM_TEXT_CONFLICT=1021
RNGP_EMPTY=1022
RNGP_EMPTY_CONSTRUCT=1023
RNGP_EMPTY_CONTENT=1024
RNGP_EMPTY_NOT_EMPTY=1025
RNGP_ERROR_TYPE_LIB=1026
RNGP_EXCEPT_EMPTY=1027
RNGP_EXCEPT_MISSING=1028
RNGP_EXCEPT_MULTIPLE=1029
RNGP_EXCEPT_NO_CONTENT=1030
RNGP_EXTERNALREF_EMTPY=1031
RNGP_EXTERNAL_REF_FAILURE=1032
RNGP_EXTERNALREF_RECURSE=1033
RNGP_FORBIDDEN_ATTRIBUTE=1034
RNGP_FOREIGN_ELEMENT=1035
RNGP_GRAMMAR_CONTENT=1036
RNGP_GRAMMAR_EMPTY=1037
RNGP_GRAMMAR_MISSING=1038
RNGP_GRAMMAR_NO_START=1039
RNGP_GROUP_ATTR_CONFLICT=1040
RNGP_HREF_ERROR=1041
RNGP_INCLUDE_EMPTY=1042
RNGP_INCLUDE_FAILURE=1043
RNGP_INCLUDE_RECURSE=1044
RNGP_INTERLEAVE_ADD=1045
RNGP_INTERLEAVE_CREATE_FAILED=1046
RNGP_INTERLEAVE_EMPTY=1047
RNGP_INTERLEAVE_NO_CONTENT=1048
RNGP_INVALID_DEFINE_NAME=1049
RNGP_INVALID_URI=1050
RNGP_INVALID_VALUE=1051
RNGP_MISSING_HREF=1052
RNGP_NAME_MISSING=1053
RNGP_NEED_COMBINE=1054
RNGP_NOTALLOWED_NOT_EMPTY=1055
RNGP_NSNAME_ATTR_ANCESTOR=1056
RNGP_NSNAME_NO_NS=1057
RNGP_PARAM_FORBIDDEN=1058
RNGP_PARAM_NAME_MISSING=1059
RNGP_PARENTREF_CREATE_FAILED=1060
RNGP_PARENTREF_NAME_INVALID=1061
RNGP_PARENTREF_NO_NAME=1062
RNGP_PARENTREF_NO_PARENT=1063
RNGP_PARENTREF_NOT_EMPTY=1064
RNGP_PARSE_ERROR=1065
RNGP_PAT_ANYNAME_EXCEPT_ANYNAME=1066
RNGP_PAT_ATTR_ATTR=1067
RNGP_PAT_ATTR_ELEM=1068
RNGP_PAT_DATA_EXCEPT_ATTR=1069
RNGP_PAT_DATA_EXCEPT_ELEM=1070
RNGP_PAT_DATA_EXCEPT_EMPTY=1071
RNGP_PAT_DATA_EXCEPT_GROUP=1072
RNGP_PAT_DATA_EXCEPT_INTERLEAVE=1073
RNGP_PAT_DATA_EXCEPT_LIST=1074
RNGP_PAT_DATA_EXCEPT_ONEMORE=1075
RNGP_PAT_DATA_EXCEPT_REF=1076
RNGP_PAT_DATA_EXCEPT_TEXT=1077
RNGP_PAT_LIST_ATTR=1078
""",
"""\
RNGP_PAT_LIST_ELEM=1079
RNGP_PAT_LIST_INTERLEAVE=1080
RNGP_PAT_LIST_LIST=1081
RNGP_PAT_LIST_REF=1082
RNGP_PAT_LIST_TEXT=1083
RNGP_PAT_NSNAME_EXCEPT_ANYNAME=1084
RNGP_PAT_NSNAME_EXCEPT_NSNAME=1085
RNGP_PAT_ONEMORE_GROUP_ATTR=1086
RNGP_PAT_ONEMORE_INTERLEAVE_ATTR=1087
RNGP_PAT_START_ATTR=1088
RNGP_PAT_START_DATA=1089
RNGP_PAT_START_EMPTY=1090
RNGP_PAT_START_GROUP=1091
RNGP_PAT_START_INTERLEAVE=1092
RNGP_PAT_START_LIST=1093
RNGP_PAT_START_ONEMORE=1094
RNGP_PAT_START_TEXT=1095
RNGP_PAT_START_VALUE=1096
RNGP_PREFIX_UNDEFINED=1097
RNGP_REF_CREATE_FAILED=1098
RNGP_REF_CYCLE=1099
RNGP_REF_NAME_INVALID=1100
RNGP_REF_NO_DEF=1101
RNGP_REF_NO_NAME=1102
RNGP_REF_NOT_EMPTY=1103
RNGP_START_CHOICE_AND_INTERLEAVE=1104
RNGP_START_CONTENT=1105
RNGP_START_EMPTY=1106
RNGP_START_MISSING=1107
RNGP_TEXT_EXPECTED=1108
RNGP_TEXT_HAS_CHILD=1109
RNGP_TYPE_MISSING=1110
RNGP_TYPE_NOT_FOUND=1111
RNGP_TYPE_VALUE=1112
RNGP_UNKNOWN_ATTRIBUTE=1113
RNGP_UNKNOWN_COMBINE=1114
RNGP_UNKNOWN_CONSTRUCT=1115
RNGP_UNKNOWN_TYPE_LIB=1116
RNGP_URI_FRAGMENT=1117
RNGP_URI_NOT_ABSOLUTE=1118
RNGP_VALUE_EMPTY=1119
RNGP_VALUE_NO_CONTENT=1120
RNGP_XMLNS_NAME=1121
RNGP_XML_NS=1122
XPATH_EXPRESSION_OK=1200
XPATH_NUMBER_ERROR=1201
XPATH_UNFINISHED_LITERAL_ERROR=1202
XPATH_START_LITERAL_ERROR=1203
XPATH_VARIABLE_REF_ERROR=1204
XPATH_UNDEF_VARIABLE_ERROR=1205
XPATH_INVALID_PREDICATE_ERROR=1206
XPATH_EXPR_ERROR=1207
XPATH_UNCLOSED_ERROR=1208
XPATH_UNKNOWN_FUNC_ERROR=1209
XPATH_INVALID_OPERAND=1210
XPATH_INVALID_TYPE=1211
XPATH_INVALID_ARITY=1212
XPATH_INVALID_CTXT_SIZE=1213
XPATH_INVALID_CTXT_POSITION=1214
XPATH_MEMORY_ERROR=1215
XPTR_SYNTAX_ERROR=1216
XPTR_RESOURCE_ERROR=1217
XPTR_SUB_RESOURCE_ERROR=1218
XPATH_UNDEF_PREFIX_ERROR=1219
XPATH_ENCODING_ERROR=1220
XPATH_INVALID_CHAR_ERROR=1221
TREE_INVALID_HEX=1300
TREE_INVALID_DEC=1301
TREE_UNTERMINATED_ENTITY=1302
TREE_NOT_UTF8=1303
SAVE_NOT_UTF8=1400
SAVE_CHAR_INVALID=1401
SAVE_NO_DOCTYPE=1402
SAVE_UNKNOWN_ENCODING=1403
""",
"""\
REGEXP_COMPILE_ERROR=1450
IO_UNKNOWN=1500
IO_EACCES=1501
IO_EAGAIN=1502
IO_EBADF=1503
IO_EBADMSG=1504
IO_EBUSY=1505
IO_ECANCELED=1506
IO_ECHILD=1507
IO_EDEADLK=1508
IO_EDOM=1509
IO_EEXIST=1510
IO_EFAULT=1511
IO_EFBIG=1512
IO_EINPROGRESS=1513
IO_EINTR=1514
IO_EINVAL=1515
IO_EIO=1516
IO_EISDIR=1517
IO_EMFILE=1518
IO_EMLINK=1519
IO_EMSGSIZE=1520
IO_ENAMETOOLONG=1521
IO_ENFILE=1522
IO_ENODEV=1523
IO_ENOENT=1524
IO_ENOEXEC=1525
IO_ENOLCK=1526
IO_ENOMEM=1527
IO_ENOSPC=1528
IO_ENOSYS=1529
IO_ENOTDIR=1530
IO_ENOTEMPTY=1531
IO_ENOTSUP=1532
IO_ENOTTY=1533
IO_ENXIO=1534
IO_EPERM=1535
IO_EPIPE=1536
IO_ERANGE=1537
IO_EROFS=1538
IO_ESPIPE=1539
IO_ESRCH=1540
IO_ETIMEDOUT=1541
IO_EXDEV=1542
IO_NETWORK_ATTEMPT=1543
IO_ENCODER=1544
IO_FLUSH=1545
IO_WRITE=1546
IO_NO_INPUT=1547
IO_BUFFER_FULL=1548
IO_LOAD_ERROR=1549
IO_ENOTSOCK=1550
IO_EISCONN=1551
IO_ECONNREFUSED=1552
IO_ENETUNREACH=1553
IO_EADDRINUSE=1554
IO_EALREADY=1555
IO_EAFNOSUPPORT=1556
XINCLUDE_RECURSION=1600
XINCLUDE_PARSE_VALUE=1601
XINCLUDE_ENTITY_DEF_MISMATCH=1602
XINCLUDE_NO_HREF=1603
XINCLUDE_NO_FALLBACK=1604
XINCLUDE_HREF_URI=1605
XINCLUDE_TEXT_FRAGMENT=1606
XINCLUDE_TEXT_DOCUMENT=1607
XINCLUDE_INVALID_CHAR=1608
XINCLUDE_BUILD_FAILED=1609
XINCLUDE_UNKNOWN_ENCODING=1610
XINCLUDE_MULTIPLE_ROOT=1611
XINCLUDE_XPTR_FAILED=1612
XINCLUDE_XPTR_RESULT=1613
XINCLUDE_INCLUDE_IN_INCLUDE=1614
XINCLUDE_FALLBACKS_IN_INCLUDE=1615
XINCLUDE_FALLBACK_NOT_IN_INCLUDE=1616
XINCLUDE_DEPRECATED_NS=1617
XINCLUDE_FRAGMENT_ID=1618
CATALOG_MISSING_ATTR=1650
CATALOG_ENTRY_BROKEN=1651
CATALOG_PREFER_VALUE=1652
CATALOG_NOT_CATALOG=1653
CATALOG_RECURSION=1654
SCHEMAP_PREFIX_UNDEFINED=1700
SCHEMAP_ATTRFORMDEFAULT_VALUE=1701
SCHEMAP_ATTRGRP_NONAME_NOREF=1702
SCHEMAP_ATTR_NONAME_NOREF=1703
SCHEMAP_COMPLEXTYPE_NONAME_NOREF=1704
SCHEMAP_ELEMFORMDEFAULT_VALUE=1705
SCHEMAP_ELEM_NONAME_NOREF=1706
SCHEMAP_EXTENSION_NO_BASE=1707
SCHEMAP_FACET_NO_VALUE=1708
SCHEMAP_FAILED_BUILD_IMPORT=1709