2001-02-23 20:55:21 +03:00
/*
* error . c : module displaying / handling XML parser errors
*
* See Copyright for the status of this software .
*
2001-06-24 16:13:24 +04:00
* Daniel Veillard < daniel @ veillard . com >
2001-02-23 20:55:21 +03:00
*/
2002-03-18 22:37:11 +03:00
# define IN_LIBXML
2001-04-21 20:57:29 +04:00
# include "libxml.h"
2001-02-23 20:55:21 +03:00
2003-10-03 02:28:19 +04:00
# include <string.h>
2001-02-23 20:55:21 +03:00
# include <stdarg.h>
2024-01-02 20:51:24 +03:00
# include <stdlib.h>
2001-02-23 20:55:21 +03:00
# include <libxml/parser.h>
# include <libxml/xmlerror.h>
2001-03-10 15:32:04 +03:00
# include <libxml/xmlmemory.h>
2001-02-23 20:55:21 +03:00
2022-08-26 02:22:33 +03:00
# include "private/error.h"
2023-12-18 21:12:08 +03:00
# include "private/string.h"
2001-10-29 14:48:19 +03:00
2023-12-18 21:12:08 +03:00
/************************************************************************
* *
* Error struct *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static int
xmlVSetError ( xmlError * err ,
void * ctxt , xmlNodePtr node ,
int domain , int code , xmlErrorLevel level ,
const char * file , int line ,
const char * str1 , const char * str2 , const char * str3 ,
int int1 , int col ,
const char * fmt , va_list ap )
{
char * message = NULL ;
char * fileCopy = NULL ;
char * str1Copy = NULL ;
char * str2Copy = NULL ;
char * str3Copy = NULL ;
if ( code = = XML_ERR_OK ) {
xmlResetError ( err ) ;
return ( 0 ) ;
}
/*
* Formatting the message
*/
if ( fmt = = NULL ) {
message = xmlMemStrdup ( " No error message provided " ) ;
} else {
xmlChar * tmp ;
int res ;
res = xmlStrVASPrintf ( & tmp , MAX_ERR_MSG_SIZE , fmt , ap ) ;
if ( res < 0 )
goto err_memory ;
message = ( char * ) tmp ;
}
if ( message = = NULL )
goto err_memory ;
if ( file ! = NULL ) {
fileCopy = ( char * ) xmlStrdup ( ( const xmlChar * ) file ) ;
if ( fileCopy = = NULL )
goto err_memory ;
}
if ( str1 ! = NULL ) {
str1Copy = ( char * ) xmlStrdup ( ( const xmlChar * ) str1 ) ;
if ( str1Copy = = NULL )
goto err_memory ;
}
if ( str2 ! = NULL ) {
str2Copy = ( char * ) xmlStrdup ( ( const xmlChar * ) str2 ) ;
if ( str2Copy = = NULL )
goto err_memory ;
}
if ( str3 ! = NULL ) {
str3Copy = ( char * ) xmlStrdup ( ( const xmlChar * ) str3 ) ;
if ( str3Copy = = NULL )
goto err_memory ;
}
xmlResetError ( err ) ;
err - > domain = domain ;
err - > code = code ;
err - > message = message ;
err - > level = level ;
err - > file = fileCopy ;
err - > line = line ;
err - > str1 = str1Copy ;
err - > str2 = str2Copy ;
err - > str3 = str3Copy ;
err - > int1 = int1 ;
err - > int2 = col ;
err - > node = node ;
err - > ctxt = ctxt ;
return ( 0 ) ;
err_memory :
xmlFree ( message ) ;
xmlFree ( fileCopy ) ;
xmlFree ( str1Copy ) ;
xmlFree ( str2Copy ) ;
xmlFree ( str3Copy ) ;
return ( - 1 ) ;
}
static int LIBXML_ATTR_FORMAT ( 14 , 15 )
xmlSetError ( xmlError * err ,
void * ctxt , xmlNodePtr node ,
int domain , int code , xmlErrorLevel level ,
const char * file , int line ,
const char * str1 , const char * str2 , const char * str3 ,
int int1 , int col ,
const char * fmt , . . . )
{
va_list ap ;
int res ;
va_start ( ap , fmt ) ;
res = xmlVSetError ( err , ctxt , node , domain , code , level , file , line ,
str1 , str2 , str3 , int1 , col , fmt , ap ) ;
va_end ( ap ) ;
return ( res ) ;
}
static int
xmlVUpdateError ( xmlError * err ,
void * ctxt , xmlNodePtr node ,
int domain , int code , xmlErrorLevel level ,
const char * file , int line ,
const char * str1 , const char * str2 , const char * str3 ,
int int1 , int col ,
const char * fmt , va_list ap )
{
int res ;
/*
* Find first element parent .
*/
if ( node ! = NULL ) {
int i ;
for ( i = 0 ; i < 10 ; i + + ) {
if ( ( node - > type = = XML_ELEMENT_NODE ) | |
( node - > parent = = NULL ) )
2023-12-10 17:46:53 +03:00
break ;
2023-12-18 21:12:08 +03:00
node = node - > parent ;
2023-12-10 17:46:53 +03:00
}
2023-12-18 21:12:08 +03:00
}
/*
* Get file and line from node .
*/
if ( node ! = NULL ) {
if ( ( file = = NULL ) & & ( node - > doc ! = NULL ) )
file = ( const char * ) node - > doc - > URL ;
if ( line = = 0 ) {
if ( node - > type = = XML_ELEMENT_NODE )
line = node - > line ;
if ( ( line = = 0 ) | | ( line = = 65535 ) )
line = xmlGetLineNo ( node ) ;
2023-12-10 17:46:53 +03:00
}
}
2023-12-18 21:12:08 +03:00
res = xmlVSetError ( err , ctxt , node , domain , code , level , file , line ,
str1 , str2 , str3 , int1 , col , fmt , ap ) ;
return ( res ) ;
2001-06-05 21:12:52 +04:00
}
2001-06-05 16:45:55 +04:00
2001-02-23 20:55:21 +03:00
/************************************************************************
2012-09-11 09:26:36 +04:00
* *
* Handling of out of context errors *
* *
2001-02-23 20:55:21 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**
* xmlGenericErrorDefaultFunc :
* @ ctx : an error context
* @ msg : the message to display / transmit
* @ . . . : extra parameters for the message display
2012-09-11 09:26:36 +04:00
*
2001-02-23 20:55:21 +03:00
* Default handler for out of context error messages .
*/
2022-12-08 04:43:17 +03:00
void
2001-03-26 20:28:29 +04:00
xmlGenericErrorDefaultFunc ( void * ctx ATTRIBUTE_UNUSED , const char * msg , . . . ) {
2001-02-23 20:55:21 +03:00
va_list args ;
if ( xmlGenericErrorContext = = NULL )
xmlGenericErrorContext = ( void * ) stderr ;
va_start ( args , msg ) ;
vfprintf ( ( FILE * ) xmlGenericErrorContext , msg , args ) ;
va_end ( args ) ;
}
2002-01-22 21:15:52 +03:00
/**
* initGenericErrorDefaultFunc :
* @ handler : the handler
2012-09-11 09:26:36 +04:00
*
2022-09-09 02:44:00 +03:00
* DEPRECATED : Use xmlSetGenericErrorFunc .
*
2002-01-22 21:15:52 +03:00
* Set or reset ( if NULL ) the default handler for generic errors
2003-01-24 17:14:52 +03:00
* to the builtin error function .
2002-01-22 21:15:52 +03:00
*/
2001-10-13 13:15:48 +04:00
void
2002-01-18 14:49:26 +03:00
initGenericErrorDefaultFunc ( xmlGenericErrorFunc * handler )
2001-10-13 13:15:48 +04:00
{
2002-01-18 14:49:26 +03:00
if ( handler = = NULL )
xmlGenericError = xmlGenericErrorDefaultFunc ;
else
2004-04-20 13:45:26 +04:00
xmlGenericError = ( * handler ) ;
2001-10-13 13:15:48 +04:00
}
2001-02-23 20:55:21 +03:00
/**
* xmlSetGenericErrorFunc :
* @ ctx : the new error handling context
* @ handler : the new handler function
*
2023-12-21 19:30:38 +03:00
* DEPRECATED : See xmlSetStructuredErrorFunc for alternatives .
*
* Set the global " generic " handler and context for error messages .
* The generic error handler will only receive fragments of error
* messages which should be concatenated or printed to a stream .
*
* If handler is NULL , use the built - in default handler which prints
* to stderr .
*
* Since this is a global setting , it ' s a good idea to reset the
* error handler to its default value after collecting the errors
* you ' re interested in .
*
* For multi - threaded applications , this must be set separately for
* each thread .
2001-02-23 20:55:21 +03:00
*/
void
xmlSetGenericErrorFunc ( void * ctx , xmlGenericErrorFunc handler ) {
xmlGenericErrorContext = ctx ;
if ( handler ! = NULL )
xmlGenericError = handler ;
else
xmlGenericError = xmlGenericErrorDefaultFunc ;
}
2003-10-10 18:10:40 +04:00
/**
* xmlSetStructuredErrorFunc :
* @ ctx : the new error handling context
* @ handler : the new handler function
*
2023-12-21 19:30:38 +03:00
* DEPRECATED : Use a per - context error handler .
*
* It ' s recommended to use the per - context error handlers instead :
*
* - xmlCtxtSetErrorHandler ( since 2.13 .0 )
* - xmlTextReaderSetStructuredErrorHandler
* - xmlXPathSetErrorHandler ( since 2.13 .0 )
* - xmlXIncludeSetErrorHandler ( since 2.13 .0 )
* - xmlSchemaSetParserStructuredErrors
* - xmlSchemaSetValidStructuredErrors
* - xmlRelaxNGSetParserStructuredErrors
* - xmlRelaxNGSetValidStructuredErrors
*
* Set the global " structured " handler and context for error messages .
* If handler is NULL , the error handler is deactivated .
*
* The structured error handler takes precedence over " generic "
* handlers , even per - context generic handlers .
*
* Since this is a global setting , it ' s a good idea to deactivate the
* error handler after collecting the errors you ' re interested in .
*
* For multi - threaded applications , this must be set separately for
* each thread .
2003-10-10 18:10:40 +04:00
*/
void
xmlSetStructuredErrorFunc ( void * ctx , xmlStructuredErrorFunc handler ) {
2009-08-24 19:34:25 +04:00
xmlStructuredErrorContext = ctx ;
2003-10-10 18:10:40 +04:00
xmlStructuredError = handler ;
}
2001-02-23 20:55:21 +03:00
/************************************************************************
2012-09-11 09:26:36 +04:00
* *
* Handling of parsing errors *
* *
2001-02-23 20:55:21 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**
* xmlParserPrintFileInfo :
* @ input : an xmlParserInputPtr input
2012-09-11 09:26:36 +04:00
*
2024-01-04 04:48:02 +03:00
* DEPRECATED : Use xmlFormatError .
*
2020-03-08 19:19:42 +03:00
* Displays the associated file and line information for the current input
2001-02-23 20:55:21 +03:00
*/
void
xmlParserPrintFileInfo ( xmlParserInputPtr input ) {
if ( input ! = NULL ) {
if ( input - > filename )
xmlGenericError ( xmlGenericErrorContext ,
" %s:%d: " , input - > filename ,
input - > line ) ;
else
xmlGenericError ( xmlGenericErrorContext ,
" Entity: line %d: " , input - > line ) ;
}
}
/**
2022-12-05 01:01:00 +03:00
* xmlParserPrintFileContextInternal :
2001-02-23 20:55:21 +03:00
* @ input : an xmlParserInputPtr input
2012-09-11 09:26:36 +04:00
*
2001-02-23 20:55:21 +03:00
* Displays current context within the input content for error tracking
*/
2003-10-03 02:28:19 +04:00
static void
2012-09-11 09:26:36 +04:00
xmlParserPrintFileContextInternal ( xmlParserInputPtr input ,
2003-10-03 02:28:19 +04:00
xmlGenericErrorFunc channel , void * data ) {
2022-12-05 01:01:00 +03:00
const xmlChar * cur , * base , * start ;
2003-08-05 19:52:22 +04:00
unsigned int n , col ; /* GCC warns if signed, because compared with sizeof() */
2003-05-13 06:06:18 +04:00
xmlChar content [ 81 ] ; /* space for 80 chars + line terminator */
2001-03-27 04:32:28 +04:00
xmlChar * ctnt ;
2001-02-23 20:55:21 +03:00
2015-12-01 15:24:44 +03:00
if ( ( input = = NULL ) | | ( input - > cur = = NULL ) )
return ;
2015-11-20 10:01:22 +03:00
2001-02-23 20:55:21 +03:00
cur = input - > cur ;
base = input - > base ;
2001-03-27 04:32:28 +04:00
/* skip backwards over any end-of-lines */
2003-08-05 19:52:22 +04:00
while ( ( cur > base ) & & ( ( * ( cur ) = = ' \n ' ) | | ( * ( cur ) = = ' \r ' ) ) ) {
2002-03-21 00:55:57 +03:00
cur - - ;
2001-02-23 20:55:21 +03:00
}
n = 0 ;
2003-05-13 06:06:18 +04:00
/* search backwards for beginning-of-line (to max buff size) */
2023-01-22 14:00:59 +03:00
while ( ( n < sizeof ( content ) - 1 ) & & ( cur > base ) & &
( * cur ! = ' \n ' ) & & ( * cur ! = ' \r ' ) ) {
2001-02-23 20:55:21 +03:00
cur - - ;
2023-01-22 14:00:59 +03:00
n + + ;
}
if ( ( n > 0 ) & & ( ( * cur = = ' \n ' ) | | ( * cur = = ' \r ' ) ) ) {
2022-12-05 01:01:00 +03:00
cur + + ;
} else {
/* skip over continuation bytes */
while ( ( cur < input - > cur ) & & ( ( * cur & 0xC0 ) = = 0x80 ) )
cur + + ;
}
2003-05-13 06:06:18 +04:00
/* calculate the error position in terms of the current position */
col = input - > cur - cur ;
/* search forward for end-of-line (to max buff size) */
2001-02-23 20:55:21 +03:00
n = 0 ;
2022-12-05 01:01:00 +03:00
start = cur ;
2003-05-13 06:06:18 +04:00
/* copy selected text to our buffer */
2022-12-05 01:01:00 +03:00
while ( ( * cur ! = 0 ) & & ( * ( cur ) ! = ' \n ' ) & & ( * ( cur ) ! = ' \r ' ) ) {
int len = input - > end - cur ;
int c = xmlGetUTF8Char ( cur , & len ) ;
if ( ( c < 0 ) | | ( n + len > sizeof ( content ) - 1 ) )
break ;
cur + = len ;
n + = len ;
2001-02-23 20:55:21 +03:00
}
2022-12-05 01:01:00 +03:00
memcpy ( content , start , n ) ;
content [ n ] = 0 ;
2003-05-13 06:06:18 +04:00
/* print out the selected text */
2003-10-03 02:28:19 +04:00
channel ( data , " %s \n " , content ) ;
2001-03-27 04:32:28 +04:00
/* create blank line with problem pointer */
2001-02-23 20:55:21 +03:00
n = 0 ;
2001-04-24 19:52:00 +04:00
ctnt = content ;
2003-05-13 06:06:18 +04:00
/* (leave buffer space for pointer + line terminator) */
while ( ( n < col ) & & ( n + + < sizeof ( content ) - 2 ) & & ( * ctnt ! = 0 ) ) {
2003-08-05 19:52:22 +04:00
if ( * ( ctnt ) ! = ' \t ' )
* ( ctnt ) = ' ' ;
2003-09-22 04:24:51 +04:00
ctnt + + ;
2002-03-21 00:55:57 +03:00
}
2003-05-13 06:06:18 +04:00
* ctnt + + = ' ^ ' ;
* ctnt = 0 ;
2003-10-03 02:28:19 +04:00
channel ( data , " %s \n " , content ) ;
}
/**
* xmlParserPrintFileContext :
* @ input : an xmlParserInputPtr input
2012-09-11 09:26:36 +04:00
*
2024-01-04 04:48:02 +03:00
* DEPRECATED : Use xmlFormatError .
*
2003-10-03 02:28:19 +04:00
* Displays current context within the input content for error tracking
*/
void
xmlParserPrintFileContext ( xmlParserInputPtr input ) {
xmlParserPrintFileContextInternal ( input , xmlGenericError ,
xmlGenericErrorContext ) ;
2002-03-21 00:55:57 +03:00
}
/**
2024-01-04 04:48:02 +03:00
* xmlFormatError :
* @ err : the error
* @ channel : callback
* @ data : user data for callback
2002-03-21 00:55:57 +03:00
*
2024-01-04 04:48:02 +03:00
* Report a formatted error to a printf - like callback .
*
* This can result in a verbose multi - line report including additional
* information from the parser context .
2024-05-20 14:58:22 +03:00
*
* Available since 2.13 .0 .
2002-03-21 00:55:57 +03:00
*/
2024-01-04 04:48:02 +03:00
void
xmlFormatError ( const xmlError * err , xmlGenericErrorFunc channel , void * data )
2003-10-04 02:21:51 +04:00
{
2023-12-18 21:12:08 +03:00
const char * message ;
const char * file ;
int line ;
int code ;
2003-10-03 02:28:19 +04:00
int domain ;
2003-10-07 15:33:24 +04:00
const xmlChar * name = NULL ;
xmlNodePtr node ;
2003-10-03 02:28:19 +04:00
xmlErrorLevel level ;
2024-01-04 04:48:02 +03:00
xmlParserCtxtPtr ctxt = NULL ;
2003-10-03 02:28:19 +04:00
xmlParserInputPtr input = NULL ;
xmlParserInputPtr cur = NULL ;
2024-01-04 04:48:02 +03:00
if ( ( err = = NULL ) | | ( channel = = NULL ) )
return ;
2023-12-18 21:12:08 +03:00
message = err - > message ;
2003-10-04 02:21:51 +04:00
file = err - > file ;
line = err - > line ;
code = err - > code ;
domain = err - > domain ;
level = err - > level ;
2003-10-07 15:33:24 +04:00
node = err - > node ;
2003-10-04 02:21:51 +04:00
2003-10-03 02:28:19 +04:00
if ( code = = XML_ERR_OK )
return ;
2024-01-04 04:48:02 +03:00
if ( ( domain = = XML_FROM_PARSER ) | | ( domain = = XML_FROM_HTML ) | |
( domain = = XML_FROM_DTD ) | | ( domain = = XML_FROM_NAMESPACE ) | |
( domain = = XML_FROM_IO ) | | ( domain = = XML_FROM_VALID ) ) {
ctxt = err - > ctxt ;
}
if ( ( node ! = NULL ) & & ( node - > type = = XML_ELEMENT_NODE ) & &
( domain ! = XML_FROM_SCHEMASV ) )
2003-10-07 15:33:24 +04:00
name = node - > name ;
2003-10-03 02:28:19 +04:00
/*
* Maintain the compatibility with the legacy error handling
*/
2023-12-10 17:46:53 +03:00
if ( ( ctxt ! = NULL ) & & ( ctxt - > input ! = NULL ) ) {
2003-10-04 02:21:51 +04:00
input = ctxt - > input ;
2023-12-10 17:46:53 +03:00
if ( ( input - > filename = = NULL ) & &
2003-10-04 02:21:51 +04:00
( ctxt - > inputNr > 1 ) ) {
cur = input ;
input = ctxt - > inputTab [ ctxt - > inputNr - 2 ] ;
}
2023-12-10 17:46:53 +03:00
if ( input - > filename )
channel ( data , " %s:%d: " , input - > filename , input - > line ) ;
else if ( ( line ! = 0 ) & & ( domain = = XML_FROM_PARSER ) )
channel ( data , " Entity: line %d: " , input - > line ) ;
2003-10-04 02:21:51 +04:00
} else {
if ( file ! = NULL )
channel ( data , " %s:%d: " , file , line ) ;
2012-09-11 09:26:36 +04:00
else if ( ( line ! = 0 ) & &
2012-08-14 07:01:07 +04:00
( ( domain = = XML_FROM_PARSER ) | | ( domain = = XML_FROM_SCHEMASV ) | |
( domain = = XML_FROM_SCHEMASP ) | | ( domain = = XML_FROM_DTD ) | |
( domain = = XML_FROM_RELAXNGP ) | | ( domain = = XML_FROM_RELAXNGV ) ) )
2003-10-04 02:21:51 +04:00
channel ( data , " Entity: line %d: " , line ) ;
2003-10-03 02:28:19 +04:00
}
2003-10-07 15:33:24 +04:00
if ( name ! = NULL ) {
channel ( data , " element %s: " , name ) ;
}
2003-10-03 02:28:19 +04:00
switch ( domain ) {
case XML_FROM_PARSER :
channel ( data , " parser " ) ;
break ;
case XML_FROM_NAMESPACE :
channel ( data , " namespace " ) ;
break ;
case XML_FROM_DTD :
2003-10-28 18:44:17 +03:00
case XML_FROM_VALID :
2003-10-03 02:28:19 +04:00
channel ( data , " validity " ) ;
break ;
case XML_FROM_HTML :
channel ( data , " HTML parser " ) ;
break ;
case XML_FROM_MEMORY :
channel ( data , " memory " ) ;
break ;
case XML_FROM_OUTPUT :
channel ( data , " output " ) ;
break ;
case XML_FROM_IO :
channel ( data , " I/O " ) ;
break ;
case XML_FROM_XINCLUDE :
channel ( data , " XInclude " ) ;
break ;
case XML_FROM_XPATH :
channel ( data , " XPath " ) ;
break ;
case XML_FROM_XPOINTER :
channel ( data , " parser " ) ;
break ;
case XML_FROM_REGEXP :
channel ( data , " regexp " ) ;
break ;
2005-01-04 18:10:22 +03:00
case XML_FROM_MODULE :
channel ( data , " module " ) ;
break ;
2003-10-10 04:49:42 +04:00
case XML_FROM_SCHEMASV :
2003-10-10 14:52:58 +04:00
channel ( data , " Schemas validity " ) ;
2003-10-10 04:49:42 +04:00
break ;
case XML_FROM_SCHEMASP :
2003-10-10 14:52:58 +04:00
channel ( data , " Schemas parser " ) ;
2003-10-03 02:28:19 +04:00
break ;
2003-10-07 15:33:24 +04:00
case XML_FROM_RELAXNGP :
channel ( data , " Relax-NG parser " ) ;
break ;
case XML_FROM_RELAXNGV :
2003-10-10 04:49:42 +04:00
channel ( data , " Relax-NG validity " ) ;
2003-10-03 02:28:19 +04:00
break ;
case XML_FROM_CATALOG :
channel ( data , " Catalog " ) ;
break ;
case XML_FROM_C14N :
channel ( data , " C14N " ) ;
break ;
case XML_FROM_XSLT :
channel ( data , " XSLT " ) ;
break ;
2005-08-24 16:46:09 +04:00
case XML_FROM_I18N :
channel ( data , " encoding " ) ;
break ;
2012-07-24 07:44:23 +04:00
case XML_FROM_SCHEMATRONV :
channel ( data , " schematron " ) ;
break ;
case XML_FROM_BUFFER :
channel ( data , " internal buffer " ) ;
break ;
case XML_FROM_URI :
channel ( data , " URI " ) ;
break ;
2003-10-03 02:28:19 +04:00
default :
break ;
}
switch ( level ) {
case XML_ERR_NONE :
channel ( data , " : " ) ;
2003-10-04 02:21:51 +04:00
break ;
2003-10-03 02:28:19 +04:00
case XML_ERR_WARNING :
channel ( data , " warning : " ) ;
2003-10-04 02:21:51 +04:00
break ;
2003-10-03 02:28:19 +04:00
case XML_ERR_ERROR :
channel ( data , " error : " ) ;
2003-10-04 02:21:51 +04:00
break ;
2003-10-03 02:28:19 +04:00
case XML_ERR_FATAL :
channel ( data , " error : " ) ;
2003-10-04 02:21:51 +04:00
break ;
2003-10-03 02:28:19 +04:00
}
2023-12-18 21:12:08 +03:00
if ( message ! = NULL ) {
2003-10-08 23:19:10 +04:00
int len ;
2023-12-18 21:12:08 +03:00
len = xmlStrlen ( ( const xmlChar * ) message ) ;
if ( ( len > 0 ) & & ( message [ len - 1 ] ! = ' \n ' ) )
channel ( data , " %s \n " , message ) ;
2003-10-08 23:26:03 +04:00
else
2023-12-18 21:12:08 +03:00
channel ( data , " %s " , message ) ;
2003-10-03 02:28:19 +04:00
} else {
2023-12-18 21:12:08 +03:00
channel ( data , " %s \n " , " No error message provided " ) ;
2001-03-10 15:32:04 +03:00
}
2003-10-03 02:28:19 +04:00
if ( ctxt ! = NULL ) {
2023-12-19 22:47:36 +03:00
if ( ( input ! = NULL ) & &
( ( input - > buf = = NULL ) | | ( input - > buf - > encoder = = NULL ) ) & &
( code = = XML_ERR_INVALID_ENCODING ) & &
( input - > cur < input - > end ) ) {
int i ;
channel ( data , " Bytes: " ) ;
for ( i = 0 ; i < 4 ; i + + ) {
if ( input - > cur + i > = input - > end )
break ;
channel ( data , " 0x%02X " , input - > cur [ i ] ) ;
}
channel ( data , " \n " ) ;
}
2003-10-03 02:28:19 +04:00
xmlParserPrintFileContextInternal ( input , channel , data ) ;
2023-12-19 22:47:36 +03:00
2003-10-03 02:28:19 +04:00
if ( cur ! = NULL ) {
if ( cur - > filename )
channel ( data , " %s:%d: \n " , cur - > filename , cur - > line ) ;
2003-10-08 01:25:12 +04:00
else if ( ( line ! = 0 ) & & ( domain = = XML_FROM_PARSER ) )
2003-10-03 02:28:19 +04:00
channel ( data , " Entity: line %d: \n " , cur - > line ) ;
xmlParserPrintFileContextInternal ( cur , channel , data ) ;
}
}
2003-10-08 01:25:12 +04:00
if ( ( domain = = XML_FROM_XPATH ) & & ( err - > str1 ! = NULL ) & &
( err - > int1 < 100 ) & &
( err - > int1 < xmlStrlen ( ( const xmlChar * ) err - > str1 ) ) ) {
xmlChar buf [ 150 ] ;
int i ;
channel ( data , " %s \n " , err - > str1 ) ;
for ( i = 0 ; i < err - > int1 ; i + + )
buf [ i ] = ' ' ;
buf [ i + + ] = ' ^ ' ;
buf [ i ] = 0 ;
channel ( data , " %s \n " , buf ) ;
}
2003-10-03 02:28:19 +04:00
}
2023-12-18 21:12:08 +03:00
/**
* xmlRaiseMemoryError :
* @ schannel : the structured callback channel
* @ channel : the old callback channel
* @ data : the callback data
* @ domain : the domain for the error
* @ error : optional error struct to be filled
*
* Update the global and optional error structure , then forward the
* error to an error handler .
*
* This function doesn ' t make memory allocations which are likely
* to fail after an OOM error .
*/
void
xmlRaiseMemoryError ( xmlStructuredErrorFunc schannel , xmlGenericErrorFunc channel ,
void * data , int domain , xmlError * error )
{
xmlError * lastError = & xmlLastError ;
xmlResetLastError ( ) ;
lastError - > domain = domain ;
lastError - > code = XML_ERR_NO_MEMORY ;
lastError - > level = XML_ERR_FATAL ;
if ( error ! = NULL ) {
xmlResetError ( error ) ;
error - > domain = domain ;
error - > code = XML_ERR_NO_MEMORY ;
error - > level = XML_ERR_FATAL ;
}
if ( schannel ! = NULL ) {
schannel ( data , lastError ) ;
} else if ( xmlStructuredError ! = NULL ) {
xmlStructuredError ( xmlStructuredErrorContext , lastError ) ;
} else if ( channel ! = NULL ) {
channel ( data , " libxml2: out of memory \n " ) ;
}
}
2003-10-03 02:28:19 +04:00
/**
2023-12-10 17:46:53 +03:00
* xmlVRaiseError :
2004-05-16 07:12:08 +04:00
* @ schannel : the structured callback channel
2003-10-10 18:10:40 +04:00
* @ channel : the old callback channel
2003-10-04 02:21:51 +04:00
* @ data : the callback data
* @ ctx : the parser context or NULL
2024-05-20 14:58:22 +03:00
* @ node : the current node or NULL
2003-10-03 02:28:19 +04:00
* @ domain : the domain for the error
* @ code : the code for the error
* @ level : the xmlErrorLevel for the error
* @ file : the file source of the error ( or NULL )
* @ line : the line of the error or 0 if N / A
* @ str1 : extra string info
* @ str2 : extra string info
* @ str3 : extra string info
* @ int1 : extra int info
2012-09-11 09:26:36 +04:00
* @ col : column number of the error or 0 if N / A
2003-10-03 02:28:19 +04:00
* @ msg : the message to display / transmit
2023-12-10 17:46:53 +03:00
* @ ap : extra parameters for the message display
2003-10-03 02:28:19 +04:00
*
2004-05-16 07:12:08 +04:00
* Update the appropriate global or contextual error structure ,
2003-10-03 02:28:19 +04:00
* then forward the error message down the parser or generic
* error callback handler
2023-12-10 17:46:53 +03:00
*
* Returns 0 on success , - 1 if a memory allocation failed .
2003-10-03 02:28:19 +04:00
*/
2023-12-10 17:46:53 +03:00
int
xmlVRaiseError ( xmlStructuredErrorFunc schannel ,
xmlGenericErrorFunc channel , void * data , void * ctx ,
2023-12-18 21:12:08 +03:00
xmlNode * node , int domain , int code , xmlErrorLevel level ,
2023-12-10 17:46:53 +03:00
const char * file , int line , const char * str1 ,
const char * str2 , const char * str3 , int int1 , int col ,
const char * msg , va_list ap )
2003-10-03 02:28:19 +04:00
{
2003-10-09 02:38:13 +04:00
xmlParserCtxtPtr ctxt = NULL ;
2023-12-10 17:46:53 +03:00
/* xmlLastError is a macro retrieving the per-thread global. */
xmlErrorPtr lastError = & xmlLastError ;
xmlErrorPtr to = lastError ;
2003-10-03 02:28:19 +04:00
2011-02-23 17:14:19 +03:00
if ( code = = XML_ERR_OK )
2023-12-10 17:46:53 +03:00
return ( 0 ) ;
2024-01-02 20:51:24 +03:00
# ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
2024-02-29 16:51:49 +03:00
if ( code = = XML_ERR_INTERNAL_ERROR ) {
2024-01-02 20:51:24 +03:00
fprintf ( stderr , " Unexpected error: %d \n " , code ) ;
abort ( ) ;
}
# endif
2003-12-08 20:41:29 +03:00
if ( ( xmlGetWarningsDefaultValue = = 0 ) & & ( level = = XML_ERR_WARNING ) )
2023-12-10 17:46:53 +03:00
return ( 0 ) ;
2023-12-18 21:12:08 +03:00
2003-10-09 02:38:13 +04:00
if ( ( domain = = XML_FROM_PARSER ) | | ( domain = = XML_FROM_HTML ) | |
( domain = = XML_FROM_DTD ) | | ( domain = = XML_FROM_NAMESPACE ) | |
2004-10-25 20:23:56 +04:00
( domain = = XML_FROM_IO ) | | ( domain = = XML_FROM_VALID ) ) {
2003-10-09 02:38:13 +04:00
ctxt = ( xmlParserCtxtPtr ) ctx ;
2003-10-07 15:33:24 +04:00
2023-12-18 21:12:08 +03:00
if ( ctxt ! = NULL )
to = & ctxt - > lastError ;
2003-10-03 02:28:19 +04:00
}
2023-12-18 21:12:08 +03:00
if ( xmlVUpdateError ( to , ctxt , node , domain , code , level , file , line ,
str1 , str2 , str3 , int1 , col , msg , ap ) )
return ( - 1 ) ;
2003-10-03 02:28:19 +04:00
2023-12-10 17:46:53 +03:00
if ( to ! = lastError ) {
if ( xmlCopyError ( to , lastError ) < 0 )
2023-12-18 21:12:08 +03:00
return ( - 1 ) ;
2023-12-10 17:46:53 +03:00
}
2004-01-02 23:26:01 +03:00
2011-02-23 17:44:05 +03:00
if ( schannel ! = NULL ) {
schannel ( data , to ) ;
2023-12-18 21:12:08 +03:00
} else if ( xmlStructuredError ! = NULL ) {
xmlStructuredError ( xmlStructuredErrorContext , to ) ;
} else if ( channel ! = NULL ) {
2024-04-09 17:54:02 +03:00
/* Don't invoke legacy error handlers */
if ( ( channel = = xmlGenericErrorDefaultFunc ) | |
( channel = = xmlParserError ) | |
( channel = = xmlParserWarning ) | |
( channel = = xmlParserValidityError ) | |
( channel = = xmlParserValidityWarning ) )
2024-01-04 04:48:02 +03:00
xmlFormatError ( to , xmlGenericError , xmlGenericErrorContext ) ;
2023-12-23 03:40:54 +03:00
else
channel ( data , " %s " , to - > message ) ;
2003-10-10 18:10:40 +04:00
}
2023-12-10 17:46:53 +03:00
return ( 0 ) ;
}
/**
* __xmlRaiseError :
* @ schannel : the structured callback channel
* @ channel : the old callback channel
* @ data : the callback data
* @ ctx : the parser context or NULL
* @ nod : the node or NULL
* @ domain : the domain for the error
* @ code : the code for the error
* @ level : the xmlErrorLevel for the error
* @ file : the file source of the error ( or NULL )
* @ line : the line of the error or 0 if N / A
* @ str1 : extra string info
* @ str2 : extra string info
* @ str3 : extra string info
* @ int1 : extra int info
* @ col : column number of the error or 0 if N / A
* @ msg : the message to display / transmit
* @ . . . : extra parameters for the message display
*
* Update the appropriate global or contextual error structure ,
* then forward the error message down the parser or generic
* error callback handler
*
* Returns 0 on success , - 1 if a memory allocation failed .
*/
int
__xmlRaiseError ( xmlStructuredErrorFunc schannel ,
xmlGenericErrorFunc channel , void * data , void * ctx ,
2023-12-18 21:12:08 +03:00
xmlNode * node , int domain , int code , xmlErrorLevel level ,
2023-12-10 17:46:53 +03:00
const char * file , int line , const char * str1 ,
const char * str2 , const char * str3 , int int1 , int col ,
const char * msg , . . . )
{
va_list ap ;
int res ;
va_start ( ap , msg ) ;
2023-12-18 21:12:08 +03:00
res = xmlVRaiseError ( schannel , channel , data , ctx , node , domain , code ,
2023-12-10 17:46:53 +03:00
level , file , line , str1 , str2 , str3 , int1 , col , msg ,
ap ) ;
va_end ( ap ) ;
return ( res ) ;
2001-03-10 15:32:04 +03:00
}
2024-04-09 17:54:02 +03:00
static void
xmlVFormatLegacyError ( void * ctx , const char * level ,
const char * fmt , va_list ap ) {
xmlParserCtxtPtr ctxt = ( xmlParserCtxtPtr ) ctx ;
xmlParserInputPtr input = NULL ;
xmlParserInputPtr cur = NULL ;
xmlChar * str = NULL ;
if ( ctxt ! = NULL ) {
input = ctxt - > input ;
if ( ( input ! = NULL ) & & ( input - > filename = = NULL ) & &
( ctxt - > inputNr > 1 ) ) {
cur = input ;
input = ctxt - > inputTab [ ctxt - > inputNr - 2 ] ;
}
xmlParserPrintFileInfo ( input ) ;
}
xmlGenericError ( xmlGenericErrorContext , " %s: " , level ) ;
xmlStrVASPrintf ( & str , MAX_ERR_MSG_SIZE , fmt , ap ) ;
if ( str ! = NULL ) {
xmlGenericError ( xmlGenericErrorContext , " %s " , ( char * ) str ) ;
xmlFree ( str ) ;
}
if ( ctxt ! = NULL ) {
xmlParserPrintFileContext ( input ) ;
if ( cur ! = NULL ) {
xmlParserPrintFileInfo ( cur ) ;
xmlGenericError ( xmlGenericErrorContext , " \n " ) ;
xmlParserPrintFileContext ( cur ) ;
}
}
}
2001-02-23 20:55:21 +03:00
/**
* xmlParserError :
* @ ctx : an XML parser context
* @ msg : the message to display / transmit
* @ . . . : extra parameters for the message display
2012-09-11 09:26:36 +04:00
*
2001-02-23 20:55:21 +03:00
* Display and format an error messages , gives file , line , position and
* extra parameters .
*/
2022-12-08 04:43:17 +03:00
void
2023-12-18 21:12:08 +03:00
xmlParserError ( void * ctx , const char * msg ATTRIBUTE_UNUSED , . . . )
2001-02-23 20:55:21 +03:00
{
2024-04-09 17:54:02 +03:00
va_list ap ;
2024-01-04 04:48:02 +03:00
2024-04-09 17:54:02 +03:00
va_start ( ap , msg ) ;
xmlVFormatLegacyError ( ctx , " error " , msg , ap ) ;
va_end ( ap ) ;
2001-02-23 20:55:21 +03:00
}
/**
* xmlParserWarning :
* @ ctx : an XML parser context
* @ msg : the message to display / transmit
* @ . . . : extra parameters for the message display
2012-09-11 09:26:36 +04:00
*
2001-02-23 20:55:21 +03:00
* Display and format a warning messages , gives file , line , position and
* extra parameters .
*/
2022-12-08 04:43:17 +03:00
void
2023-12-18 21:12:08 +03:00
xmlParserWarning ( void * ctx , const char * msg ATTRIBUTE_UNUSED , . . . )
2001-02-23 20:55:21 +03:00
{
2024-04-09 17:54:02 +03:00
va_list ap ;
2024-01-04 04:48:02 +03:00
2024-04-09 17:54:02 +03:00
va_start ( ap , msg ) ;
xmlVFormatLegacyError ( ctx , " warning " , msg , ap ) ;
va_end ( ap ) ;
2001-02-23 20:55:21 +03:00
}
/**
* xmlParserValidityError :
* @ ctx : an XML parser context
* @ msg : the message to display / transmit
* @ . . . : extra parameters for the message display
2012-09-11 09:26:36 +04:00
*
2001-02-23 20:55:21 +03:00
* Display and format an validity error messages , gives file ,
* line , position and extra parameters .
*/
2022-12-08 04:43:17 +03:00
void
2023-12-18 21:12:08 +03:00
xmlParserValidityError ( void * ctx , const char * msg ATTRIBUTE_UNUSED , . . . )
2001-02-23 20:55:21 +03:00
{
2024-04-09 17:54:02 +03:00
va_list ap ;
2024-01-04 04:48:02 +03:00
2024-04-09 17:54:02 +03:00
va_start ( ap , msg ) ;
xmlVFormatLegacyError ( ctx , " validity error " , msg , ap ) ;
va_end ( ap ) ;
2001-02-23 20:55:21 +03:00
}
/**
* xmlParserValidityWarning :
* @ ctx : an XML parser context
* @ msg : the message to display / transmit
* @ . . . : extra parameters for the message display
2012-09-11 09:26:36 +04:00
*
2001-02-23 20:55:21 +03:00
* Display and format a validity warning messages , gives file , line ,
* position and extra parameters .
*/
2022-12-08 04:43:17 +03:00
void
2023-12-18 21:12:08 +03:00
xmlParserValidityWarning ( void * ctx , const char * msg ATTRIBUTE_UNUSED , . . . )
2001-02-23 20:55:21 +03:00
{
2024-04-09 17:54:02 +03:00
va_list ap ;
2024-01-04 04:48:02 +03:00
2024-04-09 17:54:02 +03:00
va_start ( ap , msg ) ;
xmlVFormatLegacyError ( ctx , " validity warning " , msg , ap ) ;
va_end ( ap ) ;
2001-02-23 20:55:21 +03:00
}
2003-10-03 02:28:19 +04:00
/************************************************************************
* *
* Extended Error Handling *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**
* xmlGetLastError :
*
* Get the last global error registered . This is per thread if compiled
* with thread support .
*
2023-09-22 00:52:52 +03:00
* Returns a pointer to the error
2003-10-03 02:28:19 +04:00
*/
2023-09-22 00:52:52 +03:00
const xmlError *
2003-10-03 02:28:19 +04:00
xmlGetLastError ( void )
{
if ( xmlLastError . code = = XML_ERR_OK )
return ( NULL ) ;
return ( & xmlLastError ) ;
}
/**
* xmlResetError :
* @ err : pointer to the error .
*
* Cleanup the error .
*/
void
xmlResetError ( xmlErrorPtr err )
{
if ( err = = NULL )
return ;
if ( err - > code = = XML_ERR_OK )
return ;
if ( err - > message ! = NULL )
xmlFree ( err - > message ) ;
if ( err - > file ! = NULL )
xmlFree ( err - > file ) ;
if ( err - > str1 ! = NULL )
xmlFree ( err - > str1 ) ;
if ( err - > str2 ! = NULL )
xmlFree ( err - > str2 ) ;
if ( err - > str3 ! = NULL )
xmlFree ( err - > str3 ) ;
memset ( err , 0 , sizeof ( xmlError ) ) ;
err - > code = XML_ERR_OK ;
}
/**
* xmlResetLastError :
*
* Cleanup the last global error registered . For parsing error
* this does not change the well - formedness result .
*/
void
xmlResetLastError ( void )
{
if ( xmlLastError . code = = XML_ERR_OK )
return ;
xmlResetError ( & xmlLastError ) ;
}
/**
* xmlCtxtGetLastError :
* @ ctx : an XML parser context
*
* Get the last parsing error registered .
*
2017-06-17 17:15:09 +03:00
* Returns NULL if no error occurred or a pointer to the error
2003-10-03 02:28:19 +04:00
*/
2023-10-24 16:02:36 +03:00
const xmlError *
2003-10-03 02:28:19 +04:00
xmlCtxtGetLastError ( void * ctx )
{
xmlParserCtxtPtr ctxt = ( xmlParserCtxtPtr ) ctx ;
if ( ctxt = = NULL )
return ( NULL ) ;
if ( ctxt - > lastError . code = = XML_ERR_OK )
return ( NULL ) ;
return ( & ctxt - > lastError ) ;
}
/**
* xmlCtxtResetLastError :
* @ ctx : an XML parser context
*
* Cleanup the last global error registered . For parsing error
* this does not change the well - formedness result .
*/
void
xmlCtxtResetLastError ( void * ctx )
{
xmlParserCtxtPtr ctxt = ( xmlParserCtxtPtr ) ctx ;
if ( ctxt = = NULL )
return ;
2010-03-15 17:59:07 +03:00
ctxt - > errNo = XML_ERR_OK ;
2003-10-03 02:28:19 +04:00
if ( ctxt - > lastError . code = = XML_ERR_OK )
return ;
xmlResetError ( & ctxt - > lastError ) ;
}
/**
* xmlCopyError :
* @ from : a source error
* @ to : a target error
*
* Save the original error to the new place .
*
* Returns 0 in case of success and - 1 in case of error .
*/
int
2023-09-22 00:52:52 +03:00
xmlCopyError ( const xmlError * from , xmlErrorPtr to ) {
2023-12-18 21:12:08 +03:00
const char * fmt = NULL ;
2004-07-31 20:24:01 +04:00
2003-10-03 02:28:19 +04:00
if ( ( from = = NULL ) | | ( to = = NULL ) )
return ( - 1 ) ;
2004-07-31 20:24:01 +04:00
2023-12-18 21:12:08 +03:00
if ( from - > message ! = NULL )
fmt = " %s " ;
2023-12-10 17:46:53 +03:00
2023-12-18 21:12:08 +03:00
return ( xmlSetError ( to , from - > ctxt , from - > node ,
from - > domain , from - > code , from - > level ,
from - > file , from - > line ,
from - > str1 , from - > str2 , from - > str3 ,
from - > int1 , from - > int2 ,
fmt , from - > message ) ) ;
2003-10-03 02:28:19 +04:00
}
2023-12-19 22:10:10 +03:00
/**
* xmlErrString :
* @ code : an xmlParserErrors code
*
* Returns an error message for a code .
*/
const char *
xmlErrString ( xmlParserErrors code ) {
const char * errmsg ;
switch ( code ) {
case XML_ERR_INVALID_HEX_CHARREF :
errmsg = " CharRef: invalid hexadecimal value " ;
break ;
case XML_ERR_INVALID_DEC_CHARREF :
errmsg = " CharRef: invalid decimal value " ;
break ;
case XML_ERR_INVALID_CHARREF :
errmsg = " CharRef: invalid value " ;
break ;
case XML_ERR_INTERNAL_ERROR :
errmsg = " internal error " ;
break ;
case XML_ERR_PEREF_AT_EOF :
errmsg = " PEReference at end of document " ;
break ;
case XML_ERR_PEREF_IN_PROLOG :
errmsg = " PEReference in prolog " ;
break ;
case XML_ERR_PEREF_IN_EPILOG :
errmsg = " PEReference in epilog " ;
break ;
case XML_ERR_PEREF_NO_NAME :
errmsg = " PEReference: no name " ;
break ;
case XML_ERR_PEREF_SEMICOL_MISSING :
errmsg = " PEReference: expecting ';' " ;
break ;
case XML_ERR_ENTITY_LOOP :
errmsg = " Detected an entity reference loop " ;
break ;
case XML_ERR_ENTITY_NOT_STARTED :
errmsg = " EntityValue: \" or ' expected " ;
break ;
case XML_ERR_ENTITY_PE_INTERNAL :
errmsg = " PEReferences forbidden in internal subset " ;
break ;
case XML_ERR_ENTITY_NOT_FINISHED :
errmsg = " EntityValue: \" or ' expected " ;
break ;
case XML_ERR_ATTRIBUTE_NOT_STARTED :
errmsg = " AttValue: \" or ' expected " ;
break ;
case XML_ERR_LT_IN_ATTRIBUTE :
errmsg = " Unescaped '<' not allowed in attributes values " ;
break ;
case XML_ERR_LITERAL_NOT_STARTED :
errmsg = " SystemLiteral \" or ' expected " ;
break ;
case XML_ERR_LITERAL_NOT_FINISHED :
errmsg = " Unfinished System or Public ID \" or ' expected " ;
break ;
case XML_ERR_MISPLACED_CDATA_END :
errmsg = " Sequence ']]>' not allowed in content " ;
break ;
case XML_ERR_URI_REQUIRED :
errmsg = " SYSTEM or PUBLIC, the URI is missing " ;
break ;
case XML_ERR_PUBID_REQUIRED :
errmsg = " PUBLIC, the Public Identifier is missing " ;
break ;
case XML_ERR_HYPHEN_IN_COMMENT :
errmsg = " Comment must not contain '--' (double-hyphen) " ;
break ;
case XML_ERR_PI_NOT_STARTED :
errmsg = " xmlParsePI : no target name " ;
break ;
case XML_ERR_RESERVED_XML_NAME :
errmsg = " Invalid PI name " ;
break ;
case XML_ERR_NOTATION_NOT_STARTED :
errmsg = " NOTATION: Name expected here " ;
break ;
case XML_ERR_NOTATION_NOT_FINISHED :
errmsg = " '>' required to close NOTATION declaration " ;
break ;
case XML_ERR_VALUE_REQUIRED :
errmsg = " Entity value required " ;
break ;
case XML_ERR_URI_FRAGMENT :
errmsg = " Fragment not allowed " ;
break ;
case XML_ERR_ATTLIST_NOT_STARTED :
errmsg = " '(' required to start ATTLIST enumeration " ;
break ;
case XML_ERR_NMTOKEN_REQUIRED :
errmsg = " NmToken expected in ATTLIST enumeration " ;
break ;
case XML_ERR_ATTLIST_NOT_FINISHED :
errmsg = " ')' required to finish ATTLIST enumeration " ;
break ;
case XML_ERR_MIXED_NOT_STARTED :
errmsg = " MixedContentDecl : '|' or ')*' expected " ;
break ;
case XML_ERR_PCDATA_REQUIRED :
errmsg = " MixedContentDecl : '#PCDATA' expected " ;
break ;
case XML_ERR_ELEMCONTENT_NOT_STARTED :
errmsg = " ContentDecl : Name or '(' expected " ;
break ;
case XML_ERR_ELEMCONTENT_NOT_FINISHED :
errmsg = " ContentDecl : ',' '|' or ')' expected " ;
break ;
case XML_ERR_PEREF_IN_INT_SUBSET :
errmsg =
" PEReference: forbidden within markup decl in internal subset " ;
break ;
case XML_ERR_GT_REQUIRED :
errmsg = " expected '>' " ;
break ;
case XML_ERR_CONDSEC_INVALID :
errmsg = " XML conditional section '[' expected " ;
break ;
2024-01-02 19:45:54 +03:00
case XML_ERR_INT_SUBSET_NOT_FINISHED :
errmsg = " Content error in the internal subset " ;
break ;
2023-12-19 22:10:10 +03:00
case XML_ERR_EXT_SUBSET_NOT_FINISHED :
errmsg = " Content error in the external subset " ;
break ;
case XML_ERR_CONDSEC_INVALID_KEYWORD :
errmsg =
" conditional section INCLUDE or IGNORE keyword expected " ;
break ;
case XML_ERR_CONDSEC_NOT_FINISHED :
errmsg = " XML conditional section not closed " ;
break ;
case XML_ERR_XMLDECL_NOT_STARTED :
errmsg = " Text declaration '<?xml' required " ;
break ;
case XML_ERR_XMLDECL_NOT_FINISHED :
errmsg = " parsing XML declaration: '?>' expected " ;
break ;
case XML_ERR_EXT_ENTITY_STANDALONE :
errmsg = " external parsed entities cannot be standalone " ;
break ;
case XML_ERR_ENTITYREF_SEMICOL_MISSING :
errmsg = " EntityRef: expecting ';' " ;
break ;
case XML_ERR_DOCTYPE_NOT_FINISHED :
errmsg = " DOCTYPE improperly terminated " ;
break ;
case XML_ERR_LTSLASH_REQUIRED :
errmsg = " EndTag: '</' not found " ;
break ;
case XML_ERR_EQUAL_REQUIRED :
errmsg = " expected '=' " ;
break ;
case XML_ERR_STRING_NOT_CLOSED :
errmsg = " String not closed expecting \" or ' " ;
break ;
case XML_ERR_STRING_NOT_STARTED :
errmsg = " String not started expecting ' or \" " ;
break ;
case XML_ERR_ENCODING_NAME :
errmsg = " Invalid XML encoding name " ;
break ;
case XML_ERR_STANDALONE_VALUE :
errmsg = " standalone accepts only 'yes' or 'no' " ;
break ;
case XML_ERR_DOCUMENT_EMPTY :
errmsg = " Document is empty " ;
break ;
case XML_ERR_DOCUMENT_END :
errmsg = " Extra content at the end of the document " ;
break ;
case XML_ERR_NOT_WELL_BALANCED :
errmsg = " chunk is not well balanced " ;
break ;
case XML_ERR_EXTRA_CONTENT :
errmsg = " extra content at the end of well balanced chunk " ;
break ;
case XML_ERR_VERSION_MISSING :
errmsg = " Malformed declaration expecting version " ;
break ;
case XML_ERR_NAME_TOO_LONG :
errmsg = " Name too long " ;
break ;
case XML_ERR_INVALID_ENCODING :
errmsg = " Invalid bytes in character encoding " ;
break ;
case XML_ERR_RESOURCE_LIMIT :
errmsg = " Resource limit exceeded " ;
break ;
case XML_ERR_ARGUMENT :
errmsg = " Invalid argument " ;
break ;
case XML_ERR_SYSTEM :
errmsg = " Out of system resources " ;
break ;
case XML_ERR_REDECL_PREDEF_ENTITY :
errmsg = " Invalid redeclaration of predefined entity " ;
break ;
2023-12-29 20:47:30 +03:00
case XML_ERR_UNSUPPORTED_ENCODING :
errmsg = " Unsupported encoding " ;
break ;
2024-01-03 20:12:29 +03:00
case XML_ERR_INVALID_CHAR :
errmsg = " Invalid character " ;
break ;
2023-12-19 22:10:10 +03:00
case XML_IO_UNKNOWN :
errmsg = " Unknown IO error " ; break ;
case XML_IO_EACCES :
errmsg = " Permission denied " ; break ;
case XML_IO_EAGAIN :
errmsg = " Resource temporarily unavailable " ; break ;
case XML_IO_EBADF :
errmsg = " Bad file descriptor " ; break ;
case XML_IO_EBADMSG :
errmsg = " Bad message " ; break ;
case XML_IO_EBUSY :
errmsg = " Resource busy " ; break ;
case XML_IO_ECANCELED :
errmsg = " Operation canceled " ; break ;
case XML_IO_ECHILD :
errmsg = " No child processes " ; break ;
case XML_IO_EDEADLK :
errmsg = " Resource deadlock avoided " ; break ;
case XML_IO_EDOM :
errmsg = " Domain error " ; break ;
case XML_IO_EEXIST :
errmsg = " File exists " ; break ;
case XML_IO_EFAULT :
errmsg = " Bad address " ; break ;
case XML_IO_EFBIG :
errmsg = " File too large " ; break ;
case XML_IO_EINPROGRESS :
errmsg = " Operation in progress " ; break ;
case XML_IO_EINTR :
errmsg = " Interrupted function call " ; break ;
case XML_IO_EINVAL :
errmsg = " Invalid argument " ; break ;
case XML_IO_EIO :
errmsg = " Input/output error " ; break ;
case XML_IO_EISDIR :
errmsg = " Is a directory " ; break ;
case XML_IO_EMFILE :
errmsg = " Too many open files " ; break ;
case XML_IO_EMLINK :
errmsg = " Too many links " ; break ;
case XML_IO_EMSGSIZE :
errmsg = " Inappropriate message buffer length " ; break ;
case XML_IO_ENAMETOOLONG :
errmsg = " Filename too long " ; break ;
case XML_IO_ENFILE :
errmsg = " Too many open files in system " ; break ;
case XML_IO_ENODEV :
errmsg = " No such device " ; break ;
case XML_IO_ENOENT :
errmsg = " No such file or directory " ; break ;
case XML_IO_ENOEXEC :
errmsg = " Exec format error " ; break ;
case XML_IO_ENOLCK :
errmsg = " No locks available " ; break ;
case XML_IO_ENOMEM :
errmsg = " Not enough space " ; break ;
case XML_IO_ENOSPC :
errmsg = " No space left on device " ; break ;
case XML_IO_ENOSYS :
errmsg = " Function not implemented " ; break ;
case XML_IO_ENOTDIR :
errmsg = " Not a directory " ; break ;
case XML_IO_ENOTEMPTY :
errmsg = " Directory not empty " ; break ;
case XML_IO_ENOTSUP :
errmsg = " Not supported " ; break ;
case XML_IO_ENOTTY :
errmsg = " Inappropriate I/O control operation " ; break ;
case XML_IO_ENXIO :
errmsg = " No such device or address " ; break ;
case XML_IO_EPERM :
errmsg = " Operation not permitted " ; break ;
case XML_IO_EPIPE :
errmsg = " Broken pipe " ; break ;
case XML_IO_ERANGE :
errmsg = " Result too large " ; break ;
case XML_IO_EROFS :
errmsg = " Read-only file system " ; break ;
case XML_IO_ESPIPE :
errmsg = " Invalid seek " ; break ;
case XML_IO_ESRCH :
errmsg = " No such process " ; break ;
case XML_IO_ETIMEDOUT :
errmsg = " Operation timed out " ; break ;
case XML_IO_EXDEV :
errmsg = " Improper link " ; break ;
case XML_IO_NETWORK_ATTEMPT :
errmsg = " Attempt to load network entity " ; break ;
case XML_IO_ENCODER :
errmsg = " encoder error " ; break ;
case XML_IO_FLUSH :
errmsg = " flush error " ; break ;
case XML_IO_WRITE :
errmsg = " write error " ; break ;
case XML_IO_NO_INPUT :
errmsg = " no input " ; break ;
case XML_IO_BUFFER_FULL :
errmsg = " buffer full " ; break ;
case XML_IO_LOAD_ERROR :
errmsg = " loading error " ; break ;
case XML_IO_ENOTSOCK :
errmsg = " not a socket " ; break ;
case XML_IO_EISCONN :
errmsg = " already connected " ; break ;
case XML_IO_ECONNREFUSED :
errmsg = " connection refused " ; break ;
case XML_IO_ENETUNREACH :
errmsg = " unreachable network " ; break ;
case XML_IO_EADDRINUSE :
errmsg = " address in use " ; break ;
case XML_IO_EALREADY :
errmsg = " already in use " ; break ;
case XML_IO_EAFNOSUPPORT :
errmsg = " unknown address family " ; break ;
2024-02-19 13:09:39 +03:00
case XML_IO_UNSUPPORTED_PROTOCOL :
errmsg = " unsupported protocol " ; break ;
2023-12-19 22:10:10 +03:00
default :
errmsg = " Unregistered error message " ;
}
return ( errmsg ) ;
}