Annotation of embedaddon/libxml2/DOCBparser.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  * DOCBparser.c : an attempt to parse SGML Docbook documents
        !             3:  *
        !             4:  * This is deprecated !!!
        !             5:  * Code removed with release 2.6.0 it was broken.
        !             6:  * The doc are expect to be migrated to XML DocBook
        !             7:  *
        !             8:  * See Copyright for the status of this software.
        !             9:  *
        !            10:  * daniel@veillard.com
        !            11:  */
        !            12: 
        !            13: #define IN_LIBXML
        !            14: #include "libxml.h"
        !            15: #ifdef LIBXML_DOCB_ENABLED
        !            16: 
        !            17: #include <libxml/xmlerror.h>
        !            18: #include <libxml/DOCBparser.h>
        !            19: 
        !            20: /**
        !            21:  * docbEncodeEntities:
        !            22:  * @out:  a pointer to an array of bytes to store the result
        !            23:  * @outlen:  the length of @out
        !            24:  * @in:  a pointer to an array of UTF-8 chars
        !            25:  * @inlen:  the length of @in
        !            26:  * @quoteChar: the quote character to escape (' or ") or zero.
        !            27:  *
        !            28:  * Take a block of UTF-8 chars in and try to convert it to an ASCII
        !            29:  * plus SGML entities block of chars out.
        !            30:  *
        !            31:  * Returns 0 if success, -2 if the transcoding fails, or -1 otherwise
        !            32:  * The value of @inlen after return is the number of octets consumed
        !            33:  *     as the return value is positive, else unpredictable.
        !            34:  * The value of @outlen after return is the number of octets consumed.
        !            35:  */
        !            36: int
        !            37: docbEncodeEntities(unsigned char *out ATTRIBUTE_UNUSED,
        !            38:                    int *outlen ATTRIBUTE_UNUSED,
        !            39:                    const unsigned char *in ATTRIBUTE_UNUSED,
        !            40:                    int *inlen ATTRIBUTE_UNUSED,
        !            41:                    int quoteChar ATTRIBUTE_UNUSED)
        !            42: {
        !            43:     static int deprecated = 0;
        !            44: 
        !            45:     if (!deprecated) {
        !            46:         xmlGenericError(xmlGenericErrorContext,
        !            47:                         "docbEncodeEntities() deprecated function reached\n");
        !            48:         deprecated = 1;
        !            49:     }
        !            50:     return(-1);
        !            51: }
        !            52: 
        !            53: /**
        !            54:  * docbParseDocument:
        !            55:  * @ctxt:  an SGML parser context
        !            56:  * 
        !            57:  * parse an SGML document (and build a tree if using the standard SAX
        !            58:  * interface).
        !            59:  *
        !            60:  * Returns 0, -1 in case of error. the parser context is augmented
        !            61:  *                as a result of the parsing.
        !            62:  */
        !            63: 
        !            64: int
        !            65: docbParseDocument(docbParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
        !            66: {
        !            67:     static int deprecated = 0;
        !            68: 
        !            69:     if (!deprecated) {
        !            70:         xmlGenericError(xmlGenericErrorContext,
        !            71:                         "docbParseDocument() deprecated function reached\n");
        !            72:         deprecated = 1;
        !            73:     }
        !            74:     return (xmlParseDocument(ctxt));
        !            75: }
        !            76: 
        !            77: /**
        !            78:  * docbFreeParserCtxt:
        !            79:  * @ctxt:  an SGML parser context
        !            80:  *
        !            81:  * Free all the memory used by a parser context. However the parsed
        !            82:  * document in ctxt->myDoc is not freed.
        !            83:  */
        !            84: 
        !            85: void
        !            86: docbFreeParserCtxt(docbParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
        !            87: {
        !            88:     static int deprecated = 0;
        !            89: 
        !            90:     if (!deprecated) {
        !            91:         xmlGenericError(xmlGenericErrorContext,
        !            92:                         "docbFreeParserCtxt() deprecated function reached\n");
        !            93:         deprecated = 1;
        !            94:     }
        !            95:     xmlFreeParserCtxt(ctxt);
        !            96: }
        !            97: 
        !            98: /**
        !            99:  * docbParseChunk:
        !           100:  * @ctxt:  an XML parser context
        !           101:  * @chunk:  an char array
        !           102:  * @size:  the size in byte of the chunk
        !           103:  * @terminate:  last chunk indicator
        !           104:  *
        !           105:  * Parse a Chunk of memory
        !           106:  *
        !           107:  * Returns zero if no error, the xmlParserErrors otherwise.
        !           108:  */
        !           109: int
        !           110: docbParseChunk(docbParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
        !           111:                const char *chunk ATTRIBUTE_UNUSED,
        !           112:               int size ATTRIBUTE_UNUSED,
        !           113:                int terminate ATTRIBUTE_UNUSED)
        !           114: {
        !           115:     static int deprecated = 0;
        !           116: 
        !           117:     if (!deprecated) {
        !           118:         xmlGenericError(xmlGenericErrorContext,
        !           119:                         "docbParseChunk() deprecated function reached\n");
        !           120:         deprecated = 1;
        !           121:     }
        !           122: 
        !           123:     return (xmlParseChunk(ctxt, chunk, size, terminate));
        !           124: }
        !           125: 
        !           126: /**
        !           127:  * docbCreatePushParserCtxt:
        !           128:  * @sax:  a SAX handler
        !           129:  * @user_data:  The user data returned on SAX callbacks
        !           130:  * @chunk:  a pointer to an array of chars
        !           131:  * @size:  number of chars in the array
        !           132:  * @filename:  an optional file name or URI
        !           133:  * @enc:  an optional encoding
        !           134:  *
        !           135:  * Create a parser context for using the DocBook SGML parser in push mode
        !           136:  * To allow content encoding detection, @size should be >= 4
        !           137:  * The value of @filename is used for fetching external entities
        !           138:  * and error/warning reports.
        !           139:  *
        !           140:  * Returns the new parser context or NULL
        !           141:  */
        !           142: docbParserCtxtPtr
        !           143: docbCreatePushParserCtxt(docbSAXHandlerPtr sax ATTRIBUTE_UNUSED,
        !           144:                          void *user_data ATTRIBUTE_UNUSED,
        !           145:                          const char *chunk ATTRIBUTE_UNUSED,
        !           146:                         int size ATTRIBUTE_UNUSED,
        !           147:                         const char *filename ATTRIBUTE_UNUSED,
        !           148:                          xmlCharEncoding enc ATTRIBUTE_UNUSED)
        !           149: {
        !           150:     static int deprecated = 0;
        !           151: 
        !           152:     if (!deprecated) {
        !           153:         xmlGenericError(xmlGenericErrorContext,
        !           154:                         "docbParseChunk() deprecated function reached\n");
        !           155:         deprecated = 1;
        !           156:     }
        !           157: 
        !           158:     return(xmlCreatePushParserCtxt(sax, user_data, chunk, size, filename));
        !           159: }
        !           160: 
        !           161: /**
        !           162:  * docbSAXParseDoc:
        !           163:  * @cur:  a pointer to an array of xmlChar
        !           164:  * @encoding:  a free form C string describing the SGML document encoding, or NULL
        !           165:  * @sax:  the SAX handler block
        !           166:  * @userData: if using SAX, this pointer will be provided on callbacks. 
        !           167:  *
        !           168:  * parse an SGML in-memory document and build a tree.
        !           169:  * It use the given SAX function block to handle the parsing callback.
        !           170:  * If sax is NULL, fallback to the default DOM tree building routines.
        !           171:  * 
        !           172:  * Returns the resulting document tree
        !           173:  */
        !           174: 
        !           175: docbDocPtr
        !           176: docbSAXParseDoc(xmlChar * cur ATTRIBUTE_UNUSED,
        !           177:                 const char *encoding ATTRIBUTE_UNUSED,
        !           178:                docbSAXHandlerPtr sax ATTRIBUTE_UNUSED,
        !           179:                 void *userData ATTRIBUTE_UNUSED)
        !           180: {
        !           181:     static int deprecated = 0;
        !           182: 
        !           183:     if (!deprecated) {
        !           184:         xmlGenericError(xmlGenericErrorContext,
        !           185:                         "docbParseChunk() deprecated function reached\n");
        !           186:         deprecated = 1;
        !           187:     }
        !           188: 
        !           189:     return (xmlSAXParseMemoryWithData(sax, (const char *)cur,
        !           190:                          xmlStrlen((const xmlChar *) cur), 0,  userData));
        !           191: }
        !           192: 
        !           193: /**
        !           194:  * docbParseDoc:
        !           195:  * @cur:  a pointer to an array of xmlChar
        !           196:  * @encoding:  a free form C string describing the SGML document encoding, or NULL
        !           197:  *
        !           198:  * parse an SGML in-memory document and build a tree.
        !           199:  * 
        !           200:  * Returns the resulting document tree
        !           201:  */
        !           202: 
        !           203: docbDocPtr
        !           204: docbParseDoc(xmlChar * cur ATTRIBUTE_UNUSED,
        !           205:              const char *encoding ATTRIBUTE_UNUSED)
        !           206: {
        !           207:     static int deprecated = 0;
        !           208: 
        !           209:     if (!deprecated) {
        !           210:         xmlGenericError(xmlGenericErrorContext,
        !           211:                         "docbParseChunk() deprecated function reached\n");
        !           212:         deprecated = 1;
        !           213:     }
        !           214: 
        !           215:     return (xmlParseDoc(cur));
        !           216: }
        !           217: 
        !           218: 
        !           219: /**
        !           220:  * docbCreateFileParserCtxt:
        !           221:  * @filename:  the filename
        !           222:  * @encoding:  the SGML document encoding, or NULL
        !           223:  *
        !           224:  * Create a parser context for a file content. 
        !           225:  * Automatic support for ZLIB/Compress compressed document is provided
        !           226:  * by default if found at compile-time.
        !           227:  *
        !           228:  * Returns the new parser context or NULL
        !           229:  */
        !           230: docbParserCtxtPtr
        !           231: docbCreateFileParserCtxt(const char *filename ATTRIBUTE_UNUSED,
        !           232:                          const char *encoding ATTRIBUTE_UNUSED)
        !           233: {
        !           234:     static int deprecated = 0;
        !           235: 
        !           236:     if (!deprecated) {
        !           237:         xmlGenericError(xmlGenericErrorContext,
        !           238:                         "docbCreateFileParserCtxt() deprecated function reached\n");
        !           239:         deprecated = 1;
        !           240:     }
        !           241: 
        !           242:     return (xmlCreateFileParserCtxt(filename));
        !           243: }
        !           244: 
        !           245: /**
        !           246:  * docbSAXParseFile:
        !           247:  * @filename:  the filename
        !           248:  * @encoding:  a free form C string describing the SGML document encoding, or NULL
        !           249:  * @sax:  the SAX handler block
        !           250:  * @userData: if using SAX, this pointer will be provided on callbacks. 
        !           251:  *
        !           252:  * parse an SGML file and build a tree. Automatic support for ZLIB/Compress
        !           253:  * compressed document is provided by default if found at compile-time.
        !           254:  * It use the given SAX function block to handle the parsing callback.
        !           255:  * If sax is NULL, fallback to the default DOM tree building routines.
        !           256:  *
        !           257:  * Returns the resulting document tree
        !           258:  */
        !           259: 
        !           260: docbDocPtr
        !           261: docbSAXParseFile(const char *filename ATTRIBUTE_UNUSED,
        !           262:                  const char *encoding ATTRIBUTE_UNUSED,
        !           263:                  docbSAXHandlerPtr sax ATTRIBUTE_UNUSED,
        !           264:                 void *userData ATTRIBUTE_UNUSED)
        !           265: {
        !           266:     static int deprecated = 0;
        !           267: 
        !           268:     if (!deprecated) {
        !           269:         xmlGenericError(xmlGenericErrorContext,
        !           270:                         "docbSAXParseFile() deprecated function reached\n");
        !           271:         deprecated = 1;
        !           272:     }
        !           273: 
        !           274:     return (xmlSAXParseFileWithData(sax, filename, 0, userData));
        !           275: }
        !           276: 
        !           277: /**
        !           278:  * docbParseFile:
        !           279:  * @filename:  the filename
        !           280:  * @encoding:  a free form C string describing document encoding, or NULL
        !           281:  *
        !           282:  * parse a Docbook SGML file and build a tree. Automatic support for
        !           283:  * ZLIB/Compress compressed document is provided by default if found
        !           284:  * at compile-time.
        !           285:  *
        !           286:  * Returns the resulting document tree
        !           287:  */
        !           288: 
        !           289: docbDocPtr
        !           290: docbParseFile(const char *filename ATTRIBUTE_UNUSED,
        !           291:               const char *encoding ATTRIBUTE_UNUSED)
        !           292: {
        !           293:     static int deprecated = 0;
        !           294: 
        !           295:     if (!deprecated) {
        !           296:         xmlGenericError(xmlGenericErrorContext,
        !           297:                         "docbParseFile() deprecated function reached\n");
        !           298:         deprecated = 1;
        !           299:     }
        !           300: 
        !           301:     return (xmlParseFile(filename));
        !           302: }
        !           303: #define bottom_DOCBparser
        !           304: #include "elfgcchack.h"
        !           305: #endif /* LIBXML_DOCB_ENABLED */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>