Annotation of embedaddon/libxml2/DOCBparser.c, revision 1.1.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>