parserInternals.c File Reference

#include "libxml.h"
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <libxml/xmlmemory.h>
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <libxml/parserInternals.h>
#include <libxml/valid.h>
#include <libxml/entities.h>
#include <libxml/xmlerror.h>
#include <libxml/encoding.h>
#include <libxml/xmlIO.h>
#include <libxml/uri.h>
#include <libxml/dict.h>
#include <libxml/SAX.h>
#include <libxml/globals.h>
#include <libxml/chvalid.h>
#include "buf.h"
#include "enc.h"
#include "elfgcchack.h"

Include dependency graph for parserInternals.c:

Go to the source code of this file.

Macros
#define	IN_LIBXML
#define	XML_DIR_SEP   '/'
#define	CUR(ctxt)   ctxt->input->cur
#define	END(ctxt)   ctxt->input->end
#define	VALID_CTXT(ctxt)   (CUR(ctxt) <= END(ctxt))
#define	LINE_LEN   80
#define	CHECK_BUFFER(in)
#define	bottom_parserInternals

Functions
void	xmlCheckVersion (int version)
void	xmlErrMemory (xmlParserCtxtPtr ctxt, const char *extra)
void	__xmlErrEncoding (xmlParserCtxtPtr ctxt, xmlParserErrors xmlerr, const char *msg, const xmlChar *str1, const xmlChar *str2)
static void	LIBXML_ATTR_FORMAT (2, 0)
static void	LIBXML_ATTR_FORMAT (3, 0)
int	xmlIsLetter (int c)
int	xmlParserInputRead (xmlParserInputPtr in ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED)
int	xmlParserInputGrow (xmlParserInputPtr in, int len)
void	xmlParserInputShrink (xmlParserInputPtr in)
void	xmlNextChar (xmlParserCtxtPtr ctxt)
int	xmlCurrentChar (xmlParserCtxtPtr ctxt, int *len)
int	xmlStringCurrentChar (xmlParserCtxtPtr ctxt, const xmlChar *cur, int *len)
int	xmlCopyCharMultiByte (xmlChar *out, int val)
int	xmlCopyChar (int len ATTRIBUTE_UNUSED, xmlChar *out, int val)
static int	xmlSwitchToEncodingInt (xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler, int len)
static int	xmlSwitchInputEncodingInt (xmlParserCtxtPtr ctxt, xmlParserInputPtr input, xmlCharEncodingHandlerPtr handler, int len)
int	xmlSwitchEncoding (xmlParserCtxtPtr ctxt, xmlCharEncoding enc)
int	xmlSwitchInputEncoding (xmlParserCtxtPtr ctxt, xmlParserInputPtr input, xmlCharEncodingHandlerPtr handler)
int	xmlSwitchToEncoding (xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler)
void	xmlFreeInputStream (xmlParserInputPtr input)
xmlParserInputPtr	xmlNewInputStream (xmlParserCtxtPtr ctxt)
xmlParserInputPtr	xmlNewIOInputStream (xmlParserCtxtPtr ctxt, xmlParserInputBufferPtr input, xmlCharEncoding enc)
xmlParserInputPtr	xmlNewEntityInputStream (xmlParserCtxtPtr ctxt, xmlEntityPtr entity)
xmlParserInputPtr	xmlNewStringInputStream (xmlParserCtxtPtr ctxt, const xmlChar *buffer)
xmlParserInputPtr	xmlNewInputFromFile (xmlParserCtxtPtr ctxt, const char *filename)
int	xmlInitParserCtxt (xmlParserCtxtPtr ctxt)
void	xmlFreeParserCtxt (xmlParserCtxtPtr ctxt)
xmlParserCtxtPtr	xmlNewParserCtxt (void)
void	xmlClearParserCtxt (xmlParserCtxtPtr ctxt)
const xmlParserNodeInfo *	xmlParserFindNodeInfo (const xmlParserCtxtPtr ctx, const xmlNodePtr node)
void	xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq)
void	xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq)
unsigned long	xmlParserFindNodeInfoIndex (const xmlParserNodeInfoSeqPtr seq, const xmlNodePtr node)
void	xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt, const xmlParserNodeInfoPtr info)
int	xmlPedanticParserDefault (int val)
int	xmlLineNumbersDefault (int val)
int	xmlSubstituteEntitiesDefault (int val)
int	xmlKeepBlanksDefault (int val)

Macro Definition Documentation

bottom_parserInternals

#define bottom_parserInternals

Definition at line 2164 of file parserInternals.c.

CHECK_BUFFER

#define CHECK_BUFFER

(

in

)

Definition at line 270 of file parserInternals.c.

CUR

#define CUR

(

ctxt

)

ctxt->input->cur

Definition at line 58 of file parserInternals.c.

END

#define END

(

ctxt

)

ctxt->input->end

Definition at line 59 of file parserInternals.c.

IN_LIBXML

#define IN_LIBXML

Definition at line 10 of file parserInternals.c.

LINE_LEN

#define LINE_LEN   80

Definition at line 245 of file parserInternals.c.

VALID_CTXT

#define VALID_CTXT

(

ctxt

)

(CUR(ctxt) <= END(ctxt))

Definition at line 60 of file parserInternals.c.

XML_DIR_SEP

#define XML_DIR_SEP   '/'

Definition at line 16 of file parserInternals.c.

Function Documentation

__xmlErrEncoding()

void __xmlErrEncoding	(	xmlParserCtxtPtr	ctxt,
		xmlParserErrors	xmlerr,
		const char *	msg,
		const xmlChar *	str1,
		const xmlChar *	str2
	)

__xmlErrEncoding: @ctxt: an XML parser context @xmlerr: the error number @msg: the error message @str1: an string info @str2: an string info

Handle an encoding error

Definition at line 145 of file parserInternals.c.

{
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
        (ctxt->instate == XML_PARSER_EOF))
    return;
    if (ctxt != NULL)
        ctxt->errNo = xmlerr;
    __xmlRaiseError(NULL, NULL, NULL,
                    ctxt, NULL, XML_FROM_PARSER, xmlerr, XML_ERR_FATAL,
                    NULL, 0, (const char *) str1, (const char *) str2,
                    NULL, 0, 0, msg, str1, str2);
    if (ctxt != NULL) {
        ctxt->wellFormed = 0;
        if (ctxt->recovery == 0)
            ctxt->disableSAX = 1;
    }
}

Referenced by xmlCurrentChar(), xmlNextChar(), xmlStringCurrentChar(), and xmlSwitchEncoding().

LIBXML_ATTR_FORMAT() [1/2]

static void LIBXML_ATTR_FORMAT ( 2  , 0    )

static

xmlErrInternal: @ctxt: an XML parser context @msg: the error message @str: error informations

Handle an internal error

Definition at line 172 of file parserInternals.c.

{
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
        (ctxt->instate == XML_PARSER_EOF))
    return;
    if (ctxt != NULL)
        ctxt->errNo = XML_ERR_INTERNAL_ERROR;
    __xmlRaiseError(NULL, NULL, NULL,
                    ctxt, NULL, XML_FROM_PARSER, XML_ERR_INTERNAL_ERROR,
                    XML_ERR_FATAL, NULL, 0, (const char *) str, NULL, NULL,
                    0, 0, msg, str);
    if (ctxt != NULL) {
        ctxt->wellFormed = 0;
        if (ctxt->recovery == 0)
            ctxt->disableSAX = 1;
    }
}

LIBXML_ATTR_FORMAT() [2/2]

static void LIBXML_ATTR_FORMAT ( 3  , 0    )

static

xmlErrEncodingInt: @ctxt: an XML parser context @error: the error number @msg: the error message @val: an integer value

n encoding error

Definition at line 200 of file parserInternals.c.

{
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
        (ctxt->instate == XML_PARSER_EOF))
    return;
    if (ctxt != NULL)
        ctxt->errNo = error;
    __xmlRaiseError(NULL, NULL, NULL,
                    ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
                    NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
    if (ctxt != NULL) {
        ctxt->wellFormed = 0;
        if (ctxt->recovery == 0)
            ctxt->disableSAX = 1;
    }
}

xmlCheckVersion()

void xmlCheckVersion

(

int

version

)

xmlCheckVersion:

Version

: the include version number

check the compiled lib version against the include one. This can warn or immediately kill the application

Definition at line 77 of file parserInternals.c.

                             {
    int myversion = (int) LIBXML_VERSION;

    xmlInitParser();

    if ((myversion / 10000) != (version / 10000)) {
    xmlGenericError(xmlGenericErrorContext,
        "Fatal: program compiled against libxml %d using libxml %d\n",
        (version / 10000), (myversion / 10000));
    fprintf(stderr,
        "Fatal: program compiled against libxml %d using libxml %d\n",
        (version / 10000), (myversion / 10000));
    }
    if ((myversion / 100) < (version / 100)) {
    xmlGenericError(xmlGenericErrorContext,
        "Warning: program compiled against libxml %d using older %d\n",
        (version / 100), (myversion / 100));
    }
}

xmlClearNodeInfoSeq()

void xmlClearNodeInfoSeq

(

xmlParserNodeInfoSeqPtr

seq

)

xmlClearNodeInfoSeq: @seq: a node info sequence pointer

– Clear (release memory and reinitialize) node info sequence

Definition at line 1951 of file parserInternals.c.

{
    if (seq == NULL)
        return;
    if (seq->buffer != NULL)
        xmlFree(seq->buffer);
    xmlInitNodeInfoSeq(seq);
}

Referenced by xmlClearParserCtxt().

xmlClearParserCtxt()

void xmlClearParserCtxt

(

xmlParserCtxtPtr

ctxt

)

xmlClearParserCtxt: @ctxt: an XML parser context

Clear (release owned resources) and reinitialize a parser context

Definition at line 1892 of file parserInternals.c.

{
  if (ctxt==NULL)
    return;
  xmlClearNodeInfoSeq(&ctxt->node_seq);
  xmlCtxtReset(ctxt);
}

xmlCopyChar()

int xmlCopyChar	(	int len	ATTRIBUTE_UNUSED,
		xmlChar *	out,
		int	val
	)

xmlCopyChar: @len: Ignored, compatibility @out: pointer to an array of xmlChar @val: the char value

append the char value in the array

Returns the number of xmlChar written

Definition at line 900 of file parserInternals.c.

                                                             {
    if (out == NULL) return(0);
    /* the len parameter is ignored */
    if  (val >= 0x80) {
    return(xmlCopyCharMultiByte (out, val));
    }
    *out = (xmlChar) val;
    return 1;
}

Referenced by xmlParseAttValueComplex().

xmlCopyCharMultiByte()

int xmlCopyCharMultiByte	(	xmlChar *	out,
		int	val
	)

xmlCopyCharMultiByte: @out: pointer to an array of xmlChar @val: the char value

append the char value in the array

Returns the number of xmlChar written

Definition at line 857 of file parserInternals.c.

                                            {
    if (out == NULL) return(0);
    /*
     * We are supposed to handle UTF8, check it's valid
     * From rfc2044: encoding of the Unicode values on UTF-8:
     *
     * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
     * 0000 0000-0000 007F   0xxxxxxx
     * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
     * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
     */
    if  (val >= 0x80) {
    xmlChar *savedout = out;
    int bits;
    if (val <   0x800) { *out++= (val >>  6) | 0xC0;  bits=  0; }
    else if (val < 0x10000) { *out++= (val >> 12) | 0xE0;  bits=  6;}
    else if (val < 0x110000)  { *out++= (val >> 18) | 0xF0;  bits=  12; }
    else {
        xmlErrEncodingInt(NULL, XML_ERR_INVALID_CHAR,
            "Internal error, xmlCopyCharMultiByte 0x%X out of bound\n",
                  val);
        return(0);
    }
    for ( ; bits >= 0; bits-= 6)
        *out++= ((val >> bits) & 0x3F) | 0x80 ;
    return (out - savedout);
    }
    *out = (xmlChar) val;
    return 1;
}

Referenced by xmlCopyChar(), and xsltNumberFormatDecimal().

xmlCurrentChar()

int xmlCurrentChar	(	xmlParserCtxtPtr	ctxt,
		int *	len
	)

xmlCurrentChar: @ctxt: the XML parser context @len: pointer to the length of the char read

The current char value, if using UTF-8 this may actually span multiple bytes in the input buffer. Implement the end of line normalization: 2.11 End-of-Line Handling Wherever an external parsed entity or the literal entity value of an internal parsed entity contains either the literal two-character sequence "#xD#xA" or a standalone literal #xD, an XML processor must pass to the application the single character #xA. This behavior can conveniently be produced by normalizing all line breaks to #xA on input, before parsing.)

Returns the current char value and its length

Definition at line 588 of file parserInternals.c.

                                                {
    if ((ctxt == NULL) || (len == NULL) || (ctxt->input == NULL)) return(0);
    if (ctxt->instate == XML_PARSER_EOF)
    return(0);

    if ((*ctxt->input->cur >= 0x20) && (*ctxt->input->cur <= 0x7F)) {
        *len = 1;
        return((int) *ctxt->input->cur);
    }
    if (ctxt->charset == XML_CHAR_ENCODING_UTF8) {
    /*
     * We are supposed to handle UTF8, check it's valid
     * From rfc2044: encoding of the Unicode values on UTF-8:
     *
     * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
     * 0000 0000-0000 007F   0xxxxxxx
     * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
     * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
     *
     * Check for the 0x110000 limit too
     */
    const unsigned char *cur = ctxt->input->cur;
    unsigned char c;
    unsigned int val;

    c = *cur;
    if (c & 0x80) {
        if (((c & 0x40) == 0) || (c == 0xC0))
        goto encoding_error;
        if (cur[1] == 0) {
        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
                cur = ctxt->input->cur;
            }
        if ((cur[1] & 0xc0) != 0x80)
        goto encoding_error;
        if ((c & 0xe0) == 0xe0) {
        if (cur[2] == 0) {
            xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
                    cur = ctxt->input->cur;
                }
        if ((cur[2] & 0xc0) != 0x80)
            goto encoding_error;
        if ((c & 0xf0) == 0xf0) {
            if (cur[3] == 0) {
            xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
                        cur = ctxt->input->cur;
                    }
            if (((c & 0xf8) != 0xf0) ||
            ((cur[3] & 0xc0) != 0x80))
            goto encoding_error;
            /* 4-byte code */
            *len = 4;
            val = (cur[0] & 0x7) << 18;
            val |= (cur[1] & 0x3f) << 12;
            val |= (cur[2] & 0x3f) << 6;
            val |= cur[3] & 0x3f;
            if (val < 0x10000)
            goto encoding_error;
        } else {
          /* 3-byte code */
            *len = 3;
            val = (cur[0] & 0xf) << 12;
            val |= (cur[1] & 0x3f) << 6;
            val |= cur[2] & 0x3f;
            if (val < 0x800)
            goto encoding_error;
        }
        } else {
          /* 2-byte code */
        *len = 2;
        val = (cur[0] & 0x1f) << 6;
        val |= cur[1] & 0x3f;
        if (val < 0x80)
            goto encoding_error;
        }
        if (!IS_CHAR(val)) {
            xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
                  "Char 0x%X out of allowed range\n", val);
        }
        return(val);
    } else {
        /* 1-byte code */
        *len = 1;
        if (*ctxt->input->cur == 0)
        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
        if ((*ctxt->input->cur == 0) &&
            (ctxt->input->end > ctxt->input->cur)) {
            xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
                  "Char 0x0 out of allowed range\n", 0);
        }
        if (*ctxt->input->cur == 0xD) {
        if (ctxt->input->cur[1] == 0xA) {
            ctxt->nbChars++;
            ctxt->input->cur++;
        }
        return(0xA);
        }
        return((int) *ctxt->input->cur);
    }
    }
    /*
     * Assume it's a fixed length encoding (1) with
     * a compatible encoding for the ASCII set, since
     * XML constructs only use < 128 chars
     */
    *len = 1;
    if (*ctxt->input->cur == 0xD) {
    if (ctxt->input->cur[1] == 0xA) {
        ctxt->nbChars++;
        ctxt->input->cur++;
    }
    return(0xA);
    }
    return((int) *ctxt->input->cur);
encoding_error:
    /*
     * An encoding problem may arise from a truncated input buffer
     * splitting a character in the middle. In that case do not raise
     * an error but return 0 to indicate an end of stream problem
     */
    if (ctxt->input->end - ctxt->input->cur < 4) {
    *len = 0;
    return(0);
    }

    /*
     * If we detect an UTF8 error that probably mean that the
     * input encoding didn't get properly advertised in the
     * declaration header. Report the error and switch the encoding
     * to ISO-Latin-1 (if you don't like this policy, just declare the
     * encoding !)
     */
    {
        char buffer[150];

    snprintf(&buffer[0], 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
            ctxt->input->cur[0], ctxt->input->cur[1],
            ctxt->input->cur[2], ctxt->input->cur[3]);
    __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
             "Input is not proper UTF-8, indicate encoding !\n%s",
             BAD_CAST buffer, NULL);
    }
    ctxt->charset = XML_CHAR_ENCODING_8859_1;
    *len = 1;
    return((int) *ctxt->input->cur);
}

xmlErrMemory()

void xmlErrMemory	(	xmlParserCtxtPtr	ctxt,
		const char *	extra
	)

xmlErrMemory: @ctxt: an XML parser context @extra: extra informations

Handle a redefinition of attribute error

Definition at line 113 of file parserInternals.c.

{
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
        (ctxt->instate == XML_PARSER_EOF))
    return;
    if (ctxt != NULL) {
        ctxt->errNo = XML_ERR_NO_MEMORY;
        ctxt->instate = XML_PARSER_EOF;
        ctxt->disableSAX = 1;
    }
    if (extra)
        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
                        NULL, NULL, 0, 0,
                        "Memory allocation failed : %s\n", extra);
    else
        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
                        NULL, NULL, 0, 0, "Memory allocation failed\n");
}

Referenced by inputPush(), nameNsPush(), namePush(), nodePush(), nsPush(), spacePush(), xmlAddDefAttrs(), xmlAddSpecialAttr(), xmlAttrNormalizeSpace2(), xmlCharStrndup(), xmlCreateIOParserCtxt(), xmlCreateURLParserCtxt(), xmlCtxtGrowAttrs(), xmlDetectSAX2(), xmlEscapeFormatString(), xmlInitParserCtxt(), xmlNewInputStream(), xmlNewParserCtxt(), xmlNewStringInputStream(), xmlParseAttValueComplex(), xmlParseCDSect(), xmlParseComment(), xmlParseCommentComplex(), xmlParseConditionalSections(), xmlParseElementChildrenContentDeclPriv(), xmlParseEncName(), xmlParseEntityDecl(), xmlParseEntityValue(), xmlParseExternalSubset(), xmlParseName(), xmlParseNCName(), xmlParseNmtoken(), xmlParsePI(), xmlParsePubidLiteral(), xmlParserAddNodeInfo(), xmlParseStartTag2(), xmlParseStringName(), xmlParseSystemLiteral(), xmlParseVersionNum(), xmlSAX2AttributeNs(), xmlSAX2TextNode(), xmlSplitQName(), xmlStringLenDecodeEntities(), xmlStrncat(), xmlStrncatNew(), and xmlStrndup().

xmlFreeInputStream()

void xmlFreeInputStream

(

xmlParserInputPtr

input

)

xmlFreeInputStream: @input: an xmlParserInputPtr

Free up an input stream.

Definition at line 1339 of file parserInternals.c.

                                            {
    if (input == NULL) return;

    if (input->filename != NULL) xmlFree((char *) input->filename);
    if (input->directory != NULL) xmlFree((char *) input->directory);
    if (input->encoding != NULL) xmlFree((char *) input->encoding);
    if (input->version != NULL) xmlFree((char *) input->version);
    if ((input->free != NULL) && (input->base != NULL))
        input->free((xmlChar *) input->base);
    if (input->buf != NULL)
        xmlFreeParserInputBuffer(input->buf);
    xmlFree(input);
}

Referenced by inputPush(), xmlCtxtReset(), xmlFreeParserCtxt(), xmlHaltParser(), xmlInitParserCtxt(), xmlParsePEReference(), xmlPopInput(), xmlPushInput(), and xmlSAX2ExternalSubset().

xmlFreeParserCtxt()

void xmlFreeParserCtxt

(

xmlParserCtxtPtr

ctxt

)

xmlFreeParserCtxt: @ctxt: an XML parser context

Free all the memory used by a parser context. However the parsed document in ctxt->myDoc is not freed.

Definition at line 1775 of file parserInternals.c.

{
    xmlParserInputPtr input;

    if (ctxt == NULL) return;

    while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
        xmlFreeInputStream(input);
    }
    if (ctxt->spaceTab != NULL) xmlFree(ctxt->spaceTab);
    if (ctxt->nameTab != NULL) xmlFree((xmlChar * *)ctxt->nameTab);
    if (ctxt->nodeTab != NULL) xmlFree(ctxt->nodeTab);
    if (ctxt->nodeInfoTab != NULL) xmlFree(ctxt->nodeInfoTab);
    if (ctxt->inputTab != NULL) xmlFree(ctxt->inputTab);
    if (ctxt->version != NULL) xmlFree((char *) ctxt->version);
    if (ctxt->encoding != NULL) xmlFree((char *) ctxt->encoding);
    if (ctxt->extSubURI != NULL) xmlFree((char *) ctxt->extSubURI);
    if (ctxt->extSubSystem != NULL) xmlFree((char *) ctxt->extSubSystem);
#ifdef LIBXML_SAX1_ENABLED
    if ((ctxt->sax != NULL) &&
        (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler))
#else
    if (ctxt->sax != NULL)
#endif /* LIBXML_SAX1_ENABLED */
        xmlFree(ctxt->sax);
    if (ctxt->directory != NULL) xmlFree((char *) ctxt->directory);
    if (ctxt->vctxt.nodeTab != NULL) xmlFree(ctxt->vctxt.nodeTab);
    if (ctxt->atts != NULL) xmlFree((xmlChar * *)ctxt->atts);
    if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
    if (ctxt->nsTab != NULL) xmlFree((char *) ctxt->nsTab);
    if (ctxt->pushTab != NULL) xmlFree(ctxt->pushTab);
    if (ctxt->attallocs != NULL) xmlFree(ctxt->attallocs);
    if (ctxt->attsDefault != NULL)
        xmlHashFree(ctxt->attsDefault, xmlHashDefaultDeallocator);
    if (ctxt->attsSpecial != NULL)
        xmlHashFree(ctxt->attsSpecial, NULL);
    if (ctxt->freeElems != NULL) {
        xmlNodePtr cur, next;

    cur = ctxt->freeElems;
    while (cur != NULL) {
        next = cur->next;
        xmlFree(cur);
        cur = next;
    }
    }
    if (ctxt->freeAttrs != NULL) {
        xmlAttrPtr cur, next;

    cur = ctxt->freeAttrs;
    while (cur != NULL) {
        next = cur->next;
        xmlFree(cur);
        cur = next;
    }
    }
    /*
     * cleanup the error strings
     */
    if (ctxt->lastError.message != NULL)
        xmlFree(ctxt->lastError.message);
    if (ctxt->lastError.file != NULL)
        xmlFree(ctxt->lastError.file);
    if (ctxt->lastError.str1 != NULL)
        xmlFree(ctxt->lastError.str1);
    if (ctxt->lastError.str2 != NULL)
        xmlFree(ctxt->lastError.str2);
    if (ctxt->lastError.str3 != NULL)
        xmlFree(ctxt->lastError.str3);

#ifdef LIBXML_CATALOG_ENABLED
    if (ctxt->catalogs != NULL)
    xmlCatalogFreeLocal(ctxt->catalogs);
#endif
    xmlFree(ctxt);
}

Referenced by main(), parseAndPrintFile(), testSAX(), xmlCreateEntityParserCtxtInternal(), xmlCreateIOParserCtxt(), xmlCreateMemoryParserCtxt(), xmlCreateURLParserCtxt(), xmlDoRead(), xmlNewParserCtxt(), xmlParseBalancedChunkMemoryInternal(), xmlParseCtxtExternalEntity(), xmlParseExternalEntityPrivate(), xmlParseInNodeContext(), xmlReadFd(), xmlReadIO(), and xsltDocDefaultLoaderFunc().

xmlInitNodeInfoSeq()

void xmlInitNodeInfoSeq

(

xmlParserNodeInfoSeqPtr

seq

)

xmlInitNodeInfoSeq: @seq: a node info sequence pointer

– Initialize (set to initial state) node info sequence

Definition at line 1934 of file parserInternals.c.

{
    if (seq == NULL)
        return;
    seq->length = 0;
    seq->maximum = 0;
    seq->buffer = NULL;
}

Referenced by xmlClearNodeInfoSeq(), xmlCtxtReset(), and xmlInitParserCtxt().

xmlInitParserCtxt()

int xmlInitParserCtxt

(

xmlParserCtxtPtr

ctxt

)

xmlInitParserCtxt: @ctxt: an XML parser context

Initialize a parser context

Returns 0 in case of success and -1 in case of error

Definition at line 1589 of file parserInternals.c.

{
    xmlParserInputPtr input;

    if(ctxt==NULL) {
        xmlErrInternal(NULL, "Got NULL parser context\n", NULL);
        return(-1);
    }

    xmlDefaultSAXHandlerInit();

    if (ctxt->dict == NULL)
    ctxt->dict = xmlDictCreate();
    if (ctxt->dict == NULL) {
        xmlErrMemory(NULL, "cannot initialize parser context\n");
    return(-1);
    }
    xmlDictSetLimit(ctxt->dict, XML_MAX_DICTIONARY_LIMIT);

    if (ctxt->sax == NULL)
    ctxt->sax = (xmlSAXHandler *) xmlMalloc(sizeof(xmlSAXHandler));
    if (ctxt->sax == NULL) {
        xmlErrMemory(NULL, "cannot initialize parser context\n");
    return(-1);
    }
    else
        xmlSAXVersion(ctxt->sax, 2);

    ctxt->maxatts = 0;
    ctxt->atts = NULL;
    /* Allocate the Input stack */
    if (ctxt->inputTab == NULL) {
    ctxt->inputTab = (xmlParserInputPtr *)
            xmlMalloc(5 * sizeof(xmlParserInputPtr));
    ctxt->inputMax = 5;
    }
    if (ctxt->inputTab == NULL) {
        xmlErrMemory(NULL, "cannot initialize parser context\n");
    ctxt->inputNr = 0;
    ctxt->inputMax = 0;
    ctxt->input = NULL;
    return(-1);
    }
    while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
        xmlFreeInputStream(input);
    }
    ctxt->inputNr = 0;
    ctxt->input = NULL;

    ctxt->version = NULL;
    ctxt->encoding = NULL;
    ctxt->standalone = -1;
    ctxt->hasExternalSubset = 0;
    ctxt->hasPErefs = 0;
    ctxt->html = 0;
    ctxt->external = 0;
    ctxt->instate = XML_PARSER_START;
    ctxt->token = 0;
    ctxt->directory = NULL;

    /* Allocate the Node stack */
    if (ctxt->nodeTab == NULL) {
    ctxt->nodeTab = (xmlNodePtr *) xmlMalloc(10 * sizeof(xmlNodePtr));
    ctxt->nodeMax = 10;
    }
    if (ctxt->nodeTab == NULL) {
        xmlErrMemory(NULL, "cannot initialize parser context\n");
    ctxt->nodeNr = 0;
    ctxt->nodeMax = 0;
    ctxt->node = NULL;
    ctxt->inputNr = 0;
    ctxt->inputMax = 0;
    ctxt->input = NULL;
    return(-1);
    }
    ctxt->nodeNr = 0;
    ctxt->node = NULL;

    /* Allocate the Name stack */
    if (ctxt->nameTab == NULL) {
    ctxt->nameTab = (const xmlChar **) xmlMalloc(10 * sizeof(xmlChar *));
    ctxt->nameMax = 10;
    }
    if (ctxt->nameTab == NULL) {
        xmlErrMemory(NULL, "cannot initialize parser context\n");
    ctxt->nodeNr = 0;
    ctxt->nodeMax = 0;
    ctxt->node = NULL;
    ctxt->inputNr = 0;
    ctxt->inputMax = 0;
    ctxt->input = NULL;
    ctxt->nameNr = 0;
    ctxt->nameMax = 0;
    ctxt->name = NULL;
    return(-1);
    }
    ctxt->nameNr = 0;
    ctxt->name = NULL;

    /* Allocate the space stack */
    if (ctxt->spaceTab == NULL) {
    ctxt->spaceTab = (int *) xmlMalloc(10 * sizeof(int));
    ctxt->spaceMax = 10;
    }
    if (ctxt->spaceTab == NULL) {
        xmlErrMemory(NULL, "cannot initialize parser context\n");
    ctxt->nodeNr = 0;
    ctxt->nodeMax = 0;
    ctxt->node = NULL;
    ctxt->inputNr = 0;
    ctxt->inputMax = 0;
    ctxt->input = NULL;
    ctxt->nameNr = 0;
    ctxt->nameMax = 0;
    ctxt->name = NULL;
    ctxt->spaceNr = 0;
    ctxt->spaceMax = 0;
    ctxt->space = NULL;
    return(-1);
    }
    ctxt->spaceNr = 1;
    ctxt->spaceMax = 10;
    ctxt->spaceTab[0] = -1;
    ctxt->space = &ctxt->spaceTab[0];
    ctxt->userData = ctxt;
    ctxt->myDoc = NULL;
    ctxt->wellFormed = 1;
    ctxt->nsWellFormed = 1;
    ctxt->valid = 1;
    ctxt->loadsubset = xmlLoadExtDtdDefaultValue;
    if (ctxt->loadsubset) {
        ctxt->options |= XML_PARSE_DTDLOAD;
    }
    ctxt->validate = xmlDoValidityCheckingDefaultValue;
    ctxt->pedantic = xmlPedanticParserDefaultValue;
    if (ctxt->pedantic) {
        ctxt->options |= XML_PARSE_PEDANTIC;
    }
    ctxt->linenumbers = xmlLineNumbersDefaultValue;
    ctxt->keepBlanks = xmlKeepBlanksDefaultValue;
    if (ctxt->keepBlanks == 0) {
    ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
    ctxt->options |= XML_PARSE_NOBLANKS;
    }

    ctxt->vctxt.finishDtd = XML_CTXT_FINISH_DTD_0;
    ctxt->vctxt.userData = ctxt;
    ctxt->vctxt.error = xmlParserValidityError;
    ctxt->vctxt.warning = xmlParserValidityWarning;
    if (ctxt->validate) {
    if (xmlGetWarningsDefaultValue == 0)
        ctxt->vctxt.warning = NULL;
    else
        ctxt->vctxt.warning = xmlParserValidityWarning;
    ctxt->vctxt.nodeMax = 0;
        ctxt->options |= XML_PARSE_DTDVALID;
    }
    ctxt->replaceEntities = xmlSubstituteEntitiesDefaultValue;
    if (ctxt->replaceEntities) {
        ctxt->options |= XML_PARSE_NOENT;
    }
    ctxt->record_info = 0;
    ctxt->nbChars = 0;
    ctxt->checkIndex = 0;
    ctxt->inSubset = 0;
    ctxt->errNo = XML_ERR_OK;
    ctxt->depth = 0;
    ctxt->charset = XML_CHAR_ENCODING_UTF8;
    ctxt->catalogs = NULL;
    ctxt->nbentities = 0;
    ctxt->sizeentities = 0;
    ctxt->sizeentcopy = 0;
    ctxt->input_id = 1;
    xmlInitNodeInfoSeq(&ctxt->node_seq);
    return(0);
}

Referenced by xmlNewParserCtxt().

xmlIsLetter()

int xmlIsLetter

(

int

c

)

xmlIsLetter: : an unicode character (int)

Check whether the character is allowed by the production [84] Letter ::= BaseChar | Ideographic

Returns 0 if not, non-zero otherwise

Definition at line 229 of file parserInternals.c.

                   {
    return(IS_BASECHAR(c) || IS_IDEOGRAPHIC(c));
}

xmlKeepBlanksDefault()

int xmlKeepBlanksDefault

(

int

val

)

xmlKeepBlanksDefault: @val: int 0 or 1

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 ignorable white spaces. As a result the SAX callback was generating xmlSAX2IgnorableWhitespace() callbacks instead of characters() one, and when using the DOM output text nodes containing those blanks were not generated. The 2.x and later version will switch to the XML standard way and ignorableWhitespace() are only generated when running the parser in validating mode and when the current element doesn't allow CDATA or mixed content. 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 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" nodes generated. This value also affect autogeneration of indentation when saving code if blanks sections are kept, indentation is not generated.

Returns the last value for 0 for no substitution, 1 for substitution.

Definition at line 2156 of file parserInternals.c.

                              {
    int old = xmlKeepBlanksDefaultValue;

    xmlKeepBlanksDefaultValue = val;
    if (!val) xmlIndentTreeOutput = 1;
    return(old);
}

Referenced by main().

xmlLineNumbersDefault()

int xmlLineNumbersDefault

(

int

val

)

xmlLineNumbersDefault: @val: int 0 or 1

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.

Returns the last value for 0 for no substitution, 1 for substitution.

Definition at line 2102 of file parserInternals.c.

                               {
    int old = xmlLineNumbersDefaultValue;

    xmlLineNumbersDefaultValue = val;
    return(old);
}

Referenced by main().

xmlNewEntityInputStream()

xmlParserInputPtr xmlNewEntityInputStream	(	xmlParserCtxtPtr	ctxt,
		xmlEntityPtr	entity
	)

xmlNewEntityInputStream: @ctxt: an XML parser context @entity: an Entity pointer

Create a new input stream based on an xmlEntityPtr

Returns the new input stream or NULL

Definition at line 1430 of file parserInternals.c.

                                                                    {
    xmlParserInputPtr input;

    if (entity == NULL) {
        xmlErrInternal(ctxt, "xmlNewEntityInputStream entity = NULL\n",
                   NULL);
    return(NULL);
    }
    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext,
        "new input from entity: %s\n", entity->name);
    if (entity->content == NULL) {
    switch (entity->etype) {
            case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
            xmlErrInternal(ctxt, "Cannot parse entity %s\n",
                       entity->name);
                break;
            case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
            case XML_EXTERNAL_PARAMETER_ENTITY:
        return(xmlLoadExternalEntity((char *) entity->URI,
               (char *) entity->ExternalID, ctxt));
            case XML_INTERNAL_GENERAL_ENTITY:
            xmlErrInternal(ctxt,
              "Internal entity %s without content !\n",
                       entity->name);
                break;
            case XML_INTERNAL_PARAMETER_ENTITY:
            xmlErrInternal(ctxt,
              "Internal parameter entity %s without content !\n",
                       entity->name);
                break;
            case XML_INTERNAL_PREDEFINED_ENTITY:
            xmlErrInternal(ctxt,
              "Predefined entity %s without content !\n",
                       entity->name);
                break;
    }
    return(NULL);
    }
    input = xmlNewInputStream(ctxt);
    if (input == NULL) {
    return(NULL);
    }
    if (entity->URI != NULL)
    input->filename = (char *) xmlStrdup((xmlChar *) entity->URI);
    input->base = entity->content;
    if (entity->length == 0)
        entity->length = xmlStrlen(entity->content);
    input->cur = entity->content;
    input->length = entity->length;
    input->end = &entity->content[input->length];
    return(input);
}

Referenced by xmlLoadEntityContent(), and xmlParsePEReference().

xmlNewInputFromFile()

xmlParserInputPtr xmlNewInputFromFile	(	xmlParserCtxtPtr	ctxt,
		const char *	filename
	)

xmlNewInputFromFile: @ctxt: an XML parser context @filename: the filename to use as entity

Create a new input stream based on a file or an URL.

Returns the new input stream or NULL in case of error

Definition at line 1526 of file parserInternals.c.

                                                                 {
    xmlParserInputBufferPtr buf;
    xmlParserInputPtr inputStream;
    char *directory = NULL;
    xmlChar *URI = NULL;

    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext,
        "new input from file: %s\n", filename);
    if (ctxt == NULL) return(NULL);
    buf = xmlParserInputBufferCreateFilename(filename, XML_CHAR_ENCODING_NONE);
    if (buf == NULL) {
    if (filename == NULL)
        __xmlLoaderErr(ctxt,
                       "failed to load external entity: NULL filename \n",
               NULL);
    else
        __xmlLoaderErr(ctxt, "failed to load external entity \"%s\"\n",
               (const char *) filename);
    return(NULL);
    }

    inputStream = xmlNewInputStream(ctxt);
    if (inputStream == NULL)
    return(NULL);

    inputStream->buf = buf;
    inputStream = xmlCheckHTTPInput(ctxt, inputStream);
    if (inputStream == NULL)
        return(NULL);

    if (inputStream->filename == NULL)
    URI = xmlStrdup((xmlChar *) filename);
    else
    URI = xmlStrdup((xmlChar *) inputStream->filename);
    directory = xmlParserGetDirectory((const char *) URI);
    if (inputStream->filename != NULL) xmlFree((char *)inputStream->filename);
    inputStream->filename = (char *) xmlCanonicPath((const xmlChar *) URI);
    if (URI != NULL) xmlFree((char *) URI);
    inputStream->directory = directory;

    xmlBufResetInput(inputStream->buf->buffer, inputStream);
    if ((ctxt->directory == NULL) && (directory != NULL))
        ctxt->directory = (char *) xmlStrdup((const xmlChar *) directory);
    return(inputStream);
}

xmlNewInputStream()

xmlParserInputPtr xmlNewInputStream

(

xmlParserCtxtPtr

ctxt

)

xmlNewInputStream: @ctxt: an XML parser context

Create a new input stream structure.

Returns the new input stream or NULL

Definition at line 1362 of file parserInternals.c.

                                         {
    xmlParserInputPtr input;

    input = (xmlParserInputPtr) xmlMalloc(sizeof(xmlParserInput));
    if (input == NULL) {
        xmlErrMemory(ctxt,  "couldn't allocate a new input stream\n");
    return(NULL);
    }
    memset(input, 0, sizeof(xmlParserInput));
    input->line = 1;
    input->col = 1;
    input->standalone = -1;

    /*
     * If the context is NULL the id cannot be initialized, but that
     * should not happen while parsing which is the situation where
     * the id is actually needed.
     */
    if (ctxt != NULL)
        input->id = ctxt->input_id++;

    return(input);
}

Referenced by xmlCreateMemoryParserCtxt(), xmlCtxtResetPush(), xmlNewEntityInputStream(), xmlNewInputFromFile(), xmlNewIOInputStream(), and xmlNewStringInputStream().

xmlNewIOInputStream()

xmlParserInputPtr xmlNewIOInputStream	(	xmlParserCtxtPtr	ctxt,
		xmlParserInputBufferPtr	input,
		xmlCharEncoding	enc
	)

xmlNewIOInputStream: @ctxt: an XML parser context @input: an I/O Input @enc: the charset encoding if known

Create a new input stream structure encapsulating the @input into a stream suitable for the parser.

Returns the new input stream or NULL

Definition at line 1398 of file parserInternals.c.

                                     {
    xmlParserInputPtr inputStream;

    if (input == NULL) return(NULL);
    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext, "new input from I/O\n");
    inputStream = xmlNewInputStream(ctxt);
    if (inputStream == NULL) {
    return(NULL);
    }
    inputStream->filename = NULL;
    inputStream->buf = input;
    xmlBufResetInput(inputStream->buf->buffer, inputStream);

    if (enc != XML_CHAR_ENCODING_NONE) {
        xmlSwitchEncoding(ctxt, enc);
    }

    return(inputStream);
}

Referenced by testSAX(), xmlCreateIOParserCtxt(), xmlCtxtReadFd(), xmlCtxtReadIO(), xmlCtxtReadMemory(), xmlReadFd(), and xmlReadIO().

xmlNewParserCtxt()

xmlParserCtxtPtr xmlNewParserCtxt

(

void

)

xmlNewParserCtxt:

Allocate and initialize a new parser context.

Returns the xmlParserCtxtPtr or NULL

Definition at line 1861 of file parserInternals.c.

{
    xmlParserCtxtPtr ctxt;

    ctxt = (xmlParserCtxtPtr) xmlMalloc(sizeof(xmlParserCtxt));
    if (ctxt == NULL) {
    xmlErrMemory(NULL, "cannot allocate parser context\n");
    return(NULL);
    }
    memset(ctxt, 0, sizeof(xmlParserCtxt));
    if (xmlInitParserCtxt(ctxt) < 0) {
        xmlFreeParserCtxt(ctxt);
    return(NULL);
    }
    return(ctxt);
}

Referenced by main(), parseAndPrintFile(), testSAX(), xmlCreateEntityParserCtxtInternal(), xmlCreateIOParserCtxt(), xmlCreateMemoryParserCtxt(), xmlCreateURLParserCtxt(), xmlReadFd(), xmlReadIO(), and xsltDocDefaultLoaderFunc().

xmlNewStringInputStream()

xmlParserInputPtr xmlNewStringInputStream	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	buffer
	)

xmlNewStringInputStream: @ctxt: an XML parser context @buffer: an memory buffer

Create a new input stream based on a memory buffer. Returns the new input stream

Definition at line 1493 of file parserInternals.c.

                                                                      {
    xmlParserInputPtr input;

    if (buffer == NULL) {
        xmlErrInternal(ctxt, "xmlNewStringInputStream string = NULL\n",
                   NULL);
    return(NULL);
    }
    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext,
        "new fixed input: %.30s\n", buffer);
    input = xmlNewInputStream(ctxt);
    if (input == NULL) {
        xmlErrMemory(ctxt,  "couldn't allocate a new input stream\n");
    return(NULL);
    }
    input->base = buffer;
    input->cur = buffer;
    input->length = xmlStrlen(buffer);
    input->end = &buffer[input->length];
    return(input);
}

Referenced by xmlCtxtReadDoc().

xmlNextChar()

void xmlNextChar

(

xmlParserCtxtPtr

ctxt

)

xmlNextChar: @ctxt: the XML parser context

Skip to the next char input char.

Definition at line 423 of file parserInternals.c.

{
    if ((ctxt == NULL) || (ctxt->instate == XML_PARSER_EOF) ||
        (ctxt->input == NULL))
        return;

    if (!(VALID_CTXT(ctxt))) {
        xmlErrInternal(ctxt, "Parser input data memory error\n", NULL);
    ctxt->errNo = XML_ERR_INTERNAL_ERROR;
        xmlStopParser(ctxt);
    return;
    }

    if ((*ctxt->input->cur == 0) &&
        (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) {
        return;
    }

    if (ctxt->charset == XML_CHAR_ENCODING_UTF8) {
        const unsigned char *cur;
        unsigned char c;

        /*
         *   2.11 End-of-Line Handling
         *   the literal two-character sequence "#xD#xA" or a standalone
         *   literal #xD, an XML processor must pass to the application
         *   the single character #xA.
         */
        if (*(ctxt->input->cur) == '\n') {
            ctxt->input->line++; ctxt->input->col = 1;
        } else
            ctxt->input->col++;

        /*
         * We are supposed to handle UTF8, check it's valid
         * From rfc2044: encoding of the Unicode values on UTF-8:
         *
         * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
         * 0000 0000-0000 007F   0xxxxxxx
         * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
         * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
         *
         * Check for the 0x110000 limit too
         */
        cur = ctxt->input->cur;

        c = *cur;
        if (c & 0x80) {
            if (c == 0xC0)
            goto encoding_error;
            if (cur[1] == 0) {
                xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
                cur = ctxt->input->cur;
            }
            if ((cur[1] & 0xc0) != 0x80)
                goto encoding_error;
            if ((c & 0xe0) == 0xe0) {
                unsigned int val;

                if (cur[2] == 0) {
                    xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
                    cur = ctxt->input->cur;
                }
                if ((cur[2] & 0xc0) != 0x80)
                    goto encoding_error;
                if ((c & 0xf0) == 0xf0) {
                    if (cur[3] == 0) {
                        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
                        cur = ctxt->input->cur;
                    }
                    if (((c & 0xf8) != 0xf0) ||
                        ((cur[3] & 0xc0) != 0x80))
                        goto encoding_error;
                    /* 4-byte code */
                    ctxt->input->cur += 4;
                    val = (cur[0] & 0x7) << 18;
                    val |= (cur[1] & 0x3f) << 12;
                    val |= (cur[2] & 0x3f) << 6;
                    val |= cur[3] & 0x3f;
                } else {
                    /* 3-byte code */
                    ctxt->input->cur += 3;
                    val = (cur[0] & 0xf) << 12;
                    val |= (cur[1] & 0x3f) << 6;
                    val |= cur[2] & 0x3f;
                }
                if (((val > 0xd7ff) && (val < 0xe000)) ||
                    ((val > 0xfffd) && (val < 0x10000)) ||
                    (val >= 0x110000)) {
        xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
                  "Char 0x%X out of allowed range\n",
                  val);
                }
            } else
                /* 2-byte code */
                ctxt->input->cur += 2;
        } else
            /* 1-byte code */
            ctxt->input->cur++;

        ctxt->nbChars++;
    } else {
        /*
         * Assume it's a fixed length encoding (1) with
         * a compatible encoding for the ASCII set, since
         * XML constructs only use < 128 chars
         */

        if (*(ctxt->input->cur) == '\n') {
            ctxt->input->line++; ctxt->input->col = 1;
        } else
            ctxt->input->col++;
        ctxt->input->cur++;
        ctxt->nbChars++;
    }
    if (*ctxt->input->cur == 0)
        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
    return;
encoding_error:
    /*
     * If we detect an UTF8 error that probably mean that the
     * input encoding didn't get properly advertised in the
     * declaration header. Report the error and switch the encoding
     * to ISO-Latin-1 (if you don't like this policy, just declare the
     * encoding !)
     */
    if ((ctxt == NULL) || (ctxt->input == NULL) ||
        (ctxt->input->end - ctxt->input->cur < 4)) {
    __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
             "Input is not proper UTF-8, indicate encoding !\n",
             NULL, NULL);
    } else {
        char buffer[150];

    snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
            ctxt->input->cur[0], ctxt->input->cur[1],
            ctxt->input->cur[2], ctxt->input->cur[3]);
    __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
             "Input is not proper UTF-8, indicate encoding !\n%s",
             BAD_CAST buffer, NULL);
    }
    ctxt->charset = XML_CHAR_ENCODING_8859_1;
    ctxt->input->cur++;
    return;
}

xmlParserAddNodeInfo()

void xmlParserAddNodeInfo	(	xmlParserCtxtPtr	ctxt,
		const xmlParserNodeInfoPtr	info
	)

xmlParserAddNodeInfo: @ctxt: an XML parser context @info: a node info sequence pointer

Insert node info record into the sorted sequence

Definition at line 2011 of file parserInternals.c.

{
    unsigned long pos;

    if ((ctxt == NULL) || (info == NULL)) return;

    /* Find pos and check to see if node is already in the sequence */
    pos = xmlParserFindNodeInfoIndex(&ctxt->node_seq, (xmlNodePtr)
                                     info->node);

    if ((pos < ctxt->node_seq.length) &&
        (ctxt->node_seq.buffer != NULL) &&
        (ctxt->node_seq.buffer[pos].node == info->node)) {
        ctxt->node_seq.buffer[pos] = *info;
    }

    /* Otherwise, we need to add new node to buffer */
    else {
        if ((ctxt->node_seq.length + 1 > ctxt->node_seq.maximum) ||
        (ctxt->node_seq.buffer == NULL)) {
            xmlParserNodeInfo *tmp_buffer;
            unsigned int byte_size;

            if (ctxt->node_seq.maximum == 0)
                ctxt->node_seq.maximum = 2;
            byte_size = (sizeof(*ctxt->node_seq.buffer) *
            (2 * ctxt->node_seq.maximum));

            if (ctxt->node_seq.buffer == NULL)
                tmp_buffer = (xmlParserNodeInfo *) xmlMalloc(byte_size);
            else
                tmp_buffer =
                    (xmlParserNodeInfo *) xmlRealloc(ctxt->node_seq.buffer,
                                                     byte_size);

            if (tmp_buffer == NULL) {
        xmlErrMemory(ctxt, "failed to allocate buffer\n");
                return;
            }
            ctxt->node_seq.buffer = tmp_buffer;
            ctxt->node_seq.maximum *= 2;
        }

        /* If position is not at end, move elements out of the way */
        if (pos != ctxt->node_seq.length) {
            unsigned long i;

            for (i = ctxt->node_seq.length; i > pos; i--)
                ctxt->node_seq.buffer[i] = ctxt->node_seq.buffer[i - 1];
        }

        /* Copy element and increase length */
        ctxt->node_seq.buffer[pos] = *info;
        ctxt->node_seq.length++;
    }
}

Referenced by xmlParseElementEnd(), xmlParseElementStart(), and xmlSAX2EndElementNs().

xmlParserFindNodeInfo()

const xmlParserNodeInfo* xmlParserFindNodeInfo	(	const xmlParserCtxtPtr	ctx,
		const xmlNodePtr	node
	)

xmlParserFindNodeInfo: @ctx: an XML parser context @node: an XML node within the tree

Find the parser node info struct for a given node

Returns an xmlParserNodeInfo block pointer or NULL

Definition at line 1911 of file parserInternals.c.

{
    unsigned long pos;

    if ((ctx == NULL) || (node == NULL))
        return (NULL);
    /* Find position where node should be at */
    pos = xmlParserFindNodeInfoIndex(&ctx->node_seq, node);
    if (pos < ctx->node_seq.length
        && ctx->node_seq.buffer[pos].node == node)
        return &ctx->node_seq.buffer[pos];
    else
        return NULL;
}

xmlParserFindNodeInfoIndex()

unsigned long xmlParserFindNodeInfoIndex	(	const xmlParserNodeInfoSeqPtr	seq,
		const xmlNodePtr	node
	)

xmlParserFindNodeInfoIndex: @seq: a node info sequence pointer @node: an XML node pointer

xmlParserFindNodeInfoIndex : Find the index that the info record for the given node is or should be at in a sorted sequence

Returns a long indicating the position of the record

Definition at line 1972 of file parserInternals.c.

{
    unsigned long upper, lower, middle;
    int found = 0;

    if ((seq == NULL) || (node == NULL))
        return ((unsigned long) -1);

    /* Do a binary search for the key */
    lower = 1;
    upper = seq->length;
    middle = 0;
    while (lower <= upper && !found) {
        middle = lower + (upper - lower) / 2;
        if (node == seq->buffer[middle - 1].node)
            found = 1;
        else if (node < seq->buffer[middle - 1].node)
            upper = middle - 1;
        else
            lower = middle + 1;
    }

    /* Return position */
    if (middle == 0 || seq->buffer[middle - 1].node < node)
        return middle;
    else
        return middle - 1;
}

Referenced by xmlParserAddNodeInfo(), and xmlParserFindNodeInfo().

xmlParserInputGrow()

int xmlParserInputGrow	(	xmlParserInputPtr	in,
		int	len
	)

xmlParserInputGrow: @in: an XML parser input @len: an indicative size for the lookahead

This function increase the input for the parser. It tries to preserve pointers to the input buffer, and keep already read data

Returns the amount of char read, or -1 in case of error, 0 indicate the end of this entity

Definition at line 300 of file parserInternals.c.

                                                  {
    int ret;
    size_t indx;
    const xmlChar *content;

    if ((in == NULL) || (len < 0)) return(-1);
#ifdef DEBUG_INPUT
    xmlGenericError(xmlGenericErrorContext, "Grow\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);

    CHECK_BUFFER(in);

    indx = in->cur - in->base;
    if (xmlBufUse(in->buf->buffer) > (unsigned int) indx + INPUT_CHUNK) {

    CHECK_BUFFER(in);

        return(0);
    }
    if (in->buf->readcallback != NULL) {
    ret = xmlParserInputBufferGrow(in->buf, len);
    } else
        return(0);

    /*
     * NOTE : in->base may be a "dangling" i.e. freed pointer in this
     *        block, but we use it really as an integer to do some
     *        pointer arithmetic. Insure will raise it as a bug but in
     *        that specific case, that's not !
     */

    content = xmlBufContent(in->buf->buffer);
    if (in->base != content) {
        /*
     * the buffer has been reallocated
     */
    indx = in->cur - in->base;
    in->base = content;
    in->cur = &content[indx];
    }
    in->end = xmlBufEnd(in->buf->buffer);

    CHECK_BUFFER(in);

    return(ret);
}

Referenced by xmlCurrentChar(), xmlGROW(), xmlNextChar(), xmlPopInput(), xmlSHRINK(), and xmlSkipBlankChars().

xmlParserInputRead()

int xmlParserInputRead	(	xmlParserInputPtr in	ATTRIBUTE_UNUSED,
		int len	ATTRIBUTE_UNUSED
	)

xmlParserInputRead: @in: an XML parser input @len: an indicative size for the lookahead

This function was internal and is deprecated.

Returns -1 as this is an error to use it.

Definition at line 284 of file parserInternals.c.

                                                                                    {
    return(-1);
}

xmlParserInputShrink()

void xmlParserInputShrink

(

xmlParserInputPtr

in

)

xmlParserInputShrink: @in: an XML parser input

This function removes used input for the parser.

Definition at line 358 of file parserInternals.c.

                                           {
    size_t used;
    size_t ret;
    size_t indx;
    const xmlChar *content;

#ifdef DEBUG_INPUT
    xmlGenericError(xmlGenericErrorContext, "Shrink\n");
#endif
    if (in == NULL) return;
    if (in->buf == NULL) return;
    if (in->base == NULL) return;
    if (in->cur == NULL) return;
    if (in->buf->buffer == NULL) return;

    CHECK_BUFFER(in);

    used = in->cur - xmlBufContent(in->buf->buffer);
    /*
     * Do not shrink on large buffers whose only a tiny fraction
     * was consumed
     */
    if (used > INPUT_CHUNK) {
    ret = xmlBufShrink(in->buf->buffer, used - LINE_LEN);
    if (ret > 0) {
        in->cur -= ret;
        in->consumed += ret;
    }
    in->end = xmlBufEnd(in->buf->buffer);
    }

    CHECK_BUFFER(in);

    if (xmlBufUse(in->buf->buffer) > INPUT_CHUNK) {
        return;
    }
    xmlParserInputBufferRead(in->buf, 2 * INPUT_CHUNK);
    content = xmlBufContent(in->buf->buffer);
    if (in->base != content) {
        /*
     * the buffer has been reallocated
     */
    indx = in->cur - in->base;
    in->base = content;
    in->cur = &content[indx];
    }
    in->end = xmlBufEnd(in->buf->buffer);

    CHECK_BUFFER(in);
}

Referenced by xmlSHRINK().

xmlPedanticParserDefault()

int xmlPedanticParserDefault

(

int

val

)

xmlPedanticParserDefault: @val: int 0 or 1

Set and return the previous value for enabling pedantic warnings.

Returns the last value for 0 for no substitution, 1 for substitution.

Definition at line 2084 of file parserInternals.c.

                                  {
    int old = xmlPedanticParserDefaultValue;

    xmlPedanticParserDefaultValue = val;
    return(old);
}

Referenced by main().

xmlStringCurrentChar()

int xmlStringCurrentChar	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	cur,
		int *	len
	)

xmlStringCurrentChar: @ctxt: the XML parser context @cur: pointer to the beginning of the char @len: pointer to the length of the char read

The current char value, if using UTF-8 this may actually span multiple bytes in the input buffer.

Returns the current char value and its length

Definition at line 748 of file parserInternals.c.

{
    if ((len == NULL) || (cur == NULL)) return(0);
    if ((ctxt == NULL) || (ctxt->charset == XML_CHAR_ENCODING_UTF8)) {
        /*
         * We are supposed to handle UTF8, check it's valid
         * From rfc2044: encoding of the Unicode values on UTF-8:
         *
         * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
         * 0000 0000-0000 007F   0xxxxxxx
         * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
         * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
         *
         * Check for the 0x110000 limit too
         */
        unsigned char c;
        unsigned int val;

        c = *cur;
        if (c & 0x80) {
            if ((cur[1] & 0xc0) != 0x80)
                goto encoding_error;
            if ((c & 0xe0) == 0xe0) {

                if ((cur[2] & 0xc0) != 0x80)
                    goto encoding_error;
                if ((c & 0xf0) == 0xf0) {
                    if (((c & 0xf8) != 0xf0) || ((cur[3] & 0xc0) != 0x80))
                        goto encoding_error;
                    /* 4-byte code */
                    *len = 4;
                    val = (cur[0] & 0x7) << 18;
                    val |= (cur[1] & 0x3f) << 12;
                    val |= (cur[2] & 0x3f) << 6;
                    val |= cur[3] & 0x3f;
                } else {
                    /* 3-byte code */
                    *len = 3;
                    val = (cur[0] & 0xf) << 12;
                    val |= (cur[1] & 0x3f) << 6;
                    val |= cur[2] & 0x3f;
                }
            } else {
                /* 2-byte code */
                *len = 2;
                val = (cur[0] & 0x1f) << 6;
                val |= cur[1] & 0x3f;
            }
            if (!IS_CHAR(val)) {
            xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
                  "Char 0x%X out of allowed range\n", val);
            }
            return (val);
        } else {
            /* 1-byte code */
            *len = 1;
            return ((int) *cur);
        }
    }
    /*
     * Assume it's a fixed length encoding (1) with
     * a compatible encoding for the ASCII set, since
     * XML constructs only use < 128 chars
     */
    *len = 1;
    return ((int) *cur);
encoding_error:

    /*
     * An encoding problem may arise from a truncated input buffer
     * splitting a character in the middle. In that case do not raise
     * an error but return 0 to indicate an end of stream problem
     */
    if ((ctxt == NULL) || (ctxt->input == NULL) ||
        (ctxt->input->end - ctxt->input->cur < 4)) {
    *len = 0;
    return(0);
    }
    /*
     * If we detect an UTF8 error that probably mean that the
     * input encoding didn't get properly advertised in the
     * declaration header. Report the error and switch the encoding
     * to ISO-Latin-1 (if you don't like this policy, just declare the
     * encoding !)
     */
    {
        char buffer[150];

    snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
            ctxt->input->cur[0], ctxt->input->cur[1],
            ctxt->input->cur[2], ctxt->input->cur[3]);
    __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
             "Input is not proper UTF-8, indicate encoding !\n%s",
             BAD_CAST buffer, NULL);
    }
    *len = 1;
    return ((int) *cur);
}

Referenced by xsltNumberFormatTokenize(), xsltScanLiteral(), and xsltScanNCName().

xmlSubstituteEntitiesDefault()

int xmlSubstituteEntitiesDefault

(

int

val

)

xmlSubstituteEntitiesDefault: @val: int 0 or 1

Set and return the previous value for default entity support. Initially the parser always keep entity references instead of substituting entity values in the output. This function has to be used to change the default parser behavior SAX::substituteEntities() has to be used for changing that on a file by file basis.

Returns the last value for 0 for no substitution, 1 for substitution.

Definition at line 2124 of file parserInternals.c.

                                      {
    int old = xmlSubstituteEntitiesDefaultValue;

    xmlSubstituteEntitiesDefaultValue = val;
    return(old);
}

Referenced by main().

xmlSwitchEncoding()

int xmlSwitchEncoding	(	xmlParserCtxtPtr	ctxt,
		xmlCharEncoding	enc
	)

xmlSwitchEncoding: @ctxt: the parser context @enc: the encoding value (number)

change the input functions when discovering the character encoding of a given entity.

Returns 0 in case of success, -1 otherwise

Definition at line 933 of file parserInternals.c.

{
    xmlCharEncodingHandlerPtr handler;
    int len = -1;
    int ret;

    if (ctxt == NULL) return(-1);
    switch (enc) {
    case XML_CHAR_ENCODING_ERROR:
        __xmlErrEncoding(ctxt, XML_ERR_UNKNOWN_ENCODING,
                       "encoding unknown\n", NULL, NULL);
        return(-1);
    case XML_CHAR_ENCODING_NONE:
        /* let's assume it's UTF-8 without the XML decl */
        ctxt->charset = XML_CHAR_ENCODING_UTF8;
        return(0);
    case XML_CHAR_ENCODING_UTF8:
        /* default encoding, no conversion should be needed */
        ctxt->charset = XML_CHAR_ENCODING_UTF8;

        /*
         * Errata on XML-1.0 June 20 2001
         * Specific handling of the Byte Order Mark for
         * UTF-8
         */
        if ((ctxt->input != NULL) &&
        (ctxt->input->cur[0] == 0xEF) &&
        (ctxt->input->cur[1] == 0xBB) &&
        (ctxt->input->cur[2] == 0xBF)) {
        ctxt->input->cur += 3;
        }
        return(0);
    case XML_CHAR_ENCODING_UTF16LE:
    case XML_CHAR_ENCODING_UTF16BE:
        /*The raw input characters are encoded
         *in UTF-16. As we expect this function
         *to be called after xmlCharEncInFunc, we expect
         *ctxt->input->cur to contain UTF-8 encoded characters.
         *So the raw UTF16 Byte Order Mark
         *has also been converted into
         *an UTF-8 BOM. Let's skip that BOM.
         */
        if ((ctxt->input != NULL) && (ctxt->input->cur != NULL) &&
            (ctxt->input->cur[0] == 0xEF) &&
            (ctxt->input->cur[1] == 0xBB) &&
            (ctxt->input->cur[2] == 0xBF)) {
            ctxt->input->cur += 3;
        }
        len = 90;
    break;
    case XML_CHAR_ENCODING_UCS2:
        len = 90;
    break;
    case XML_CHAR_ENCODING_UCS4BE:
    case XML_CHAR_ENCODING_UCS4LE:
    case XML_CHAR_ENCODING_UCS4_2143:
    case XML_CHAR_ENCODING_UCS4_3412:
        len = 180;
    break;
    case XML_CHAR_ENCODING_EBCDIC:
    case XML_CHAR_ENCODING_8859_1:
    case XML_CHAR_ENCODING_8859_2:
    case XML_CHAR_ENCODING_8859_3:
    case XML_CHAR_ENCODING_8859_4:
    case XML_CHAR_ENCODING_8859_5:
    case XML_CHAR_ENCODING_8859_6:
    case XML_CHAR_ENCODING_8859_7:
    case XML_CHAR_ENCODING_8859_8:
    case XML_CHAR_ENCODING_8859_9:
    case XML_CHAR_ENCODING_ASCII:
    case XML_CHAR_ENCODING_2022_JP:
    case XML_CHAR_ENCODING_SHIFT_JIS:
    case XML_CHAR_ENCODING_EUC_JP:
        len = 45;
    break;
    }
    handler = xmlGetCharEncodingHandler(enc);
    if (handler == NULL) {
    /*
     * Default handlers.
     */
    switch (enc) {
        case XML_CHAR_ENCODING_ASCII:
        /* default encoding, no conversion should be needed */
        ctxt->charset = XML_CHAR_ENCODING_UTF8;
        return(0);
        case XML_CHAR_ENCODING_UTF16LE:
        break;
        case XML_CHAR_ENCODING_UTF16BE:
        break;
        case XML_CHAR_ENCODING_UCS4LE:
        __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                   "encoding not supported %s\n",
                   BAD_CAST "USC4 little endian", NULL);
        break;
        case XML_CHAR_ENCODING_UCS4BE:
        __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                   "encoding not supported %s\n",
                   BAD_CAST "USC4 big endian", NULL);
        break;
        case XML_CHAR_ENCODING_EBCDIC:
        __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                   "encoding not supported %s\n",
                   BAD_CAST "EBCDIC", NULL);
        break;
        case XML_CHAR_ENCODING_UCS4_2143:
        __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                   "encoding not supported %s\n",
                   BAD_CAST "UCS4 2143", NULL);
        break;
        case XML_CHAR_ENCODING_UCS4_3412:
        __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                   "encoding not supported %s\n",
                   BAD_CAST "UCS4 3412", NULL);
        break;
        case XML_CHAR_ENCODING_UCS2:
        __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                   "encoding not supported %s\n",
                   BAD_CAST "UCS2", NULL);
        break;
        case XML_CHAR_ENCODING_8859_1:
        case XML_CHAR_ENCODING_8859_2:
        case XML_CHAR_ENCODING_8859_3:
        case XML_CHAR_ENCODING_8859_4:
        case XML_CHAR_ENCODING_8859_5:
        case XML_CHAR_ENCODING_8859_6:
        case XML_CHAR_ENCODING_8859_7:
        case XML_CHAR_ENCODING_8859_8:
        case XML_CHAR_ENCODING_8859_9:
        /*
         * We used to keep the internal content in the
         * document encoding however this turns being unmaintainable
         * So xmlGetCharEncodingHandler() will return non-null
         * values for this now.
         */
        if ((ctxt->inputNr == 1) &&
            (ctxt->encoding == NULL) &&
            (ctxt->input != NULL) &&
            (ctxt->input->encoding != NULL)) {
            ctxt->encoding = xmlStrdup(ctxt->input->encoding);
        }
        ctxt->charset = enc;
        return(0);
        case XML_CHAR_ENCODING_2022_JP:
        __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                   "encoding not supported %s\n",
                   BAD_CAST "ISO-2022-JP", NULL);
        break;
        case XML_CHAR_ENCODING_SHIFT_JIS:
        __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                   "encoding not supported %s\n",
                   BAD_CAST "Shift_JIS", NULL);
        break;
        case XML_CHAR_ENCODING_EUC_JP:
        __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                   "encoding not supported %s\n",
                   BAD_CAST "EUC-JP", NULL);
        break;
        default:
            break;
    }
    }
    /*
     * TODO: We could recover from errors in external entities if we
     * didn't stop the parser. But most callers of this function don't
     * check the return value.
     */
    if (handler == NULL) {
        xmlStopParser(ctxt);
    return(-1);
    }
    ctxt->charset = XML_CHAR_ENCODING_UTF8;
    ret = xmlSwitchToEncodingInt(ctxt, handler, len);
    if ((ret < 0) || (ctxt->errNo == XML_I18N_CONV_FAILED)) {
        /*
     * on encoding conversion errors, stop the parser
     */
        xmlStopParser(ctxt);
    ctxt->errNo = XML_I18N_CONV_FAILED;
    }
    return(ret);
}

Referenced by xmlCtxtResetPush(), xmlNewIOInputStream(), xmlParseCtxtExternalEntity(), xmlParseDocument(), xmlParseExternalEntityPrivate(), xmlParseExternalSubset(), xmlParseExtParsedEnt(), xmlParsePEReference(), and xmlSAX2ExternalSubset().

xmlSwitchInputEncoding()

int xmlSwitchInputEncoding	(	xmlParserCtxtPtr	ctxt,
		xmlParserInputPtr	input,
		xmlCharEncodingHandlerPtr	handler
	)

xmlSwitchInputEncoding: @ctxt: the parser context @input: the input stream @handler: the encoding handler

change the input functions when discovering the character encoding of a given entity.

Returns 0 in case of success, -1 otherwise

Definition at line 1270 of file parserInternals.c.

                                                             {
    return(xmlSwitchInputEncodingInt(ctxt, input, handler, -1));
}

xmlSwitchInputEncodingInt()

static int xmlSwitchInputEncodingInt ( xmlParserCtxtPtr  ctxt, xmlParserInputPtr  input, xmlCharEncodingHandlerPtr  handler, int  len  )

static

xmlSwitchInputEncoding: @ctxt: the parser context @input: the input stream @handler: the encoding handler @len: the number of bytes to convert for the first line or -1

change the input functions when discovering the character encoding of a given entity.

Returns 0 in case of success, -1 otherwise

Definition at line 1129 of file parserInternals.c.

{
    int nbchars;

    if (handler == NULL)
        return (-1);
    if (input == NULL)
        return (-1);
    if (input->buf != NULL) {
        if (input->buf->encoder != NULL) {
            /*
             * Check in case the auto encoding detection triggered
             * in already.
             */
            if (input->buf->encoder == handler)
                return (0);

            /*
             * "UTF-16" can be used for both LE and BE
             if ((!xmlStrncmp(BAD_CAST input->buf->encoder->name,
             BAD_CAST "UTF-16", 6)) &&
             (!xmlStrncmp(BAD_CAST handler->name,
             BAD_CAST "UTF-16", 6))) {
             return(0);
             }
             */

            /*
             * Note: this is a bit dangerous, but that's what it
             * takes to use nearly compatible signature for different
             * encodings.
             */
            xmlCharEncCloseFunc(input->buf->encoder);
            input->buf->encoder = handler;
            return (0);
        }
        input->buf->encoder = handler;

        /*
         * Is there already some content down the pipe to convert ?
         */
        if (xmlBufIsEmpty(input->buf->buffer) == 0) {
            int processed;
        unsigned int use;

            /*
             * Specific handling of the Byte Order Mark for
             * UTF-16
             */
            if ((handler->name != NULL) &&
                (!strcmp(handler->name, "UTF-16LE") ||
                 !strcmp(handler->name, "UTF-16")) &&
                (input->cur[0] == 0xFF) && (input->cur[1] == 0xFE)) {
                input->cur += 2;
            }
            if ((handler->name != NULL) &&
                (!strcmp(handler->name, "UTF-16BE")) &&
                (input->cur[0] == 0xFE) && (input->cur[1] == 0xFF)) {
                input->cur += 2;
            }
            /*
             * Errata on XML-1.0 June 20 2001
             * Specific handling of the Byte Order Mark for
             * UTF-8
             */
            if ((handler->name != NULL) &&
                (!strcmp(handler->name, "UTF-8")) &&
                (input->cur[0] == 0xEF) &&
                (input->cur[1] == 0xBB) && (input->cur[2] == 0xBF)) {
                input->cur += 3;
            }

            /*
             * Shrink the current input buffer.
             * Move it as the raw buffer and create a new input buffer
             */
            processed = input->cur - input->base;
            xmlBufShrink(input->buf->buffer, processed);
            input->buf->raw = input->buf->buffer;
            input->buf->buffer = xmlBufCreate();
        input->buf->rawconsumed = processed;
        use = xmlBufUse(input->buf->raw);

            if (ctxt->html) {
                /*
                 * convert as much as possible of the buffer
                 */
                nbchars = xmlCharEncInput(input->buf, 1);
            } else {
                /*
                 * convert just enough to get
                 * '<?xml version="1.0" encoding="xxx"?>'
                 * parsed with the autodetected encoding
                 * into the parser reading buffer.
                 */
                nbchars = xmlCharEncFirstLineInput(input->buf, len);
            }
            xmlBufResetInput(input->buf->buffer, input);
            if (nbchars < 0) {
                xmlErrInternal(ctxt,
                               "switching encoding: encoder error\n",
                               NULL);
                return (-1);
            }
        input->buf->rawconsumed += use - xmlBufUse(input->buf->raw);
        }
        return (0);
    } else if (input->length == 0) {
    /*
     * When parsing a static memory array one must know the
     * size to be able to convert the buffer.
     */
    xmlErrInternal(ctxt, "switching encoding : no input\n", NULL);
        /*
         * Callers assume that the input buffer takes ownership of the
         * encoding handler. xmlCharEncCloseFunc frees unregistered
         * handlers and avoids a memory leak.
         */
        xmlCharEncCloseFunc(handler);
    return (-1);
    }
    /*
     * We should actually raise an error here, see issue #34.
     */
    xmlCharEncCloseFunc(handler);
    return (0);
}

Referenced by xmlSwitchInputEncoding(), and xmlSwitchToEncodingInt().

xmlSwitchToEncoding()

int xmlSwitchToEncoding	(	xmlParserCtxtPtr	ctxt,
		xmlCharEncodingHandlerPtr	handler
	)

xmlSwitchToEncoding: @ctxt: the parser context @handler: the encoding handler

change the input functions when discovering the character encoding of a given entity.

Returns 0 in case of success, -1 otherwise

Definition at line 1321 of file parserInternals.c.

{
    return (xmlSwitchToEncodingInt(ctxt, handler, -1));
}

Referenced by xmlCtxtResetPush(), xmlDoRead(), xmlParseEncodingDecl(), and xmlParseInNodeContext().

xmlSwitchToEncodingInt()

static int xmlSwitchToEncodingInt ( xmlParserCtxtPtr  ctxt, xmlCharEncodingHandlerPtr  handler, int  len  )

static

xmlSwitchToEncodingInt: @ctxt: the parser context @handler: the encoding handler @len: the length to convert or -1

change the input functions when discovering the character encoding of a given entity, and convert only @len bytes of the output, this is needed on auto detect to allows any declared encoding later to convert the actual content after the xmlDecl

Returns 0 in case of success, -1 otherwise

Definition at line 1289 of file parserInternals.c.

                                                                   {
    int ret = 0;

    if (handler != NULL) {
        if (ctxt->input != NULL) {
        ret = xmlSwitchInputEncodingInt(ctxt, ctxt->input, handler, len);
    } else {
        xmlErrInternal(ctxt, "xmlSwitchToEncoding : no input\n",
                       NULL);
        return(-1);
    }
    /*
     * The parsing is now done in UTF8 natively
     */
    ctxt->charset = XML_CHAR_ENCODING_UTF8;
    } else
    return(-1);
    return(ret);
}

Referenced by xmlSwitchEncoding(), and xmlSwitchToEncoding().