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