Return to parse4.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2 / doc / examples

Annotation of embedaddon/libxml2/doc/examples/parse4.c, revision 1.1

1.1     ! misho       1: /**
        !             2:  * section: Parsing
        !             3:  * synopsis: Parse an XML document chunk by chunk to a tree and free it
        !             4:  * purpose: Demonstrate the use of xmlCreatePushParserCtxt() and
        !             5:  *          xmlParseChunk() to read an XML file progressively
        !             6:  *          into a tree and and xmlFreeDoc() to free the resulting tree
        !             7:  * usage: parse4 test3.xml
        !             8:  * test: parse4 test3.xml
        !             9:  * author: Daniel Veillard
        !            10:  * copy: see Copyright for the status of this software.
        !            11:  */
        !            12: 
        !            13: #include <stdio.h>
        !            14: #include <libxml/parser.h>
        !            15: #include <libxml/tree.h>
        !            16: 
        !            17: #ifdef LIBXML_PUSH_ENABLED
        !            18: static FILE *desc;
        !            19: 
        !            20: /**
        !            21:  * readPacket:
        !            22:  * @mem: array to store the packet
        !            23:  * @size: the packet size
        !            24:  *
        !            25:  * read at most @size bytes from the document and store it in @mem
        !            26:  *
        !            27:  * Returns the number of bytes read
        !            28:  */
        !            29: static int
        !            30: readPacket(char *mem, int size) {
        !            31:     int res;
        !            32: 
        !            33:     res = fread(mem, 1, size, desc);
        !            34:     return(res);
        !            35: }
        !            36: 
        !            37: /**
        !            38:  * example4Func:
        !            39:  * @filename: a filename or an URL
        !            40:  *
        !            41:  * Parse the resource and free the resulting tree
        !            42:  */
        !            43: static void
        !            44: example4Func(const char *filename) {
        !            45:     xmlParserCtxtPtr ctxt;
        !            46:     char chars[4];
        !            47:     xmlDocPtr doc; /* the resulting document tree */
        !            48:     int res;
        !            49: 
        !            50:     /*
        !            51:      * Read a few first byte to check the input used for the
        !            52:      * encoding detection at the parser level.
        !            53:      */
        !            54:     res = readPacket(chars, 4);
        !            55:     if (res <= 0) {
        !            56:         fprintf(stderr, "Failed to parse %s\n", filename);
        !            57:        return;
        !            58:     }
        !            59: 
        !            60:     /*
        !            61:      * Create a progressive parsing context, the 2 first arguments
        !            62:      * are not used since we want to build a tree and not use a SAX
        !            63:      * parsing interface. We also pass the first bytes of the document
        !            64:      * to allow encoding detection when creating the parser but this
        !            65:      * is optional.
        !            66:      */
        !            67:     ctxt = xmlCreatePushParserCtxt(NULL, NULL,
        !            68:                                    chars, res, filename);
        !            69:     if (ctxt == NULL) {
        !            70:         fprintf(stderr, "Failed to create parser context !\n");
        !            71:        return;
        !            72:     }
        !            73: 
        !            74:     /*
        !            75:      * loop on the input getting the document data, of course 4 bytes
        !            76:      * at a time is not realistic but allows to verify testing on small
        !            77:      * documents.
        !            78:      */
        !            79:     while ((res = readPacket(chars, 4)) > 0) {
        !            80:         xmlParseChunk(ctxt, chars, res, 0);
        !            81:     }
        !            82: 
        !            83:     /*
        !            84:      * there is no more input, indicate the parsing is finished.
        !            85:      */
        !            86:     xmlParseChunk(ctxt, chars, 0, 1);
        !            87: 
        !            88:     /*
        !            89:      * collect the document back and if it was wellformed
        !            90:      * and destroy the parser context.
        !            91:      */
        !            92:     doc = ctxt->myDoc;
        !            93:     res = ctxt->wellFormed;
        !            94:     xmlFreeParserCtxt(ctxt);
        !            95: 
        !            96:     if (!res) {
        !            97:         fprintf(stderr, "Failed to parse %s\n", filename);
        !            98:     }
        !            99: 
        !           100:     /*
        !           101:      * since we don't use the document, destroy it now.
        !           102:      */
        !           103:     xmlFreeDoc(doc);
        !           104: }
        !           105: 
        !           106: int main(int argc, char **argv) {
        !           107:     if (argc != 2)
        !           108:         return(1);
        !           109: 
        !           110:     /*
        !           111:      * this initialize the library and check potential ABI mismatches
        !           112:      * between the version it was compiled for and the actual shared
        !           113:      * library used.
        !           114:      */
        !           115:     LIBXML_TEST_VERSION
        !           116: 
        !           117:     /*
        !           118:      * simulate a progressive parsing using the input file.
        !           119:      */
        !           120:     desc = fopen(argv[1], "rb");
        !           121:     if (desc != NULL) {
        !           122:        example4Func(argv[1]);
        !           123:        fclose(desc);
        !           124:     } else {
        !           125:         fprintf(stderr, "Failed to parse %s\n", argv[1]);
        !           126:     }
        !           127: 
        !           128:     /*
        !           129:      * Cleanup function for the XML library.
        !           130:      */
        !           131:     xmlCleanupParser();
        !           132:     /*
        !           133:      * this is to debug memory for regression tests
        !           134:      */
        !           135:     xmlMemoryDump();
        !           136:     return(0);
        !           137: }
        !           138: #else /* ! LIBXML_PUSH_ENABLED */
        !           139: int main(int argc, char **argv) {
        !           140:     fprintf(stderr, "Library not compiled with push parser support\n");
        !           141:     return(1);
        !           142: }
        !           143: #endif