version 1.1.1.2, 2013/07/22 01:22:19
|
version 1.1.1.3, 2014/06/15 19:53:29
|
Line 55
|
Line 55
|
#include <libxml/globals.h> |
#include <libxml/globals.h> |
#include <libxml/chvalid.h> |
#include <libxml/chvalid.h> |
|
|
|
#include "buf.h" |
|
#include "enc.h" |
|
|
/* |
/* |
* Various global defaults for parsing |
* Various global defaults for parsing |
*/ |
*/ |
Line 73 xmlCheckVersion(int version) {
|
Line 76 xmlCheckVersion(int version) {
|
xmlInitParser(); |
xmlInitParser(); |
|
|
if ((myversion / 10000) != (version / 10000)) { |
if ((myversion / 10000) != (version / 10000)) { |
xmlGenericError(xmlGenericErrorContext, | xmlGenericError(xmlGenericErrorContext, |
"Fatal: program compiled against libxml %d using libxml %d\n", |
"Fatal: program compiled against libxml %d using libxml %d\n", |
(version / 10000), (myversion / 10000)); |
(version / 10000), (myversion / 10000)); |
fprintf(stderr, | fprintf(stderr, |
"Fatal: program compiled against libxml %d using libxml %d\n", |
"Fatal: program compiled against libxml %d using libxml %d\n", |
(version / 10000), (myversion / 10000)); |
(version / 10000), (myversion / 10000)); |
} |
} |
if ((myversion / 100) < (version / 100)) { |
if ((myversion / 100) < (version / 100)) { |
xmlGenericError(xmlGenericErrorContext, | xmlGenericError(xmlGenericErrorContext, |
"Warning: program compiled against libxml %d using older %d\n", |
"Warning: program compiled against libxml %d using older %d\n", |
(version / 100), (myversion / 100)); |
(version / 100), (myversion / 100)); |
} |
} |
Line 90 xmlCheckVersion(int version) {
|
Line 93 xmlCheckVersion(int version) {
|
|
|
/************************************************************************ |
/************************************************************************ |
* * |
* * |
* Some factorized error routines * | * Some factorized error routines * |
* * |
* * |
************************************************************************/ |
************************************************************************/ |
|
|
Line 225 xmlIsLetter(int c) {
|
Line 228 xmlIsLetter(int c) {
|
|
|
/************************************************************************ |
/************************************************************************ |
* * |
* * |
* Input handling functions for progressive parsing * | * Input handling functions for progressive parsing * |
* * |
* * |
************************************************************************/ |
************************************************************************/ |
|
|
Line 242 xmlIsLetter(int c) {
|
Line 245 xmlIsLetter(int c) {
|
|
|
static |
static |
void check_buffer(xmlParserInputPtr in) { |
void check_buffer(xmlParserInputPtr in) { |
if (in->base != in->buf->buffer->content) { | if (in->base != xmlBufContent(in->buf->buffer)) { |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlParserInput: base mismatch problem\n"); |
"xmlParserInput: base mismatch problem\n"); |
} |
} |
Line 250 void check_buffer(xmlParserInputPtr in) {
|
Line 253 void check_buffer(xmlParserInputPtr in) {
|
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlParserInput: cur < base problem\n"); |
"xmlParserInput: cur < base problem\n"); |
} |
} |
if (in->cur > in->base + in->buf->buffer->use) { | if (in->cur > in->base + xmlBufUse(in->buf->buffer)) { |
xmlGenericError(xmlGenericErrorContext, |
xmlGenericError(xmlGenericErrorContext, |
"xmlParserInput: cur > base + use problem\n"); |
"xmlParserInput: cur > base + use problem\n"); |
} |
} |
xmlGenericError(xmlGenericErrorContext,"buffer %x : content %x, cur %d, use %d, size %d\n", | xmlGenericError(xmlGenericErrorContext,"buffer %x : content %x, cur %d, use %d\n", |
(int) in, (int) in->buf->buffer->content, in->cur - in->base, | (int) in, (int) xmlBufContent(in->buf->buffer), in->cur - in->base, |
in->buf->buffer->use, in->buf->buffer->size); | xmlBufUse(in->buf->buffer)); |
} |
} |
|
|
#else |
#else |
#define CHECK_BUFFER(in) | #define CHECK_BUFFER(in) |
#endif |
#endif |
|
|
|
|
Line 269 void check_buffer(xmlParserInputPtr in) {
|
Line 272 void check_buffer(xmlParserInputPtr in) {
|
* @in: an XML parser input |
* @in: an XML parser input |
* @len: an indicative size for the lookahead |
* @len: an indicative size for the lookahead |
* |
* |
* This function refresh the input for the parser. It doesn't try to | * This function was internal and is deprecated. |
* preserve pointers to the input buffer, and discard already read data | |
* |
* |
* Returns the number of xmlChars read, or -1 in case of error, 0 indicate the | * Returns -1 as this is an error to use it. |
* end of this entity | |
*/ |
*/ |
int |
int |
xmlParserInputRead(xmlParserInputPtr in, int len) { | xmlParserInputRead(xmlParserInputPtr in ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED) { |
int ret; | return(-1); |
int used; | |
int indx; | |
| |
if (in == NULL) return(-1); | |
#ifdef DEBUG_INPUT | |
xmlGenericError(xmlGenericErrorContext, "Read\n"); | |
#endif | |
if (in->buf == NULL) return(-1); | |
if (in->base == NULL) return(-1); | |
if (in->cur == NULL) return(-1); | |
if (in->buf->buffer == NULL) return(-1); | |
if (in->buf->readcallback == NULL) return(-1); | |
| |
CHECK_BUFFER(in); | |
| |
used = in->cur - in->buf->buffer->content; | |
ret = xmlBufferShrink(in->buf->buffer, used); | |
if (ret > 0) { | |
in->cur -= ret; | |
in->consumed += ret; | |
} | |
ret = xmlParserInputBufferRead(in->buf, len); | |
if (in->base != in->buf->buffer->content) { | |
/* | |
* the buffer has been reallocated | |
*/ | |
indx = in->cur - in->base; | |
in->base = in->buf->buffer->content; | |
in->cur = &in->buf->buffer->content[indx]; | |
} | |
in->end = &in->buf->buffer->content[in->buf->buffer->use]; | |
| |
CHECK_BUFFER(in); | |
| |
return(ret); | |
} |
} |
|
|
/** |
/** |
Line 323 xmlParserInputRead(xmlParserInputPtr in, int len) {
|
Line 289 xmlParserInputRead(xmlParserInputPtr in, int len) {
|
* This function increase the input for the parser. It tries to |
* This function increase the input for the parser. It tries to |
* preserve pointers to the input buffer, and keep already read data |
* preserve pointers to the input buffer, and keep already read data |
* |
* |
* Returns the number of xmlChars read, or -1 in case of error, 0 indicate the | * Returns the amount of char read, or -1 in case of error, 0 indicate the |
* end of this entity |
* end of this entity |
*/ |
*/ |
int |
int |
xmlParserInputGrow(xmlParserInputPtr in, int len) { |
xmlParserInputGrow(xmlParserInputPtr in, int len) { |
int ret; | size_t ret; |
int indx; | size_t indx; |
| const xmlChar *content; |
|
|
if (in == NULL) return(-1); | if ((in == NULL) || (len < 0)) return(-1); |
#ifdef DEBUG_INPUT |
#ifdef DEBUG_INPUT |
xmlGenericError(xmlGenericErrorContext, "Grow\n"); |
xmlGenericError(xmlGenericErrorContext, "Grow\n"); |
#endif |
#endif |
Line 343 xmlParserInputGrow(xmlParserInputPtr in, int len) {
|
Line 310 xmlParserInputGrow(xmlParserInputPtr in, int len) {
|
CHECK_BUFFER(in); |
CHECK_BUFFER(in); |
|
|
indx = in->cur - in->base; |
indx = in->cur - in->base; |
if (in->buf->buffer->use > (unsigned int) indx + INPUT_CHUNK) { | if (xmlBufUse(in->buf->buffer) > (unsigned int) indx + INPUT_CHUNK) { |
|
|
CHECK_BUFFER(in); |
CHECK_BUFFER(in); |
|
|
return(0); |
return(0); |
} |
} |
if (in->buf->readcallback != NULL) | if (in->buf->readcallback != NULL) { |
ret = xmlParserInputBufferGrow(in->buf, len); |
ret = xmlParserInputBufferGrow(in->buf, len); |
else | } else |
return(0); |
return(0); |
|
|
/* |
/* |
Line 360 xmlParserInputGrow(xmlParserInputPtr in, int len) {
|
Line 327 xmlParserInputGrow(xmlParserInputPtr in, int len) {
|
* pointer arithmetic. Insure will raise it as a bug but in |
* pointer arithmetic. Insure will raise it as a bug but in |
* that specific case, that's not ! |
* that specific case, that's not ! |
*/ |
*/ |
if (in->base != in->buf->buffer->content) { | |
| content = xmlBufContent(in->buf->buffer); |
| if (in->base != content) { |
/* |
/* |
* the buffer has been reallocated |
* the buffer has been reallocated |
*/ |
*/ |
indx = in->cur - in->base; |
indx = in->cur - in->base; |
in->base = in->buf->buffer->content; | in->base = content; |
in->cur = &in->buf->buffer->content[indx]; | in->cur = &content[indx]; |
} |
} |
in->end = &in->buf->buffer->content[in->buf->buffer->use]; | in->end = xmlBufEnd(in->buf->buffer); |
|
|
CHECK_BUFFER(in); |
CHECK_BUFFER(in); |
|
|
Line 383 xmlParserInputGrow(xmlParserInputPtr in, int len) {
|
Line 352 xmlParserInputGrow(xmlParserInputPtr in, int len) {
|
*/ |
*/ |
void |
void |
xmlParserInputShrink(xmlParserInputPtr in) { |
xmlParserInputShrink(xmlParserInputPtr in) { |
int used; | size_t used; |
int ret; | size_t ret; |
int indx; | size_t indx; |
| const xmlChar *content; |
|
|
#ifdef DEBUG_INPUT |
#ifdef DEBUG_INPUT |
xmlGenericError(xmlGenericErrorContext, "Shrink\n"); |
xmlGenericError(xmlGenericErrorContext, "Shrink\n"); |
Line 398 xmlParserInputShrink(xmlParserInputPtr in) {
|
Line 368 xmlParserInputShrink(xmlParserInputPtr in) {
|
|
|
CHECK_BUFFER(in); |
CHECK_BUFFER(in); |
|
|
used = in->cur - in->buf->buffer->content; | used = in->cur - xmlBufContent(in->buf->buffer); |
/* |
/* |
* Do not shrink on large buffers whose only a tiny fraction |
* Do not shrink on large buffers whose only a tiny fraction |
* was consumed |
* was consumed |
*/ |
*/ |
if (used > INPUT_CHUNK) { |
if (used > INPUT_CHUNK) { |
ret = xmlBufferShrink(in->buf->buffer, used - LINE_LEN); | ret = xmlBufShrink(in->buf->buffer, used - LINE_LEN); |
if (ret > 0) { |
if (ret > 0) { |
in->cur -= ret; |
in->cur -= ret; |
in->consumed += ret; |
in->consumed += ret; |
} |
} |
in->end = &in->buf->buffer->content[in->buf->buffer->use]; | in->end = xmlBufEnd(in->buf->buffer); |
} |
} |
|
|
CHECK_BUFFER(in); |
CHECK_BUFFER(in); |
|
|
if (in->buf->buffer->use > INPUT_CHUNK) { | if (xmlBufUse(in->buf->buffer) > INPUT_CHUNK) { |
return; |
return; |
} |
} |
xmlParserInputBufferRead(in->buf, 2 * INPUT_CHUNK); |
xmlParserInputBufferRead(in->buf, 2 * INPUT_CHUNK); |
if (in->base != in->buf->buffer->content) { | content = xmlBufContent(in->buf->buffer); |
| if (in->base != content) { |
/* |
/* |
* the buffer has been reallocated |
* the buffer has been reallocated |
*/ |
*/ |
indx = in->cur - in->base; |
indx = in->cur - in->base; |
in->base = in->buf->buffer->content; | in->base = content; |
in->cur = &in->buf->buffer->content[indx]; | in->cur = &content[indx]; |
} |
} |
in->end = &in->buf->buffer->content[in->buf->buffer->use]; | in->end = xmlBufEnd(in->buf->buffer); |
|
|
CHECK_BUFFER(in); |
CHECK_BUFFER(in); |
} |
} |
|
|
/************************************************************************ |
/************************************************************************ |
* * |
* * |
* UTF8 character input and related functions * | * UTF8 character input and related functions * |
* * |
* * |
************************************************************************/ |
************************************************************************/ |
|
|
Line 484 xmlNextChar(xmlParserCtxtPtr ctxt)
|
Line 455 xmlNextChar(xmlParserCtxtPtr ctxt)
|
* UCS-4 range (hex.) UTF-8 octet sequence (binary) |
* UCS-4 range (hex.) UTF-8 octet sequence (binary) |
* 0000 0000-0000 007F 0xxxxxxx |
* 0000 0000-0000 007F 0xxxxxxx |
* 0000 0080-0000 07FF 110xxxxx 10xxxxxx |
* 0000 0080-0000 07FF 110xxxxx 10xxxxxx |
* 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx | * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx |
* |
* |
* Check for the 0x110000 limit too |
* Check for the 0x110000 limit too |
*/ |
*/ |
Line 634 xmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) {
|
Line 605 xmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) {
|
* UCS-4 range (hex.) UTF-8 octet sequence (binary) |
* UCS-4 range (hex.) UTF-8 octet sequence (binary) |
* 0000 0000-0000 007F 0xxxxxxx |
* 0000 0000-0000 007F 0xxxxxxx |
* 0000 0080-0000 07FF 110xxxxx 10xxxxxx |
* 0000 0080-0000 07FF 110xxxxx 10xxxxxx |
* 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx | * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx |
* |
* |
* Check for the 0x110000 limit too |
* Check for the 0x110000 limit too |
*/ |
*/ |
Line 695 xmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) {
|
Line 666 xmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) {
|
if (!IS_CHAR(val)) { |
if (!IS_CHAR(val)) { |
xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR, |
xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR, |
"Char 0x%X out of allowed range\n", val); |
"Char 0x%X out of allowed range\n", val); |
} | } |
return(val); |
return(val); |
} else { |
} else { |
/* 1-byte code */ |
/* 1-byte code */ |
Line 759 encoding_error:
|
Line 730 encoding_error:
|
"Input is not proper UTF-8, indicate encoding !\n%s", |
"Input is not proper UTF-8, indicate encoding !\n%s", |
BAD_CAST buffer, NULL); |
BAD_CAST buffer, NULL); |
} |
} |
ctxt->charset = XML_CHAR_ENCODING_8859_1; | ctxt->charset = XML_CHAR_ENCODING_8859_1; |
*len = 1; |
*len = 1; |
return((int) *ctxt->input->cur); |
return((int) *ctxt->input->cur); |
} |
} |
Line 788 xmlStringCurrentChar(xmlParserCtxtPtr ctxt, const xmlC
|
Line 759 xmlStringCurrentChar(xmlParserCtxtPtr ctxt, const xmlC
|
* UCS-4 range (hex.) UTF-8 octet sequence (binary) |
* UCS-4 range (hex.) UTF-8 octet sequence (binary) |
* 0000 0000-0000 007F 0xxxxxxx |
* 0000 0000-0000 007F 0xxxxxxx |
* 0000 0080-0000 07FF 110xxxxx 10xxxxxx |
* 0000 0080-0000 07FF 110xxxxx 10xxxxxx |
* 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx | * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx |
* |
* |
* Check for the 0x110000 limit too |
* Check for the 0x110000 limit too |
*/ |
*/ |
Line 881 encoding_error:
|
Line 852 encoding_error:
|
* @out: pointer to an array of xmlChar |
* @out: pointer to an array of xmlChar |
* @val: the char value |
* @val: the char value |
* |
* |
* append the char value in the array | * append the char value in the array |
* |
* |
* Returns the number of xmlChar written |
* Returns the number of xmlChar written |
*/ |
*/ |
Line 895 xmlCopyCharMultiByte(xmlChar *out, int val) {
|
Line 866 xmlCopyCharMultiByte(xmlChar *out, int val) {
|
* UCS-4 range (hex.) UTF-8 octet sequence (binary) |
* UCS-4 range (hex.) UTF-8 octet sequence (binary) |
* 0000 0000-0000 007F 0xxxxxxx |
* 0000 0000-0000 007F 0xxxxxxx |
* 0000 0080-0000 07FF 110xxxxx 10xxxxxx |
* 0000 0080-0000 07FF 110xxxxx 10xxxxxx |
* 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx | * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx |
*/ |
*/ |
if (val >= 0x80) { |
if (val >= 0x80) { |
xmlChar *savedout = out; |
xmlChar *savedout = out; |
Line 923 xmlCopyCharMultiByte(xmlChar *out, int val) {
|
Line 894 xmlCopyCharMultiByte(xmlChar *out, int val) {
|
* @out: pointer to an array of xmlChar |
* @out: pointer to an array of xmlChar |
* @val: the char value |
* @val: the char value |
* |
* |
* append the char value in the array | * append the char value in the array |
* |
* |
* Returns the number of xmlChar written |
* Returns the number of xmlChar written |
*/ |
*/ |
Line 945 xmlCopyChar(int len ATTRIBUTE_UNUSED, xmlChar *out, in
|
Line 916 xmlCopyChar(int len ATTRIBUTE_UNUSED, xmlChar *out, in
|
* * |
* * |
************************************************************************/ |
************************************************************************/ |
|
|
/* defined in encoding.c, not public */ |
|
int |
|
xmlCharEncFirstLineInt(xmlCharEncodingHandler *handler, xmlBufferPtr out, |
|
xmlBufferPtr in, int len); |
|
|
|
static int |
static int |
xmlSwitchToEncodingInt(xmlParserCtxtPtr ctxt, |
xmlSwitchToEncodingInt(xmlParserCtxtPtr ctxt, |
xmlCharEncodingHandlerPtr handler, int len); |
xmlCharEncodingHandlerPtr handler, int len); |
Line 1189 xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlPa
|
Line 1155 xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlPa
|
/* |
/* |
* Is there already some content down the pipe to convert ? |
* Is there already some content down the pipe to convert ? |
*/ |
*/ |
if ((input->buf->buffer != NULL) && (input->buf->buffer->use > 0)) { | if (xmlBufIsEmpty(input->buf->buffer) == 0) { |
int processed; |
int processed; |
unsigned int use; |
unsigned int use; |
|
|
/* |
/* |
* Specific handling of the Byte Order Mark for | * Specific handling of the Byte Order Mark for |
* UTF-16 |
* UTF-16 |
*/ |
*/ |
if ((handler->name != NULL) && |
if ((handler->name != NULL) && |
Line 1225 xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlPa
|
Line 1191 xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlPa
|
* Move it as the raw buffer and create a new input buffer |
* Move it as the raw buffer and create a new input buffer |
*/ |
*/ |
processed = input->cur - input->base; |
processed = input->cur - input->base; |
xmlBufferShrink(input->buf->buffer, processed); | xmlBufShrink(input->buf->buffer, processed); |
input->buf->raw = input->buf->buffer; |
input->buf->raw = input->buf->buffer; |
input->buf->buffer = xmlBufferCreate(); | input->buf->buffer = xmlBufCreate(); |
input->buf->rawconsumed = processed; |
input->buf->rawconsumed = processed; |
use = input->buf->raw->use; | use = xmlBufUse(input->buf->raw); |
|
|
if (ctxt->html) { |
if (ctxt->html) { |
/* |
/* |
* convert as much as possible of the buffer |
* convert as much as possible of the buffer |
*/ |
*/ |
nbchars = xmlCharEncInFunc(input->buf->encoder, | nbchars = xmlCharEncInput(input->buf, 1); |
input->buf->buffer, | |
input->buf->raw); | |
} else { |
} else { |
/* |
/* |
* convert just enough to get |
* convert just enough to get |
Line 1245 xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlPa
|
Line 1209 xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlPa
|
* parsed with the autodetected encoding |
* parsed with the autodetected encoding |
* into the parser reading buffer. |
* into the parser reading buffer. |
*/ |
*/ |
nbchars = xmlCharEncFirstLineInt(input->buf->encoder, | nbchars = xmlCharEncFirstLineInput(input->buf, len); |
input->buf->buffer, | |
input->buf->raw, | |
len); | |
} |
} |
if (nbchars < 0) { |
if (nbchars < 0) { |
xmlErrInternal(ctxt, |
xmlErrInternal(ctxt, |
Line 1256 xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlPa
|
Line 1217 xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlPa
|
NULL); |
NULL); |
return (-1); |
return (-1); |
} |
} |
input->buf->rawconsumed += use - input->buf->raw->use; | input->buf->rawconsumed += use - xmlBufUse(input->buf->raw); |
input->base = input->cur = input->buf->buffer->content; | xmlBufResetInput(input->buf->buffer, input); |
input->end = &input->base[input->buf->buffer->use]; | |
| |
} |
} |
return (0); |
return (0); |
} else if (input->length == 0) { |
} else if (input->length == 0) { |
Line 1294 xmlSwitchInputEncoding(xmlParserCtxtPtr ctxt, xmlParse
|
Line 1253 xmlSwitchInputEncoding(xmlParserCtxtPtr ctxt, xmlParse
|
* xmlSwitchToEncodingInt: |
* xmlSwitchToEncodingInt: |
* @ctxt: the parser context |
* @ctxt: the parser context |
* @handler: the encoding handler |
* @handler: the encoding handler |
* @len: the lenght to convert or -1 | * @len: the length to convert or -1 |
* |
* |
* change the input functions when discovering the character encoding |
* change the input functions when discovering the character encoding |
* of a given entity, and convert only @len bytes of the output, this |
* of a given entity, and convert only @len bytes of the output, this |
Line 1336 xmlSwitchToEncodingInt(xmlParserCtxtPtr ctxt,
|
Line 1295 xmlSwitchToEncodingInt(xmlParserCtxtPtr ctxt,
|
* Returns 0 in case of success, -1 otherwise |
* Returns 0 in case of success, -1 otherwise |
*/ |
*/ |
int |
int |
xmlSwitchToEncoding(xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler) | xmlSwitchToEncoding(xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler) |
{ |
{ |
return (xmlSwitchToEncodingInt(ctxt, handler, -1)); |
return (xmlSwitchToEncodingInt(ctxt, handler, -1)); |
} |
} |
Line 1363 xmlFreeInputStream(xmlParserInputPtr input) {
|
Line 1322 xmlFreeInputStream(xmlParserInputPtr input) {
|
if (input->version != NULL) xmlFree((char *) input->version); |
if (input->version != NULL) xmlFree((char *) input->version); |
if ((input->free != NULL) && (input->base != NULL)) |
if ((input->free != NULL) && (input->base != NULL)) |
input->free((xmlChar *) input->base); |
input->free((xmlChar *) input->base); |
if (input->buf != NULL) | if (input->buf != NULL) |
xmlFreeParserInputBuffer(input->buf); |
xmlFreeParserInputBuffer(input->buf); |
xmlFree(input); |
xmlFree(input); |
} |
} |
Line 1426 xmlNewIOInputStream(xmlParserCtxtPtr ctxt, xmlParserIn
|
Line 1385 xmlNewIOInputStream(xmlParserCtxtPtr ctxt, xmlParserIn
|
} |
} |
inputStream->filename = NULL; |
inputStream->filename = NULL; |
inputStream->buf = input; |
inputStream->buf = input; |
inputStream->base = inputStream->buf->buffer->content; | xmlBufResetInput(inputStream->buf->buffer, inputStream); |
inputStream->cur = inputStream->buf->buffer->content; | |
inputStream->end = &inputStream->base[inputStream->buf->buffer->use]; | |
if (enc != XML_CHAR_ENCODING_NONE) { |
if (enc != XML_CHAR_ENCODING_NONE) { |
xmlSwitchEncoding(ctxt, enc); |
xmlSwitchEncoding(ctxt, enc); |
} |
} |
Line 1570 xmlNewInputFromFile(xmlParserCtxtPtr ctxt, const char
|
Line 1528 xmlNewInputFromFile(xmlParserCtxtPtr ctxt, const char
|
inputStream = xmlCheckHTTPInput(ctxt, inputStream); |
inputStream = xmlCheckHTTPInput(ctxt, inputStream); |
if (inputStream == NULL) |
if (inputStream == NULL) |
return(NULL); |
return(NULL); |
| |
if (inputStream->filename == NULL) |
if (inputStream->filename == NULL) |
URI = xmlStrdup((xmlChar *) filename); |
URI = xmlStrdup((xmlChar *) filename); |
else |
else |
Line 1581 xmlNewInputFromFile(xmlParserCtxtPtr ctxt, const char
|
Line 1539 xmlNewInputFromFile(xmlParserCtxtPtr ctxt, const char
|
if (URI != NULL) xmlFree((char *) URI); |
if (URI != NULL) xmlFree((char *) URI); |
inputStream->directory = directory; |
inputStream->directory = directory; |
|
|
inputStream->base = inputStream->buf->buffer->content; | xmlBufResetInput(inputStream->buf->buffer, inputStream); |
inputStream->cur = inputStream->buf->buffer->content; | |
inputStream->end = &inputStream->base[inputStream->buf->buffer->use]; | |
if ((ctxt->directory == NULL) && (directory != NULL)) |
if ((ctxt->directory == NULL) && (directory != NULL)) |
ctxt->directory = (char *) xmlStrdup((const xmlChar *) directory); |
ctxt->directory = (char *) xmlStrdup((const xmlChar *) directory); |
return(inputStream); |
return(inputStream); |
Line 1622 xmlInitParserCtxt(xmlParserCtxtPtr ctxt)
|
Line 1578 xmlInitParserCtxt(xmlParserCtxtPtr ctxt)
|
xmlErrMemory(NULL, "cannot initialize parser context\n"); |
xmlErrMemory(NULL, "cannot initialize parser context\n"); |
return(-1); |
return(-1); |
} |
} |
|
xmlDictSetLimit(ctxt->dict, XML_MAX_DICTIONARY_LIMIT); |
|
|
if (ctxt->sax == NULL) |
if (ctxt->sax == NULL) |
ctxt->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler)); |
ctxt->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler)); |
if (ctxt->sax == NULL) { |
if (ctxt->sax == NULL) { |
Line 1761 xmlInitParserCtxt(xmlParserCtxtPtr ctxt)
|
Line 1719 xmlInitParserCtxt(xmlParserCtxtPtr ctxt)
|
ctxt->charset = XML_CHAR_ENCODING_UTF8; |
ctxt->charset = XML_CHAR_ENCODING_UTF8; |
ctxt->catalogs = NULL; |
ctxt->catalogs = NULL; |
ctxt->nbentities = 0; |
ctxt->nbentities = 0; |
|
ctxt->sizeentities = 0; |
|
ctxt->sizeentcopy = 0; |
ctxt->input_id = 1; |
ctxt->input_id = 1; |
xmlInitNodeInfoSeq(&ctxt->node_seq); |
xmlInitNodeInfoSeq(&ctxt->node_seq); |
return(0); |
return(0); |
Line 1807 xmlFreeParserCtxt(xmlParserCtxtPtr ctxt)
|
Line 1767 xmlFreeParserCtxt(xmlParserCtxtPtr ctxt)
|
if (ctxt->nsTab != NULL) xmlFree((char *) ctxt->nsTab); |
if (ctxt->nsTab != NULL) xmlFree((char *) ctxt->nsTab); |
if (ctxt->pushTab != NULL) xmlFree(ctxt->pushTab); |
if (ctxt->pushTab != NULL) xmlFree(ctxt->pushTab); |
if (ctxt->attallocs != NULL) xmlFree(ctxt->attallocs); |
if (ctxt->attallocs != NULL) xmlFree(ctxt->attallocs); |
if (ctxt->attsDefault != NULL) | if (ctxt->attsDefault != NULL) |
xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree); |
xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree); |
if (ctxt->attsSpecial != NULL) |
if (ctxt->attsSpecial != NULL) |
xmlHashFree(ctxt->attsSpecial, NULL); |
xmlHashFree(ctxt->attsSpecial, NULL); |
Line 1907 xmlClearParserCtxt(xmlParserCtxtPtr ctxt)
|
Line 1867 xmlClearParserCtxt(xmlParserCtxtPtr ctxt)
|
* @node: an XML node within the tree |
* @node: an XML node within the tree |
* |
* |
* Find the parser node info struct for a given node |
* Find the parser node info struct for a given node |
* | * |
* Returns an xmlParserNodeInfo block pointer or NULL |
* Returns an xmlParserNodeInfo block pointer or NULL |
*/ |
*/ |
const xmlParserNodeInfo * |
const xmlParserNodeInfo * |
Line 1965 xmlClearNodeInfoSeq(xmlParserNodeInfoSeqPtr seq)
|
Line 1925 xmlClearNodeInfoSeq(xmlParserNodeInfoSeqPtr seq)
|
* @seq: a node info sequence pointer |
* @seq: a node info sequence pointer |
* @node: an XML node pointer |
* @node: an XML node pointer |
* |
* |
* | * |
* xmlParserFindNodeInfoIndex : Find the index that the info record for |
* xmlParserFindNodeInfoIndex : Find the index that the info record for |
* the given node is or should be at in a sorted sequence |
* the given node is or should be at in a sorted sequence |
* |
* |
Line 2022 xmlParserAddNodeInfo(xmlParserCtxtPtr ctxt,
|
Line 1982 xmlParserAddNodeInfo(xmlParserCtxtPtr ctxt,
|
pos = xmlParserFindNodeInfoIndex(&ctxt->node_seq, (xmlNodePtr) |
pos = xmlParserFindNodeInfoIndex(&ctxt->node_seq, (xmlNodePtr) |
info->node); |
info->node); |
|
|
if ((pos < ctxt->node_seq.length) && | if ((pos < ctxt->node_seq.length) && |
(ctxt->node_seq.buffer != NULL) && |
(ctxt->node_seq.buffer != NULL) && |
(ctxt->node_seq.buffer[pos].node == info->node)) { |
(ctxt->node_seq.buffer[pos].node == info->node)) { |
ctxt->node_seq.buffer[pos] = *info; |
ctxt->node_seq.buffer[pos] = *info; |
Line 2075 xmlParserAddNodeInfo(xmlParserCtxtPtr ctxt,
|
Line 2035 xmlParserAddNodeInfo(xmlParserCtxtPtr ctxt,
|
************************************************************************/ |
************************************************************************/ |
/** |
/** |
* xmlPedanticParserDefault: |
* xmlPedanticParserDefault: |
* @val: int 0 or 1 | * @val: int 0 or 1 |
* |
* |
* Set and return the previous value for enabling pedantic warnings. |
* Set and return the previous value for enabling pedantic warnings. |
* |
* |
Line 2092 xmlPedanticParserDefault(int val) {
|
Line 2052 xmlPedanticParserDefault(int val) {
|
|
|
/** |
/** |
* xmlLineNumbersDefault: |
* xmlLineNumbersDefault: |
* @val: int 0 or 1 | * @val: int 0 or 1 |
* |
* |
* Set and return the previous value for enabling line numbers in elements |
* Set and return the previous value for enabling line numbers in elements |
* contents. This may break on old application and is turned off by default. |
* contents. This may break on old application and is turned off by default. |
Line 2110 xmlLineNumbersDefault(int val) {
|
Line 2070 xmlLineNumbersDefault(int val) {
|
|
|
/** |
/** |
* xmlSubstituteEntitiesDefault: |
* xmlSubstituteEntitiesDefault: |
* @val: int 0 or 1 | * @val: int 0 or 1 |
* |
* |
* Set and return the previous value for default entity support. |
* Set and return the previous value for default entity support. |
* Initially the parser always keep entity references instead of substituting |
* Initially the parser always keep entity references instead of substituting |
Line 2132 xmlSubstituteEntitiesDefault(int val) {
|
Line 2092 xmlSubstituteEntitiesDefault(int val) {
|
|
|
/** |
/** |
* xmlKeepBlanksDefault: |
* xmlKeepBlanksDefault: |
* @val: int 0 or 1 | * @val: int 0 or 1 |
* |
* |
* Set and return the previous value for default blanks text nodes support. |
* Set and return the previous value for default blanks text nodes support. |
* The 1.x version of the parser used an heuristic to try to detect |
* The 1.x version of the parser used an heuristic to try to detect |
Line 2143 xmlSubstituteEntitiesDefault(int val) {
|
Line 2103 xmlSubstituteEntitiesDefault(int val) {
|
* ignorableWhitespace() are only generated when running the parser in |
* ignorableWhitespace() are only generated when running the parser in |
* validating mode and when the current element doesn't allow CDATA or |
* validating mode and when the current element doesn't allow CDATA or |
* mixed content. |
* mixed content. |
* This function is provided as a way to force the standard behavior | * This function is provided as a way to force the standard behavior |
* on 1.X libs and to switch back to the old mode for compatibility when |
* on 1.X libs and to switch back to the old mode for compatibility when |
* running 1.X client code on 2.X . Upgrade of 1.X code should be done |
* running 1.X client code on 2.X . Upgrade of 1.X code should be done |
* by using xmlIsBlankNode() commodity function to detect the "empty" |
* by using xmlIsBlankNode() commodity function to detect the "empty" |