src/lxml/xmlerror.pxi

   1 # DEBUG and error logging
   2
   3 cimport xmlerror
   4
   5 # module level API functions
   6
   7 def clear_error_log():
   8     u"""clear_error_log()
   9
  10     Clear the global error log.  Note that this log is already bound to a
  11     fixed size.
  12
  13     Note: since lxml 2.2, the global error log is local to a thread
  14     and this function will only clear the global error log of the
  15     current thread.
  16     """
  17     _getGlobalErrorLog().clear()
  18
  19 # dummy function: no debug output at all
  20 cdef void _nullGenericErrorFunc(void* ctxt, char* msg, ...) nogil:
  21     pass
  22
  23 # setup for global log:
  24
  25 cdef void _initThreadLogging():
  26     # disable generic error lines from libxml2
  27     xmlerror.xmlThrDefSetGenericErrorFunc(NULL, _nullGenericErrorFunc)
  28     xmlerror.xmlSetGenericErrorFunc(NULL, _nullGenericErrorFunc)
  29
  30     # divert error messages to the global error log
  31     xmlerror.xmlThrDefSetStructuredErrorFunc(NULL, _receiveError)
  32     connectErrorLog(NULL)
  33
  34 cdef void connectErrorLog(void* log):
  35     xmlerror.xmlSetStructuredErrorFunc(log, _receiveError)
  36     xslt.xsltSetGenericErrorFunc(log, _receiveXSLTError)
  37
  38
  39 # Logging classes
  40
  41 cdef class _LogEntry:
  42     cdef readonly object domain
  43     cdef readonly object type
  44     cdef readonly object level
  45     cdef readonly object line
  46     cdef readonly object column
  47     cdef readonly object message
  48     cdef readonly object filename
  49
  50     cdef _setError(self, xmlerror.xmlError* error):
  51         cdef int size
  52         self.domain   = error.domain
  53         self.type     = error.code
  54         self.level    = <int>error.level
  55         self.line     = error.line
  56         self.column   = error.int2
  57         size = cstd.strlen(error.message)
  58         if size > 0 and error.message[size-1] == c'\n':
  59             size = size - 1 # strip EOL
  60         try:
  61             self.message = python.PyUnicode_DecodeUTF8(
  62                 error.message, size, NULL)
  63         except:
  64             try:
  65                 self.message = python.PyUnicode_DecodeASCII(
  66                     error.message, size, 'backslashreplace')
  67             except:
  68                 self.message = u'<undecodable error message>'
  69         if error.file is NULL:
  70             self.filename = u'<string>'
  71         else:
  72             self.filename = _decodeFilename(error.file)
  73
  74     cdef _setGeneric(self, int domain, int type, int level, int line,
  75                      message, filename):
  76         self.domain  = domain
  77         self.type    = type
  78         self.level   = level
  79         self.line    = line
  80         self.column  = 0
  81         self.message = message
  82         self.filename = filename
  83
  84     def __repr__(self):
  85         return u"%s:%d:%d:%s:%s:%s: %s" % (
  86             self.filename, self.line, self.column, self.level_name,
  87             self.domain_name, self.type_name, self.message)
  88
  89     property domain_name:
  90         def __get__(self):
  91             return ErrorDomains._getName(self.domain, u"unknown")
  92
  93     property type_name:
  94         def __get__(self):
  95             if self.domain == ErrorDomains.RELAXNGV:
  96                 getName = RelaxNGErrorTypes._getName
  97             else:
  98                 getName = ErrorTypes._getName
  99             return getName(self.type, u"unknown")
 100
 101     property level_name:
 102         def __get__(self):
 103             return ErrorLevels._getName(self.level, u"unknown")
 104
 105 cdef class _BaseErrorLog:
 106     cdef _LogEntry _first_error
 107     cdef readonly object last_error
 108     def __init__(self, first_error, last_error):
 109         self._first_error = first_error
 110         self.last_error = last_error
 111
 112     def copy(self):
 113         return _BaseErrorLog(self._first_error, self.last_error)
 114
 115     def __repr__(self):
 116         return u''
 117
 118     cdef void _receive(self, xmlerror.xmlError* error):
 119         cdef bint is_error
 120         cdef _LogEntry entry
 121         cdef _BaseErrorLog global_log
 122         entry = _LogEntry()
 123         entry._setError(error)
 124         is_error = error.level == xmlerror.XML_ERR_ERROR or \
 125                    error.level == xmlerror.XML_ERR_FATAL
 126         global_log = _getGlobalErrorLog()
 127         if global_log is not self:
 128             global_log.receive(entry)
 129             if is_error:
 130                 global_log.last_error = entry
 131         self.receive(entry)
 132         if is_error:
 133             self.last_error = entry
 134
 135     cdef void _receiveGeneric(self, int domain, int type, int level, int line,
 136                               message, filename):
 137         cdef bint is_error
 138         cdef _LogEntry entry
 139         cdef _BaseErrorLog global_log
 140         entry = _LogEntry()
 141         entry._setGeneric(domain, type, level, line, message, filename)
 142         is_error = level == xmlerror.XML_ERR_ERROR or \
 143                    level == xmlerror.XML_ERR_FATAL
 144         global_log = _getGlobalErrorLog()
 145         if global_log is not self:
 146             global_log.receive(entry)
 147             if is_error:
 148                 global_log.last_error = entry
 149         self.receive(entry)
 150         if is_error:
 151             self.last_error = entry
 152
 153     cdef _buildParseException(self, exctype, default_message):
 154         code = xmlerror.XML_ERR_INTERNAL_ERROR
 155         if self._first_error is None:
 156             return exctype(default_message, code, 0, 0)
 157         if self._first_error is None or \
 158                 self._first_error.message is None or \
 159                 not self._first_error.message:
 160             message = default_message
 161             line = 0
 162             column = 0
 163         else:
 164             message = self._first_error.message
 165             code = self._first_error.type
 166             line = self._first_error.line
 167             column = self._first_error.column
 168             if line > 0:
 169                 if column > 0:
 170                     message = u"%s, line %d, column %d" % (message, line, column)
 171                 else:
 172                     message = u"%s, line %d" % (message, line)
 173         return exctype(message, code, line, column)
 174
 175     cdef _buildExceptionMessage(self, default_message):
 176         if self._first_error is None:
 177             return default_message
 178         if self._first_error.message is not None and self._first_error.message:
 179             message = self._first_error.message
 180         elif default_message is None:
 181             return None
 182         else:
 183             message = default_message
 184         if self._first_error.line > 0:
 185             if self._first_error.column > 0:
 186                 message = u"%s, line %d, column %d" % (
 187                     message, self._first_error.line, self._first_error.column)
 188             else:
 189                 message = u"%s, line %d" % (message, self._first_error.line)
 190         return message
 191
 192 cdef class _ListErrorLog(_BaseErrorLog):
 193     u"Immutable base version of a list based error log."
 194     cdef list _entries
 195     def __init__(self, entries, first_error, last_error):
 196         if entries:
 197             if first_error is None:
 198                 first_error = entries[0]
 199             if last_error is None:
 200                 last_error = entries[-1]
 201         _BaseErrorLog.__init__(self, first_error, last_error)
 202         self._entries = entries
 203
 204     def copy(self):
 205         u"""Creates a shallow copy of this error log.  Reuses the list of
 206         entries.
 207         """
 208         return _ListErrorLog(self._entries, self._first_error, self.last_error)
 209
 210     def __iter__(self):
 211         return iter(self._entries)
 212
 213     def __repr__(self):
 214         cdef list l = []
 215         for entry in self._entries:
 216             l.append(repr(entry))
 217         return u'\n'.join(l)
 218
 219     def __getitem__(self, index):
 220         return self._entries[index]
 221
 222     def __len__(self):
 223         return len(self._entries)
 224
 225     def __contains__(self, error_type):
 226         for entry in self._entries:
 227             if entry.type == error_type:
 228                 return True
 229         return False
 230
 231     def __nonzero__(self):
 232         cdef bint result
 233         result = self._entries
 234         return result
 235
 236     def filter_domains(self, domains):
 237         u"""Filter the errors by the given domains and return a new error log
 238         containing the matches.
 239         """
 240         cdef _LogEntry entry
 241         cdef list filtered = []
 242         if not python.PySequence_Check(domains):
 243             domains = (domains,)
 244         for entry in self._entries:
 245             if entry.domain in domains:
 246                 filtered.append(entry)
 247         return _ListErrorLog(filtered, None, None)
 248
 249     def filter_types(self, types):
 250         u"""filter_types(self, types)
 251
 252         Filter the errors by the given types and return a new error
 253         log containing the matches.
 254         """
 255         cdef _LogEntry entry
 256         cdef list filtered = []
 257         if not python.PySequence_Check(types):
 258             types = (types,)
 259         for entry in self._entries:
 260             if entry.type in types:
 261                 filtered.append(entry)
 262         return _ListErrorLog(filtered, None, None)
 263
 264     def filter_levels(self, levels):
 265         u"""filter_levels(self, levels)
 266
 267         Filter the errors by the given error levels and return a new
 268         error log containing the matches.
 269         """
 270         cdef _LogEntry entry
 271         cdef list filtered = []
 272         if not python.PySequence_Check(levels):
 273             levels = (levels,)
 274         for entry in self._entries:
 275             if entry.level in levels:
 276                 filtered.append(entry)
 277         return _ListErrorLog(filtered, None, None)
 278
 279     def filter_from_level(self, level):
 280         u"""filter_from_level(self, level)
 281
 282         Return a log with all messages of the requested level of worse.
 283         """
 284         cdef _LogEntry entry
 285         cdef list filtered = []
 286         for entry in self._entries:
 287             if entry.level >= level:
 288                 filtered.append(entry)
 289         return _ListErrorLog(filtered, None, None)
 290
 291     def filter_from_fatals(self):
 292         u"""filter_from_fatals(self)
 293
 294         Convenience method to get all fatal error messages.
 295         """
 296         return self.filter_from_level(ErrorLevels.FATAL)
 297
 298     def filter_from_errors(self):
 299         u"""filter_from_errors(self)
 300
 301         Convenience method to get all error messages or worse.
 302         """
 303         return self.filter_from_level(ErrorLevels.ERROR)
 304
 305     def filter_from_warnings(self):
 306         u"""filter_from_warnings(self)
 307
 308         Convenience method to get all warnings or worse.
 309         """
 310         return self.filter_from_level(ErrorLevels.WARNING)
 311
 312 cdef class _ErrorLog(_ListErrorLog):
 313     def __init__(self):
 314         _ListErrorLog.__init__(self, [], None, None)
 315
 316     cdef void connect(self):
 317         self._first_error = None
 318         del self._entries[:]
 319         connectErrorLog(<void*>self)
 320
 321     cdef void disconnect(self):
 322         connectErrorLog(NULL)
 323
 324     def clear(self):
 325         self._first_error = None
 326         del self._entries[:]
 327
 328     def copy(self):
 329         u"""Creates a shallow copy of this error log and the list of entries.
 330         """
 331         return _ListErrorLog(self._entries[:], self._first_error,
 332                              self.last_error)
 333
 334     def __iter__(self):
 335         return iter(self._entries[:])
 336
 337     def receive(self, entry):
 338         if self._first_error is None:
 339             self._first_error = entry
 340         self._entries.append(entry)
 341
 342 cdef class _DomainErrorLog(_ErrorLog):
 343     def __init__(self, domains):
 344         _ErrorLog.__init__(self)
 345         self._accepted_domains = tuple(domains)
 346
 347     def receive(self, entry):
 348         if entry.domain in self._accepted_domains:
 349             _ErrorLog.receive(self, entry)
 350
 351 cdef class _RotatingErrorLog(_ErrorLog):
 352     cdef int _max_len
 353     def __init__(self, max_len):
 354         _ErrorLog.__init__(self)
 355         self._max_len = max_len
 356
 357     def receive(self, entry):
 358         if python.PyList_GET_SIZE(self._entries) > self._max_len:
 359             del self._entries[0]
 360         self._entries.append(entry)
 361
 362 cdef class PyErrorLog(_BaseErrorLog):
 363     u"""PyErrorLog(self, logger_name=None)
 364     A global error log that connects to the Python stdlib logging package.
 365
 366     The constructor accepts an optional logger name.
 367
 368     If you want to change the mapping between libxml2's ErrorLevels and Python
 369     logging levels, you can modify the level_map dictionary from a subclass.
 370
 371     The default mapping is::
 372
 373             ErrorLevels.WARNING = logging.WARNING
 374             ErrorLevels.ERROR   = logging.ERROR
 375             ErrorLevels.FATAL   = logging.CRITICAL
 376
 377     You can also override the method ``receive()`` that takes a LogEntry
 378     object and calls ``self.log(log_entry, format_string, arg1, arg2, ...)``
 379     with appropriate data.
 380     """
 381     cdef readonly object level_map
 382     cdef object _map_level
 383     cdef object _log
 384     def __init__(self, logger_name=None):
 385         _BaseErrorLog.__init__(self, None, None)
 386         import logging
 387         self.level_map = {
 388             ErrorLevels.WARNING : logging.WARNING,
 389             ErrorLevels.ERROR   : logging.ERROR,
 390             ErrorLevels.FATAL   : logging.CRITICAL
 391             }
 392         self._map_level = self.level_map.get
 393         if logger_name:
 394             logger = logging.getLogger(logger_name)
 395         else:
 396             logger = logging.getLogger()
 397         self._log = logger.log
 398
 399     def copy(self):
 400         u"""Dummy method that returns an empty error log.
 401         """
 402         return _ListErrorLog([], None, None)
 403
 404     def log(self, log_entry, message, *args):
 405         u"""log(self, log_entry, message, *args)
 406
 407         Called by the .receive() method to log a _LogEntry instance to
 408         the Python logging system.  This handles the error level
 409         mapping.
 410
 411         In the default implementation, the ``message`` argument
 412         receives a complete log line, and there are no further
 413         ``args``.  To change the message format, it is best to
 414         override the .receive() method instead of this one.
 415         """
 416         self._log(
 417             self._map_level(log_entry.level, 0),
 418             message, *args
 419             )
 420
 421     def receive(self, _LogEntry log_entry):
 422         u"""receive(self, log_entry)
 423
 424         Receive a _LogEntry instance from the logging system.  Calls
 425         the .log() method with appropriate parameters::
 426
 427             self.log(log_entry, repr(log_entry))
 428
 429         You can override this method to provide your own log output
 430         format.
 431         """
 432         self.log(log_entry, repr(log_entry))
 433
 434 # thread-local, global list log to collect error output messages from
 435 # libxml2/libxslt
 436
 437 cdef _BaseErrorLog __GLOBAL_ERROR_LOG
 438 __GLOBAL_ERROR_LOG = _RotatingErrorLog(__MAX_LOG_SIZE)
 439
 440 cdef _BaseErrorLog _getGlobalErrorLog():
 441     u"""Retrieve the global error log of this thread."""
 442     cdef python.PyObject* thread_dict
 443     thread_dict = python.PyThreadState_GetDict()
 444     if thread_dict is NULL:
 445         return __GLOBAL_ERROR_LOG
 446     try:
 447         return (<object>thread_dict)[u"_GlobalErrorLog"]
 448     except KeyError:
 449         log = (<object>thread_dict)[u"_GlobalErrorLog"] = \
 450               _RotatingErrorLog(__MAX_LOG_SIZE)
 451         return log
 452
 453 cdef _setGlobalErrorLog(_BaseErrorLog log):
 454     u"""Set the global error log of this thread."""
 455     cdef python.PyObject* thread_dict
 456     thread_dict = python.PyThreadState_GetDict()
 457     if thread_dict is NULL:
 458         global __GLOBAL_ERROR_LOG
 459         __GLOBAL_ERROR_LOG = log
 460     else:
 461         (<object>thread_dict)[u"_GlobalErrorLog"] = log
 462
 463 cdef __copyGlobalErrorLog():
 464     u"Helper function for properties in exceptions."
 465     return _getGlobalErrorLog().copy()
 466
 467 def use_global_python_log(PyErrorLog log not None):
 468     u"""use_global_python_log(log)
 469
 470     Replace the global error log by an etree.PyErrorLog that uses the
 471     standard Python logging package.
 472
 473     Note that this disables access to the global error log from exceptions.
 474     Parsers, XSLT etc. will continue to provide their normal local error log.
 475
 476     Note: prior to lxml 2.2, this changed the error log globally.
 477     Since lxml 2.2, the global error log is local to a thread and this
 478     function will only set the global error log of the current thread.
 479     """
 480     _setGlobalErrorLog(log)
 481
 482
 483 # local log functions: forward error to logger object
 484 cdef void _forwardError(void* c_log_handler, xmlerror.xmlError* error) with gil:
 485     cdef _BaseErrorLog log_handler
 486     if c_log_handler is not NULL:
 487         log_handler = <_BaseErrorLog>c_log_handler
 488     else:
 489         log_handler = _getGlobalErrorLog()
 490     log_handler._receive(error)
 491
 492 cdef void _receiveError(void* c_log_handler, xmlerror.xmlError* error) nogil:
 493     # no Python objects here, may be called without thread context !
 494     # when we declare a Python object, Pyrex will INCREF(None) !
 495     if __DEBUG != 0:
 496         _forwardError(c_log_handler, error)
 497
 498 cdef void _receiveXSLTError(void* c_log_handler, char* msg, ...) nogil:
 499     # no Python objects here, may be called without thread context !
 500     # when we declare a Python object, Pyrex will INCREF(None) !
 501     cdef xmlerror.xmlError c_error
 502     cdef cstd.va_list args
 503     cdef char* c_text
 504     cdef char* c_message
 505     cdef char* c_element
 506     cdef int i, text_size, element_size
 507     if __DEBUG == 0 or msg is NULL:
 508         return
 509     if msg[0] == c'\n' or msg[0] == c'\0':
 510         return
 511
 512     cstd.va_start(args, msg)
 513     if msg[0] == c'%' and msg[1] == c's':
 514         c_text = cstd.va_charptr(args)
 515     else:
 516         c_text = NULL
 517     if cstd.strstr(msg, 'file %s'):
 518         c_error.file = cstd.va_charptr(args)
 519         if c_error.file and \
 520                 cstd.strncmp(c_error.file,
 521                             'string://__STRING__XSLT', 23) == 0:
 522             c_error.file = '<xslt>'
 523     else:
 524         c_error.file = NULL
 525     if cstd.strstr(msg, 'line %d'):
 526         c_error.line = cstd.va_int(args)
 527     else:
 528         c_error.line = 0
 529     if cstd.strstr(msg, 'element %s'):
 530         c_element = cstd.va_charptr(args)
 531     else:
 532         c_element = NULL
 533     cstd.va_end(args)
 534
 535     c_message = NULL
 536     if c_text is NULL:
 537         if c_element is not NULL and \
 538                 cstd.strchr(msg, c'%') == cstd.strrchr(msg, c'%'):
 539             # special case: a single occurrence of 'element %s'
 540             text_size    = cstd.strlen(msg)
 541             element_size = cstd.strlen(c_element)
 542             c_message = <char*>cstd.malloc(
 543                 (text_size + element_size + 1) * sizeof(char))
 544             cstd.sprintf(c_message, msg, c_element)
 545             c_error.message = c_message
 546         else:
 547             c_error.message = ''
 548     elif c_element is NULL:
 549         c_error.message = c_text
 550     else:
 551         text_size    = cstd.strlen(c_text)
 552         element_size = cstd.strlen(c_element)
 553         c_message = <char*>cstd.malloc(
 554             (text_size + 12 + element_size + 1) * sizeof(char))
 555         cstd.sprintf(c_message, "%s, element '%s'", c_text, c_element)
 556         c_error.message = c_message
 557
 558     c_error.domain = xmlerror.XML_FROM_XSLT
 559     c_error.code   = xmlerror.XML_ERR_OK    # what else?
 560     c_error.level  = xmlerror.XML_ERR_ERROR # what else?
 561     c_error.int2   = 0
 562
 563     _forwardError(c_log_handler, &c_error)
 564
 565     if c_message is not NULL:
 566         cstd.free(c_message)
 567
 568 ################################################################################
 569 ## CONSTANTS FROM "xmlerror.h" (or rather libxml-xmlerror.html)
 570 ################################################################################
 571
 572 cdef void __initErrorConstants():
 573     u"Called at setup time to parse the constants and build the classes below."
 574     cdef dict reverse_dict
 575     find_constants = re.compile(ur"\s*([a-zA-Z0-9_]+)\s*=\s*([0-9]+)").findall
 576     const_defs = ((ErrorLevels,          __ERROR_LEVELS),
 577                   (ErrorDomains,         __ERROR_DOMAINS),
 578                   (ErrorTypes,           __PARSER_ERROR_TYPES),
 579                   (RelaxNGErrorTypes,    __RELAXNG_ERROR_TYPES))
 580     for cls, constant_tuple in const_defs:
 581         reverse_dict = {}
 582         cls._names   = reverse_dict
 583         cls._getName = reverse_dict.get
 584         for constants in constant_tuple:
 585             #print len(constants) + 1
 586             for name, value in find_constants(constants):
 587                 value = int(value)
 588                 python.PyObject_SetAttr(cls, name, value)
 589                 reverse_dict[value] = name
 590
 591
 592 class ErrorLevels:
 593     u"Libxml2 error levels"
 594
 595 class ErrorDomains:
 596     u"Libxml2 error domains"
 597
 598 class ErrorTypes:
 599     u"Libxml2 error types"
 600
 601 class RelaxNGErrorTypes:
 602     u"Libxml2 RelaxNG error types"
 603
 604 # --- BEGIN: GENERATED CONSTANTS ---
 605
 606 # This section is generated by the script 'update-error-constants.py'.
 607
 608 # Constants are stored in tuples of strings, for which Pyrex generates very
 609 # efficient setup code.  To parse them, iterate over the tuples and parse each
 610 # line in each string independently.  Tuples of strings (instead of a plain
 611 # string) are required as some C-compilers of a certain well-known OS vendor
 612 # cannot handle strings that are a few thousand bytes in length.
 613
 614 cdef object __ERROR_LEVELS
 615 __ERROR_LEVELS = (u"""\
 616 NONE=0
 617 WARNING=1
 618 ERROR=2
 619 FATAL=3
 620 """,)
 621
 622 cdef object __ERROR_DOMAINS
 623 __ERROR_DOMAINS = (u"""\
 624 NONE=0
 625 PARSER=1
 626 TREE=2
 627 NAMESPACE=3
 628 DTD=4
 629 HTML=5
 630 MEMORY=6
 631 OUTPUT=7
 632 IO=8
 633 FTP=9
 634 HTTP=10
 635 XINCLUDE=11
 636 XPATH=12
 637 XPOINTER=13
 638 REGEXP=14
 639 DATATYPE=15
 640 SCHEMASP=16
 641 SCHEMASV=17
 642 RELAXNGP=18
 643 RELAXNGV=19
 644 CATALOG=20
 645 C14N=21
 646 XSLT=22
 647 VALID=23
 648 CHECK=24
 649 WRITER=25
 650 MODULE=26
 651 I18N=27
 652 SCHEMATRONV=28
 653 """,)
 654
 655 cdef object __PARSER_ERROR_TYPES
 656 __PARSER_ERROR_TYPES = (u"""\
 657 ERR_OK=0
 658 ERR_INTERNAL_ERROR=1
 659 ERR_NO_MEMORY=2
 660 ERR_DOCUMENT_START=3
 661 ERR_DOCUMENT_EMPTY=4
 662 ERR_DOCUMENT_END=5
 663 ERR_INVALID_HEX_CHARREF=6
 664 ERR_INVALID_DEC_CHARREF=7
 665 ERR_INVALID_CHARREF=8
 666 ERR_INVALID_CHAR=9
 667 ERR_CHARREF_AT_EOF=10
 668 ERR_CHARREF_IN_PROLOG=11
 669 ERR_CHARREF_IN_EPILOG=12
 670 ERR_CHARREF_IN_DTD=13
 671 ERR_ENTITYREF_AT_EOF=14
 672 ERR_ENTITYREF_IN_PROLOG=15
 673 ERR_ENTITYREF_IN_EPILOG=16
 674 ERR_ENTITYREF_IN_DTD=17
 675 ERR_PEREF_AT_EOF=18
 676 ERR_PEREF_IN_PROLOG=19
 677 ERR_PEREF_IN_EPILOG=20
 678 ERR_PEREF_IN_INT_SUBSET=21
 679 ERR_ENTITYREF_NO_NAME=22
 680 ERR_ENTITYREF_SEMICOL_MISSING=23
 681 ERR_PEREF_NO_NAME=24
 682 ERR_PEREF_SEMICOL_MISSING=25
 683 ERR_UNDECLARED_ENTITY=26
 684 WAR_UNDECLARED_ENTITY=27
 685 ERR_UNPARSED_ENTITY=28
 686 ERR_ENTITY_IS_EXTERNAL=29
 687 ERR_ENTITY_IS_PARAMETER=30
 688 ERR_UNKNOWN_ENCODING=31
 689 ERR_UNSUPPORTED_ENCODING=32
 690 ERR_STRING_NOT_STARTED=33
 691 ERR_STRING_NOT_CLOSED=34
 692 ERR_NS_DECL_ERROR=35
 693 ERR_ENTITY_NOT_STARTED=36
 694 ERR_ENTITY_NOT_FINISHED=37
 695 ERR_LT_IN_ATTRIBUTE=38
 696 ERR_ATTRIBUTE_NOT_STARTED=39
 697 ERR_ATTRIBUTE_NOT_FINISHED=40
 698 ERR_ATTRIBUTE_WITHOUT_VALUE=41
 699 ERR_ATTRIBUTE_REDEFINED=42
 700 ERR_LITERAL_NOT_STARTED=43
 701 ERR_LITERAL_NOT_FINISHED=44
 702 ERR_COMMENT_NOT_FINISHED=45
 703 ERR_PI_NOT_STARTED=46
 704 ERR_PI_NOT_FINISHED=47
 705 ERR_NOTATION_NOT_STARTED=48
 706 ERR_NOTATION_NOT_FINISHED=49
 707 ERR_ATTLIST_NOT_STARTED=50
 708 ERR_ATTLIST_NOT_FINISHED=51
 709 ERR_MIXED_NOT_STARTED=52
 710 ERR_MIXED_NOT_FINISHED=53
 711 ERR_ELEMCONTENT_NOT_STARTED=54
 712 ERR_ELEMCONTENT_NOT_FINISHED=55
 713 ERR_XMLDECL_NOT_STARTED=56
 714 ERR_XMLDECL_NOT_FINISHED=57
 715 ERR_CONDSEC_NOT_STARTED=58
 716 ERR_CONDSEC_NOT_FINISHED=59
 717 ERR_EXT_SUBSET_NOT_FINISHED=60
 718 ERR_DOCTYPE_NOT_FINISHED=61
 719 ERR_MISPLACED_CDATA_END=62
 720 ERR_CDATA_NOT_FINISHED=63
 721 ERR_RESERVED_XML_NAME=64
 722 ERR_SPACE_REQUIRED=65
 723 ERR_SEPARATOR_REQUIRED=66
 724 ERR_NMTOKEN_REQUIRED=67
 725 ERR_NAME_REQUIRED=68
 726 ERR_PCDATA_REQUIRED=69
 727 ERR_URI_REQUIRED=70
 728 ERR_PUBID_REQUIRED=71
 729 ERR_LT_REQUIRED=72
 730 ERR_GT_REQUIRED=73
 731 ERR_LTSLASH_REQUIRED=74
 732 ERR_EQUAL_REQUIRED=75
 733 ERR_TAG_NAME_MISMATCH=76
 734 ERR_TAG_NOT_FINISHED=77
 735 ERR_STANDALONE_VALUE=78
 736 """,
 737 u"""\
 738 ERR_ENCODING_NAME=79
 739 ERR_HYPHEN_IN_COMMENT=80
 740 ERR_INVALID_ENCODING=81
 741 ERR_EXT_ENTITY_STANDALONE=82
 742 ERR_CONDSEC_INVALID=83
 743 ERR_VALUE_REQUIRED=84
 744 ERR_NOT_WELL_BALANCED=85
 745 ERR_EXTRA_CONTENT=86
 746 ERR_ENTITY_CHAR_ERROR=87
 747 ERR_ENTITY_PE_INTERNAL=88
 748 ERR_ENTITY_LOOP=89
 749 ERR_ENTITY_BOUNDARY=90
 750 ERR_INVALID_URI=91
 751 ERR_URI_FRAGMENT=92
 752 WAR_CATALOG_PI=93
 753 ERR_NO_DTD=94
 754 ERR_CONDSEC_INVALID_KEYWORD=95
 755 ERR_VERSION_MISSING=96
 756 WAR_UNKNOWN_VERSION=97
 757 WAR_LANG_VALUE=98
 758 WAR_NS_URI=99
 759 WAR_NS_URI_RELATIVE=100
 760 ERR_MISSING_ENCODING=101
 761 WAR_SPACE_VALUE=102
 762 ERR_NOT_STANDALONE=103
 763 ERR_ENTITY_PROCESSING=104
 764 ERR_NOTATION_PROCESSING=105
 765 WAR_NS_COLUMN=106
 766 WAR_ENTITY_REDEFINED=107
 767 ERR_UNKNOWN_VERSION=108
 768 ERR_VERSION_MISMATCH=109
 769 NS_ERR_XML_NAMESPACE=200
 770 NS_ERR_UNDEFINED_NAMESPACE=201
 771 NS_ERR_QNAME=202
 772 NS_ERR_ATTRIBUTE_REDEFINED=203
 773 NS_ERR_EMPTY=204
 774 NS_ERR_COLON=205
 775 DTD_ATTRIBUTE_DEFAULT=500
 776 DTD_ATTRIBUTE_REDEFINED=501
 777 DTD_ATTRIBUTE_VALUE=502
 778 DTD_CONTENT_ERROR=503
 779 DTD_CONTENT_MODEL=504
 780 DTD_CONTENT_NOT_DETERMINIST=505
 781 DTD_DIFFERENT_PREFIX=506
 782 DTD_ELEM_DEFAULT_NAMESPACE=507
 783 DTD_ELEM_NAMESPACE=508
 784 DTD_ELEM_REDEFINED=509
 785 DTD_EMPTY_NOTATION=510
 786 DTD_ENTITY_TYPE=511
 787 DTD_ID_FIXED=512
 788 DTD_ID_REDEFINED=513
 789 DTD_ID_SUBSET=514
 790 DTD_INVALID_CHILD=515
 791 DTD_INVALID_DEFAULT=516
 792 DTD_LOAD_ERROR=517
 793 DTD_MISSING_ATTRIBUTE=518
 794 DTD_MIXED_CORRUPT=519
 795 DTD_MULTIPLE_ID=520
 796 DTD_NO_DOC=521
 797 DTD_NO_DTD=522
 798 DTD_NO_ELEM_NAME=523
 799 DTD_NO_PREFIX=524
 800 DTD_NO_ROOT=525
 801 DTD_NOTATION_REDEFINED=526
 802 DTD_NOTATION_VALUE=527
 803 DTD_NOT_EMPTY=528
 804 DTD_NOT_PCDATA=529
 805 DTD_NOT_STANDALONE=530
 806 DTD_ROOT_NAME=531
 807 DTD_STANDALONE_WHITE_SPACE=532
 808 DTD_UNKNOWN_ATTRIBUTE=533
 809 DTD_UNKNOWN_ELEM=534
 810 DTD_UNKNOWN_ENTITY=535
 811 DTD_UNKNOWN_ID=536
 812 DTD_UNKNOWN_NOTATION=537
 813 DTD_STANDALONE_DEFAULTED=538
 814 DTD_XMLID_VALUE=539
 815 DTD_XMLID_TYPE=540
 816 DTD_DUP_TOKEN=541
 817 HTML_STRUCURE_ERROR=800
 818 HTML_UNKNOWN_TAG=801
 819 RNGP_ANYNAME_ATTR_ANCESTOR=1000
 820 RNGP_ATTR_CONFLICT=1001
 821 RNGP_ATTRIBUTE_CHILDREN=1002
 822 RNGP_ATTRIBUTE_CONTENT=1003
 823 """,
 824 u"""\
 825 RNGP_ATTRIBUTE_EMPTY=1004
 826 RNGP_ATTRIBUTE_NOOP=1005
 827 RNGP_CHOICE_CONTENT=1006
 828 RNGP_CHOICE_EMPTY=1007
 829 RNGP_CREATE_FAILURE=1008
 830 RNGP_DATA_CONTENT=1009
 831 RNGP_DEF_CHOICE_AND_INTERLEAVE=1010
 832 RNGP_DEFINE_CREATE_FAILED=1011
 833 RNGP_DEFINE_EMPTY=1012
 834 RNGP_DEFINE_MISSING=1013
 835 RNGP_DEFINE_NAME_MISSING=1014
 836 RNGP_ELEM_CONTENT_EMPTY=1015
 837 RNGP_ELEM_CONTENT_ERROR=1016
 838 RNGP_ELEMENT_EMPTY=1017
 839 RNGP_ELEMENT_CONTENT=1018
 840 RNGP_ELEMENT_NAME=1019
 841 RNGP_ELEMENT_NO_CONTENT=1020
 842 RNGP_ELEM_TEXT_CONFLICT=1021
 843 RNGP_EMPTY=1022
 844 RNGP_EMPTY_CONSTRUCT=1023
 845 RNGP_EMPTY_CONTENT=1024
 846 RNGP_EMPTY_NOT_EMPTY=1025
 847 RNGP_ERROR_TYPE_LIB=1026
 848 RNGP_EXCEPT_EMPTY=1027
 849 RNGP_EXCEPT_MISSING=1028
 850 RNGP_EXCEPT_MULTIPLE=1029
 851 RNGP_EXCEPT_NO_CONTENT=1030
 852 RNGP_EXTERNALREF_EMTPY=1031
 853 RNGP_EXTERNAL_REF_FAILURE=1032
 854 RNGP_EXTERNALREF_RECURSE=1033
 855 RNGP_FORBIDDEN_ATTRIBUTE=1034
 856 RNGP_FOREIGN_ELEMENT=1035
 857 RNGP_GRAMMAR_CONTENT=1036
 858 RNGP_GRAMMAR_EMPTY=1037
 859 RNGP_GRAMMAR_MISSING=1038
 860 RNGP_GRAMMAR_NO_START=1039
 861 RNGP_GROUP_ATTR_CONFLICT=1040
 862 RNGP_HREF_ERROR=1041
 863 RNGP_INCLUDE_EMPTY=1042
 864 RNGP_INCLUDE_FAILURE=1043
 865 RNGP_INCLUDE_RECURSE=1044
 866 RNGP_INTERLEAVE_ADD=1045
 867 RNGP_INTERLEAVE_CREATE_FAILED=1046
 868 RNGP_INTERLEAVE_EMPTY=1047
 869 RNGP_INTERLEAVE_NO_CONTENT=1048
 870 RNGP_INVALID_DEFINE_NAME=1049
 871 RNGP_INVALID_URI=1050
 872 RNGP_INVALID_VALUE=1051
 873 RNGP_MISSING_HREF=1052
 874 RNGP_NAME_MISSING=1053
 875 RNGP_NEED_COMBINE=1054
 876 RNGP_NOTALLOWED_NOT_EMPTY=1055
 877 RNGP_NSNAME_ATTR_ANCESTOR=1056
 878 RNGP_NSNAME_NO_NS=1057
 879 RNGP_PARAM_FORBIDDEN=1058
 880 RNGP_PARAM_NAME_MISSING=1059
 881 RNGP_PARENTREF_CREATE_FAILED=1060
 882 RNGP_PARENTREF_NAME_INVALID=1061
 883 RNGP_PARENTREF_NO_NAME=1062
 884 RNGP_PARENTREF_NO_PARENT=1063
 885 RNGP_PARENTREF_NOT_EMPTY=1064
 886 RNGP_PARSE_ERROR=1065
 887 RNGP_PAT_ANYNAME_EXCEPT_ANYNAME=1066
 888 RNGP_PAT_ATTR_ATTR=1067
 889 RNGP_PAT_ATTR_ELEM=1068
 890 RNGP_PAT_DATA_EXCEPT_ATTR=1069
 891 RNGP_PAT_DATA_EXCEPT_ELEM=1070
 892 RNGP_PAT_DATA_EXCEPT_EMPTY=1071
 893 RNGP_PAT_DATA_EXCEPT_GROUP=1072
 894 RNGP_PAT_DATA_EXCEPT_INTERLEAVE=1073
 895 RNGP_PAT_DATA_EXCEPT_LIST=1074
 896 """,
 897 u"""\
 898 RNGP_PAT_DATA_EXCEPT_ONEMORE=1075
 899 RNGP_PAT_DATA_EXCEPT_REF=1076
 900 RNGP_PAT_DATA_EXCEPT_TEXT=1077
 901 RNGP_PAT_LIST_ATTR=1078
 902 RNGP_PAT_LIST_ELEM=1079
 903 RNGP_PAT_LIST_INTERLEAVE=1080
 904 RNGP_PAT_LIST_LIST=1081
 905 RNGP_PAT_LIST_REF=1082
 906 RNGP_PAT_LIST_TEXT=1083
 907 RNGP_PAT_NSNAME_EXCEPT_ANYNAME=1084
 908 RNGP_PAT_NSNAME_EXCEPT_NSNAME=1085
 909 RNGP_PAT_ONEMORE_GROUP_ATTR=1086
 910 RNGP_PAT_ONEMORE_INTERLEAVE_ATTR=1087
 911 RNGP_PAT_START_ATTR=1088
 912 RNGP_PAT_START_DATA=1089
 913 RNGP_PAT_START_EMPTY=1090
 914 RNGP_PAT_START_GROUP=1091
 915 RNGP_PAT_START_INTERLEAVE=1092
 916 RNGP_PAT_START_LIST=1093
 917 RNGP_PAT_START_ONEMORE=1094
 918 RNGP_PAT_START_TEXT=1095
 919 RNGP_PAT_START_VALUE=1096
 920 RNGP_PREFIX_UNDEFINED=1097
 921 RNGP_REF_CREATE_FAILED=1098
 922 RNGP_REF_CYCLE=1099
 923 RNGP_REF_NAME_INVALID=1100
 924 RNGP_REF_NO_DEF=1101
 925 RNGP_REF_NO_NAME=1102
 926 RNGP_REF_NOT_EMPTY=1103
 927 RNGP_START_CHOICE_AND_INTERLEAVE=1104
 928 RNGP_START_CONTENT=1105
 929 RNGP_START_EMPTY=1106
 930 RNGP_START_MISSING=1107
 931 RNGP_TEXT_EXPECTED=1108
 932 RNGP_TEXT_HAS_CHILD=1109
 933 RNGP_TYPE_MISSING=1110
 934 RNGP_TYPE_NOT_FOUND=1111
 935 RNGP_TYPE_VALUE=1112
 936 RNGP_UNKNOWN_ATTRIBUTE=1113
 937 RNGP_UNKNOWN_COMBINE=1114
 938 RNGP_UNKNOWN_CONSTRUCT=1115
 939 RNGP_UNKNOWN_TYPE_LIB=1116
 940 RNGP_URI_FRAGMENT=1117
 941 RNGP_URI_NOT_ABSOLUTE=1118
 942 RNGP_VALUE_EMPTY=1119
 943 RNGP_VALUE_NO_CONTENT=1120
 944 RNGP_XMLNS_NAME=1121
 945 RNGP_XML_NS=1122
 946 XPATH_EXPRESSION_OK=1200
 947 XPATH_NUMBER_ERROR=1201
 948 XPATH_UNFINISHED_LITERAL_ERROR=1202
 949 XPATH_START_LITERAL_ERROR=1203
 950 XPATH_VARIABLE_REF_ERROR=1204
 951 XPATH_UNDEF_VARIABLE_ERROR=1205
 952 XPATH_INVALID_PREDICATE_ERROR=1206
 953 XPATH_EXPR_ERROR=1207
 954 XPATH_UNCLOSED_ERROR=1208
 955 XPATH_UNKNOWN_FUNC_ERROR=1209
 956 XPATH_INVALID_OPERAND=1210
 957 XPATH_INVALID_TYPE=1211
 958 XPATH_INVALID_ARITY=1212
 959 XPATH_INVALID_CTXT_SIZE=1213
 960 XPATH_INVALID_CTXT_POSITION=1214
 961 XPATH_MEMORY_ERROR=1215
 962 XPTR_SYNTAX_ERROR=1216
 963 XPTR_RESOURCE_ERROR=1217
 964 XPTR_SUB_RESOURCE_ERROR=1218
 965 XPATH_UNDEF_PREFIX_ERROR=1219
 966 XPATH_ENCODING_ERROR=1220
 967 XPATH_INVALID_CHAR_ERROR=1221
 968 TREE_INVALID_HEX=1300
 969 TREE_INVALID_DEC=1301
 970 TREE_UNTERMINATED_ENTITY=1302
 971 """,
 972 u"""\
 973 TREE_NOT_UTF8=1303
 974 SAVE_NOT_UTF8=1400
 975 SAVE_CHAR_INVALID=1401
 976 SAVE_NO_DOCTYPE=1402
 977 SAVE_UNKNOWN_ENCODING=1403
 978 REGEXP_COMPILE_ERROR=1450
 979 IO_UNKNOWN=1500
 980 IO_EACCES=1501
 981 IO_EAGAIN=1502
 982 IO_EBADF=1503
 983 IO_EBADMSG=1504
 984 IO_EBUSY=1505
 985 IO_ECANCELED=1506
 986 IO_ECHILD=1507
 987 IO_EDEADLK=1508
 988 IO_EDOM=1509
 989 IO_EEXIST=1510
 990 IO_EFAULT=1511
 991 IO_EFBIG=1512
 992 IO_EINPROGRESS=1513
 993 IO_EINTR=1514
 994 IO_EINVAL=1515
 995 IO_EIO=1516
 996 IO_EISDIR=1517
 997 IO_EMFILE=1518
 998 IO_EMLINK=1519
 999 IO_EMSGSIZE=1520
1000 IO_ENAMETOOLONG=1521
1001 IO_ENFILE=1522
1002 IO_ENODEV=1523
1003 IO_ENOENT=1524
1004 IO_ENOEXEC=1525
1005 IO_ENOLCK=1526
1006 IO_ENOMEM=1527
1007 IO_ENOSPC=1528
1008 IO_ENOSYS=1529
1009 IO_ENOTDIR=1530
1010 IO_ENOTEMPTY=1531
1011 IO_ENOTSUP=1532
1012 IO_ENOTTY=1533
1013 IO_ENXIO=1534
1014 IO_EPERM=1535
1015 IO_EPIPE=1536
1016 IO_ERANGE=1537
1017 IO_EROFS=1538
1018 IO_ESPIPE=1539
1019 IO_ESRCH=1540
1020 IO_ETIMEDOUT=1541
1021 IO_EXDEV=1542
1022 IO_NETWORK_ATTEMPT=1543
1023 IO_ENCODER=1544
1024 IO_FLUSH=1545
1025 IO_WRITE=1546
1026 IO_NO_INPUT=1547
1027 IO_BUFFER_FULL=1548
1028 IO_LOAD_ERROR=1549
1029 IO_ENOTSOCK=1550
1030 IO_EISCONN=1551
1031 IO_ECONNREFUSED=1552
1032 IO_ENETUNREACH=1553
1033 IO_EADDRINUSE=1554
1034 IO_EALREADY=1555
1035 IO_EAFNOSUPPORT=1556
1036 XINCLUDE_RECURSION=1600
1037 XINCLUDE_PARSE_VALUE=1601
1038 XINCLUDE_ENTITY_DEF_MISMATCH=1602
1039 XINCLUDE_NO_HREF=1603
1040 XINCLUDE_NO_FALLBACK=1604
1041 XINCLUDE_HREF_URI=1605
1042 XINCLUDE_TEXT_FRAGMENT=1606
1043 XINCLUDE_TEXT_DOCUMENT=1607
1044 XINCLUDE_INVALID_CHAR=1608
1045 XINCLUDE_BUILD_FAILED=1609
1046 XINCLUDE_UNKNOWN_ENCODING=1610
1047 XINCLUDE_MULTIPLE_ROOT=1611
1048 XINCLUDE_XPTR_FAILED=1612
1049 XINCLUDE_XPTR_RESULT=1613
1050 XINCLUDE_INCLUDE_IN_INCLUDE=1614
1051 XINCLUDE_FALLBACKS_IN_INCLUDE=1615
1052 XINCLUDE_FALLBACK_NOT_IN_INCLUDE=1616
1053 XINCLUDE_DEPRECATED_NS=1617
1054 XINCLUDE_FRAGMENT_ID=1618
1055 CATALOG_MISSING_ATTR=1650
1056 CATALOG_ENTRY_BROKEN=1651
1057 CATALOG_PREFER_VALUE=1652
1058 CATALOG_NOT_CATALOG=1653
1059 CATALOG_RECURSION=1654
1060 SCHEMAP_PREFIX_UNDEFINED=1700
1061 SCHEMAP_ATTRFORMDEFAULT_VALUE=1701
1062 SCHEMAP_ATTRGRP_NONAME_NOREF=1702
1063 SCHEMAP_ATTR_NONAME_NOREF=1703
1064 SCHEMAP_COMPLEXTYPE_NONAME_NOREF=1704
1065 SCHEMAP_ELEMFORMDEFAULT_VALUE=1705
1066 SCHEMAP_ELEM_NONAME_NOREF=1706
1067 """,
1068 u"""\
1069 SCHEMAP_EXTENSION_NO_BASE=1707
1070 SCHEMAP_FACET_NO_VALUE=1708
1071 SCHEMAP_FAILED_BUILD_IMPORT=1709
1072 SCHEMAP_GROUP_NONAME_NOREF=1710
1073 SCHEMAP_IMPORT_NAMESPACE_NOT_URI=1711
1074 SCHEMAP_IMPORT_REDEFINE_NSNAME=1712
1075 SCHEMAP_IMPORT_SCHEMA_NOT_URI=1713
1076 SCHEMAP_INVALID_BOOLEAN=1714
1077 SCHEMAP_INVALID_ENUM=1715
1078 SCHEMAP_INVALID_FACET=1716
1079 SCHEMAP_INVALID_FACET_VALUE=1717
1080 SCHEMAP_INVALID_MAXOCCURS=1718
1081 SCHEMAP_INVALID_MINOCCURS=1719
1082 SCHEMAP_INVALID_REF_AND_SUBTYPE=1720
1083 SCHEMAP_INVALID_WHITE_SPACE=1721
1084 SCHEMAP_NOATTR_NOREF=1722
1085 SCHEMAP_NOTATION_NO_NAME=1723
1086 SCHEMAP_NOTYPE_NOREF=1724
1087 SCHEMAP_REF_AND_SUBTYPE=1725
1088 SCHEMAP_RESTRICTION_NONAME_NOREF=1726
1089 SCHEMAP_SIMPLETYPE_NONAME=1727
1090 SCHEMAP_TYPE_AND_SUBTYPE=1728
1091 SCHEMAP_UNKNOWN_ALL_CHILD=1729
1092 SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD=1730
1093 SCHEMAP_UNKNOWN_ATTR_CHILD=1731
1094 SCHEMAP_UNKNOWN_ATTRGRP_CHILD=1732
1095 SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP=1733
1096 SCHEMAP_UNKNOWN_BASE_TYPE=1734
1097 SCHEMAP_UNKNOWN_CHOICE_CHILD=1735
1098 SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD=1736
1099 SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD=1737
1100 SCHEMAP_UNKNOWN_ELEM_CHILD=1738
1101 SCHEMAP_UNKNOWN_EXTENSION_CHILD=1739
1102 SCHEMAP_UNKNOWN_FACET_CHILD=1740
1103 SCHEMAP_UNKNOWN_FACET_TYPE=1741
1104 SCHEMAP_UNKNOWN_GROUP_CHILD=1742
1105 SCHEMAP_UNKNOWN_IMPORT_CHILD=1743
1106 SCHEMAP_UNKNOWN_LIST_CHILD=1744
1107 SCHEMAP_UNKNOWN_NOTATION_CHILD=1745
1108 SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD=1746
1109 SCHEMAP_UNKNOWN_REF=1747
1110 SCHEMAP_UNKNOWN_RESTRICTION_CHILD=1748
1111 SCHEMAP_UNKNOWN_SCHEMAS_CHILD=1749
1112 SCHEMAP_UNKNOWN_SEQUENCE_CHILD=1750
1113 SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD=1751
1114 SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD=1752
1115 SCHEMAP_UNKNOWN_TYPE=1753
1116 SCHEMAP_UNKNOWN_UNION_CHILD=1754
1117 SCHEMAP_ELEM_DEFAULT_FIXED=1755
1118 SCHEMAP_REGEXP_INVALID=1756
1119 SCHEMAP_FAILED_LOAD=1757
1120 SCHEMAP_NOTHING_TO_PARSE=1758
1121 SCHEMAP_NOROOT=1759
1122 SCHEMAP_REDEFINED_GROUP=1760
1123 SCHEMAP_REDEFINED_TYPE=1761
1124 SCHEMAP_REDEFINED_ELEMENT=1762
1125 SCHEMAP_REDEFINED_ATTRGROUP=1763
1126 SCHEMAP_REDEFINED_ATTR=1764
1127 SCHEMAP_REDEFINED_NOTATION=1765
1128 SCHEMAP_FAILED_PARSE=1766
1129 SCHEMAP_UNKNOWN_PREFIX=1767
1130 """,
1131 u"""\
1132 SCHEMAP_DEF_AND_PREFIX=1768
1133 SCHEMAP_UNKNOWN_INCLUDE_CHILD=1769
1134 SCHEMAP_INCLUDE_SCHEMA_NOT_URI=1770
1135 SCHEMAP_INCLUDE_SCHEMA_NO_URI=1771
1136 SCHEMAP_NOT_SCHEMA=1772
1137 SCHEMAP_UNKNOWN_MEMBER_TYPE=1773
1138 SCHEMAP_INVALID_ATTR_USE=1774
1139 SCHEMAP_RECURSIVE=1775
1140 SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE=1776
1141 SCHEMAP_INVALID_ATTR_COMBINATION=1777
1142 SCHEMAP_INVALID_ATTR_INLINE_COMBINATION=1778
1143 SCHEMAP_MISSING_SIMPLETYPE_CHILD=1779
1144 SCHEMAP_INVALID_ATTR_NAME=1780
1145 SCHEMAP_REF_AND_CONTENT=1781
1146 SCHEMAP_CT_PROPS_CORRECT_1=1782
1147 SCHEMAP_CT_PROPS_CORRECT_2=1783
1148 SCHEMAP_CT_PROPS_CORRECT_3=1784
1149 SCHEMAP_CT_PROPS_CORRECT_4=1785
1150 SCHEMAP_CT_PROPS_CORRECT_5=1786
1151 SCHEMAP_DERIVATION_OK_RESTRICTION_1=1787
1152 SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1=1788
1153 SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2=1789
1154 SCHEMAP_DERIVATION_OK_RESTRICTION_2_2=1790
1155 SCHEMAP_DERIVATION_OK_RESTRICTION_3=1791
1156 SCHEMAP_WILDCARD_INVALID_NS_MEMBER=1792
1157 SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE=1793
1158 SCHEMAP_UNION_NOT_EXPRESSIBLE=1794
1159 SCHEMAP_SRC_IMPORT_3_1=1795
1160 SCHEMAP_SRC_IMPORT_3_2=1796
1161 SCHEMAP_DERIVATION_OK_RESTRICTION_4_1=1797
1162 SCHEMAP_DERIVATION_OK_RESTRICTION_4_2=1798
1163 SCHEMAP_DERIVATION_OK_RESTRICTION_4_3=1799
1164 SCHEMAP_COS_CT_EXTENDS_1_3=1800
1165 SCHEMAV_NOROOT=1801
1166 SCHEMAV_UNDECLAREDELEM=1802
1167 SCHEMAV_NOTTOPLEVEL=1803
1168 SCHEMAV_MISSING=1804
1169 SCHEMAV_WRONGELEM=1805
1170 SCHEMAV_NOTYPE=1806
1171 SCHEMAV_NOROLLBACK=1807
1172 SCHEMAV_ISABSTRACT=1808
1173 SCHEMAV_NOTEMPTY=1809
1174 SCHEMAV_ELEMCONT=1810
1175 SCHEMAV_HAVEDEFAULT=1811
1176 SCHEMAV_NOTNILLABLE=1812
1177 SCHEMAV_EXTRACONTENT=1813
1178 SCHEMAV_INVALIDATTR=1814
1179 SCHEMAV_INVALIDELEM=1815
1180 SCHEMAV_NOTDETERMINIST=1816
1181 SCHEMAV_CONSTRUCT=1817
1182 SCHEMAV_INTERNAL=1818
1183 SCHEMAV_NOTSIMPLE=1819
1184 SCHEMAV_ATTRUNKNOWN=1820
1185 SCHEMAV_ATTRINVALID=1821
1186 SCHEMAV_VALUE=1822
1187 SCHEMAV_FACET=1823
1188 SCHEMAV_CVC_DATATYPE_VALID_1_2_1=1824
1189 SCHEMAV_CVC_DATATYPE_VALID_1_2_2=1825
1190 SCHEMAV_CVC_DATATYPE_VALID_1_2_3=1826
1191 SCHEMAV_CVC_TYPE_3_1_1=1827
1192 SCHEMAV_CVC_TYPE_3_1_2=1828
1193 SCHEMAV_CVC_FACET_VALID=1829
1194 SCHEMAV_CVC_LENGTH_VALID=1830
1195 """,
1196 u"""\
1197 SCHEMAV_CVC_MINLENGTH_VALID=1831
1198 SCHEMAV_CVC_MAXLENGTH_VALID=1832
1199 SCHEMAV_CVC_MININCLUSIVE_VALID=1833
1200 SCHEMAV_CVC_MAXINCLUSIVE_VALID=1834
1201 SCHEMAV_CVC_MINEXCLUSIVE_VALID=1835
1202 SCHEMAV_CVC_MAXEXCLUSIVE_VALID=1836
1203 SCHEMAV_CVC_TOTALDIGITS_VALID=1837
1204 SCHEMAV_CVC_FRACTIONDIGITS_VALID=1838
1205 SCHEMAV_CVC_PATTERN_VALID=1839
1206 SCHEMAV_CVC_ENUMERATION_VALID=1840
1207 SCHEMAV_CVC_COMPLEX_TYPE_2_1=1841
1208 SCHEMAV_CVC_COMPLEX_TYPE_2_2=1842
1209 SCHEMAV_CVC_COMPLEX_TYPE_2_3=1843
1210 SCHEMAV_CVC_COMPLEX_TYPE_2_4=1844
1211 SCHEMAV_CVC_ELT_1=1845
1212 SCHEMAV_CVC_ELT_2=1846
1213 SCHEMAV_CVC_ELT_3_1=1847
1214 SCHEMAV_CVC_ELT_3_2_1=1848
1215 SCHEMAV_CVC_ELT_3_2_2=1849
1216 SCHEMAV_CVC_ELT_4_1=1850
1217 SCHEMAV_CVC_ELT_4_2=1851
1218 SCHEMAV_CVC_ELT_4_3=1852
1219 SCHEMAV_CVC_ELT_5_1_1=1853
1220 SCHEMAV_CVC_ELT_5_1_2=1854
1221 SCHEMAV_CVC_ELT_5_2_1=1855
1222 SCHEMAV_CVC_ELT_5_2_2_1=1856
1223 SCHEMAV_CVC_ELT_5_2_2_2_1=1857
1224 SCHEMAV_CVC_ELT_5_2_2_2_2=1858
1225 SCHEMAV_CVC_ELT_6=1859
1226 SCHEMAV_CVC_ELT_7=1860
1227 SCHEMAV_CVC_ATTRIBUTE_1=1861
1228 SCHEMAV_CVC_ATTRIBUTE_2=1862
1229 SCHEMAV_CVC_ATTRIBUTE_3=1863
1230 SCHEMAV_CVC_ATTRIBUTE_4=1864
1231 SCHEMAV_CVC_COMPLEX_TYPE_3_1=1865
1232 SCHEMAV_CVC_COMPLEX_TYPE_3_2_1=1866
1233 SCHEMAV_CVC_COMPLEX_TYPE_3_2_2=1867
1234 SCHEMAV_CVC_COMPLEX_TYPE_4=1868
1235 SCHEMAV_CVC_COMPLEX_TYPE_5_1=1869
1236 SCHEMAV_CVC_COMPLEX_TYPE_5_2=1870
1237 SCHEMAV_ELEMENT_CONTENT=1871
1238 SCHEMAV_DOCUMENT_ELEMENT_MISSING=1872
1239 SCHEMAV_CVC_COMPLEX_TYPE_1=1873
1240 SCHEMAV_CVC_AU=1874
1241 SCHEMAV_CVC_TYPE_1=1875
1242 SCHEMAV_CVC_TYPE_2=1876
1243 SCHEMAV_CVC_IDC=1877
1244 SCHEMAV_CVC_WILDCARD=1878
1245 SCHEMAV_MISC=1879
1246 XPTR_UNKNOWN_SCHEME=1900
1247 XPTR_CHILDSEQ_START=1901
1248 XPTR_EVAL_FAILED=1902
1249 XPTR_EXTRA_OBJECTS=1903
1250 C14N_CREATE_CTXT=1950
1251 C14N_REQUIRES_UTF8=1951
1252 C14N_CREATE_STACK=1952
1253 C14N_INVALID_NODE=1953
1254 C14N_UNKNOW_NODE=1954
1255 C14N_RELATIVE_NAMESPACE=1955
1256 FTP_PASV_ANSWER=2000
1257 FTP_EPSV_ANSWER=2001
1258 FTP_ACCNT=2002
1259 FTP_URL_SYNTAX=2003
1260 HTTP_URL_SYNTAX=2020
1261 HTTP_USE_IP=2021
1262 HTTP_UNKNOWN_HOST=2022
1263 SCHEMAP_SRC_SIMPLE_TYPE_1=3000
1264 SCHEMAP_SRC_SIMPLE_TYPE_2=3001
1265 SCHEMAP_SRC_SIMPLE_TYPE_3=3002
1266 SCHEMAP_SRC_SIMPLE_TYPE_4=3003
1267 """,
1268 u"""\
1269 SCHEMAP_SRC_RESOLVE=3004
1270 SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE=3005
1271 SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE=3006
1272 SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES=3007
1273 SCHEMAP_ST_PROPS_CORRECT_1=3008
1274 SCHEMAP_ST_PROPS_CORRECT_2=3009
1275 SCHEMAP_ST_PROPS_CORRECT_3=3010
1276 SCHEMAP_COS_ST_RESTRICTS_1_1=3011
1277 SCHEMAP_COS_ST_RESTRICTS_1_2=3012
1278 SCHEMAP_COS_ST_RESTRICTS_1_3_1=3013
1279 SCHEMAP_COS_ST_RESTRICTS_1_3_2=3014
1280 SCHEMAP_COS_ST_RESTRICTS_2_1=3015
1281 SCHEMAP_COS_ST_RESTRICTS_2_3_1_1=3016
1282 SCHEMAP_COS_ST_RESTRICTS_2_3_1_2=3017
1283 SCHEMAP_COS_ST_RESTRICTS_2_3_2_1=3018
1284 SCHEMAP_COS_ST_RESTRICTS_2_3_2_2=3019
1285 SCHEMAP_COS_ST_RESTRICTS_2_3_2_3=3020
1286 SCHEMAP_COS_ST_RESTRICTS_2_3_2_4=3021
1287 SCHEMAP_COS_ST_RESTRICTS_2_3_2_5=3022
1288 SCHEMAP_COS_ST_RESTRICTS_3_1=3023
1289 SCHEMAP_COS_ST_RESTRICTS_3_3_1=3024
1290 SCHEMAP_COS_ST_RESTRICTS_3_3_1_2=3025
1291 SCHEMAP_COS_ST_RESTRICTS_3_3_2_2=3026
1292 SCHEMAP_COS_ST_RESTRICTS_3_3_2_1=3027
1293 SCHEMAP_COS_ST_RESTRICTS_3_3_2_3=3028
1294 SCHEMAP_COS_ST_RESTRICTS_3_3_2_4=3029
1295 SCHEMAP_COS_ST_RESTRICTS_3_3_2_5=3030
1296 SCHEMAP_COS_ST_DERIVED_OK_2_1=3031
1297 SCHEMAP_COS_ST_DERIVED_OK_2_2=3032
1298 SCHEMAP_S4S_ELEM_NOT_ALLOWED=3033
1299 SCHEMAP_S4S_ELEM_MISSING=3034
1300 SCHEMAP_S4S_ATTR_NOT_ALLOWED=3035
1301 SCHEMAP_S4S_ATTR_MISSING=3036
1302 SCHEMAP_S4S_ATTR_INVALID_VALUE=3037
1303 SCHEMAP_SRC_ELEMENT_1=3038
1304 SCHEMAP_SRC_ELEMENT_2_1=3039
1305 SCHEMAP_SRC_ELEMENT_2_2=3040
1306 SCHEMAP_SRC_ELEMENT_3=3041
1307 SCHEMAP_P_PROPS_CORRECT_1=3042
1308 SCHEMAP_P_PROPS_CORRECT_2_1=3043
1309 SCHEMAP_P_PROPS_CORRECT_2_2=3044
1310 SCHEMAP_E_PROPS_CORRECT_2=3045
1311 SCHEMAP_E_PROPS_CORRECT_3=3046
1312 SCHEMAP_E_PROPS_CORRECT_4=3047
1313 SCHEMAP_E_PROPS_CORRECT_5=3048
1314 SCHEMAP_E_PROPS_CORRECT_6=3049
1315 SCHEMAP_SRC_INCLUDE=3050
1316 SCHEMAP_SRC_ATTRIBUTE_1=3051
1317 SCHEMAP_SRC_ATTRIBUTE_2=3052
1318 SCHEMAP_SRC_ATTRIBUTE_3_1=3053
1319 SCHEMAP_SRC_ATTRIBUTE_3_2=3054
1320 SCHEMAP_SRC_ATTRIBUTE_4=3055
1321 SCHEMAP_NO_XMLNS=3056
1322 SCHEMAP_NO_XSI=3057
1323 SCHEMAP_COS_VALID_DEFAULT_1=3058
1324 SCHEMAP_COS_VALID_DEFAULT_2_1=3059
1325 SCHEMAP_COS_VALID_DEFAULT_2_2_1=3060
1326 SCHEMAP_COS_VALID_DEFAULT_2_2_2=3061
1327 """,
1328 u"""\
1329 SCHEMAP_CVC_SIMPLE_TYPE=3062
1330 SCHEMAP_COS_CT_EXTENDS_1_1=3063
1331 SCHEMAP_SRC_IMPORT_1_1=3064
1332 SCHEMAP_SRC_IMPORT_1_2=3065
1333 SCHEMAP_SRC_IMPORT_2=3066
1334 SCHEMAP_SRC_IMPORT_2_1=3067
1335 SCHEMAP_SRC_IMPORT_2_2=3068
1336 SCHEMAP_INTERNAL=3069
1337 SCHEMAP_NOT_DETERMINISTIC=3070
1338 SCHEMAP_SRC_ATTRIBUTE_GROUP_1=3071
1339 SCHEMAP_SRC_ATTRIBUTE_GROUP_2=3072
1340 SCHEMAP_SRC_ATTRIBUTE_GROUP_3=3073
1341 SCHEMAP_MG_PROPS_CORRECT_1=3074
1342 SCHEMAP_MG_PROPS_CORRECT_2=3075
1343 SCHEMAP_SRC_CT_1=3076
1344 SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3=3077
1345 SCHEMAP_AU_PROPS_CORRECT_2=3078
1346 SCHEMAP_A_PROPS_CORRECT_2=3079
1347 SCHEMAP_C_PROPS_CORRECT=3080
1348 SCHEMAP_SRC_REDEFINE=3081
1349 SCHEMAP_SRC_IMPORT=3082
1350 SCHEMAP_WARN_SKIP_SCHEMA=3083
1351 SCHEMAP_WARN_UNLOCATED_SCHEMA=3084
1352 SCHEMAP_WARN_ATTR_REDECL_PROH=3085
1353 SCHEMAP_WARN_ATTR_POINTLESS_PROH=3086
1354 SCHEMAP_AG_PROPS_CORRECT=3087
1355 SCHEMAP_COS_CT_EXTENDS_1_2=3088
1356 SCHEMAP_AU_PROPS_CORRECT=3089
1357 SCHEMAP_A_PROPS_CORRECT_3=3090
1358 SCHEMAP_COS_ALL_LIMITED=3091
1359 SCHEMATRONV_ASSERT=4000
1360 SCHEMATRONV_REPORT=4001
1361 MODULE_OPEN=4900
1362 MODULE_CLOSE=4901
1363 CHECK_FOUND_ELEMENT=5000
1364 CHECK_FOUND_ATTRIBUTE=5001
1365 CHECK_FOUND_TEXT=5002
1366 CHECK_FOUND_CDATA=5003
1367 CHECK_FOUND_ENTITYREF=5004
1368 CHECK_FOUND_ENTITY=5005
1369 CHECK_FOUND_PI=5006
1370 CHECK_FOUND_COMMENT=5007
1371 CHECK_FOUND_DOCTYPE=5008
1372 CHECK_FOUND_FRAGMENT=5009
1373 CHECK_FOUND_NOTATION=5010
1374 CHECK_UNKNOWN_NODE=5011
1375 CHECK_ENTITY_TYPE=5012
1376 CHECK_NO_PARENT=5013
1377 CHECK_NO_DOC=5014
1378 CHECK_NO_NAME=5015
1379 CHECK_NO_ELEM=5016
1380 CHECK_WRONG_DOC=5017
1381 CHECK_NO_PREV=5018
1382 CHECK_WRONG_PREV=5019
1383 CHECK_NO_NEXT=5020
1384 CHECK_WRONG_NEXT=5021
1385 CHECK_NOT_DTD=5022
1386 CHECK_NOT_ATTR=5023
1387 CHECK_NOT_ATTR_DECL=5024
1388 CHECK_NOT_ELEM_DECL=5025
1389 CHECK_NOT_ENTITY_DECL=5026
1390 CHECK_NOT_NS_DECL=5027
1391 CHECK_NO_HREF=5028
1392 CHECK_WRONG_PARENT=5029
1393 CHECK_NS_SCOPE=5030
1394 CHECK_NS_ANCESTOR=5031
1395 CHECK_NOT_UTF8=5032
1396 CHECK_NO_DICT=5033
1397 CHECK_NOT_NCNAME=5034
1398 CHECK_OUTSIDE_DICT=5035
1399 CHECK_WRONG_NAME=5036
1400 CHECK_NAME_NOT_NULL=5037
1401 I18N_NO_NAME=6000
1402 I18N_NO_HANDLER=6001
1403 I18N_EXCESS_HANDLER=6002
1404 I18N_CONV_FAILED=6003
1405 """,
1406 u"""\
1407 I18N_NO_OUTPUT=6004
1408 CHECK_=6005
1409 CHECK_X=6006
1410 """,)
1411
1412 cdef object __RELAXNG_ERROR_TYPES
1413 __RELAXNG_ERROR_TYPES = (u"""\
1414 RELAXNG_OK=0
1415 RELAXNG_ERR_MEMORY=1
1416 RELAXNG_ERR_TYPE=2
1417 RELAXNG_ERR_TYPEVAL=3
1418 RELAXNG_ERR_DUPID=4
1419 RELAXNG_ERR_TYPECMP=5
1420 RELAXNG_ERR_NOSTATE=6
1421 RELAXNG_ERR_NODEFINE=7
1422 RELAXNG_ERR_LISTEXTRA=8
1423 RELAXNG_ERR_LISTEMPTY=9
1424 RELAXNG_ERR_INTERNODATA=10
1425 RELAXNG_ERR_INTERSEQ=11
1426 RELAXNG_ERR_INTEREXTRA=12
1427 RELAXNG_ERR_ELEMNAME=13
1428 RELAXNG_ERR_ATTRNAME=14
1429 RELAXNG_ERR_ELEMNONS=15
1430 RELAXNG_ERR_ATTRNONS=16
1431 RELAXNG_ERR_ELEMWRONGNS=17
1432 RELAXNG_ERR_ATTRWRONGNS=18
1433 RELAXNG_ERR_ELEMEXTRANS=19
1434 RELAXNG_ERR_ATTREXTRANS=20
1435 RELAXNG_ERR_ELEMNOTEMPTY=21
1436 RELAXNG_ERR_NOELEM=22
1437 RELAXNG_ERR_NOTELEM=23
1438 RELAXNG_ERR_ATTRVALID=24
1439 RELAXNG_ERR_CONTENTVALID=25
1440 RELAXNG_ERR_EXTRACONTENT=26
1441 RELAXNG_ERR_INVALIDATTR=27
1442 RELAXNG_ERR_DATAELEM=28
1443 RELAXNG_ERR_VALELEM=29
1444 RELAXNG_ERR_LISTELEM=30
1445 RELAXNG_ERR_DATATYPE=31
1446 RELAXNG_ERR_VALUE=32
1447 RELAXNG_ERR_LIST=33
1448 RELAXNG_ERR_NOGRAMMAR=34
1449 RELAXNG_ERR_EXTRADATA=35
1450 RELAXNG_ERR_LACKDATA=36
1451 RELAXNG_ERR_INTERNAL=37
1452 RELAXNG_ERR_ELEMWRONG=38
1453 RELAXNG_ERR_TEXTWRONG=39
1454 """,)
1455 # --- END: GENERATED CONSTANTS ---
1456
1457 __initErrorConstants()