Return to tree2.c CVS log

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

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

1.1     ! misho       1: /* 
        !             2:  * section:  Tree
        !             3:  * synopsis: Creates a tree
        !             4:  * purpose:  Shows how to create document, nodes and dump it to stdout or file.
        !             5:  * usage:    tree2 <filename>  -Default output: stdout
        !             6:  * test:     tree2 > tree2.tmp ; diff tree2.tmp tree2.res ; rm tree2.tmp
        !             7:  * author:   Lucas Brasilino <brasilino@recife.pe.gov.br>
        !             8:  * copy:     see Copyright for the status of this software
        !             9:  */
        !            10: 
        !            11: #include <stdio.h>
        !            12: #include <libxml/parser.h>
        !            13: #include <libxml/tree.h>
        !            14: 
        !            15: #if defined(LIBXML_TREE_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
        !            16: 
        !            17: /*
        !            18:  *To compile this file using gcc you can type
        !            19:  *gcc `xml2-config --cflags --libs` -o tree2 tree2.c
        !            20:  */
        !            21: 
        !            22: /* A simple example how to create DOM. Libxml2 automagically 
        !            23:  * allocates the necessary amount of memory to it.
        !            24: */
        !            25: int
        !            26: main(int argc, char **argv)
        !            27: {
        !            28:     xmlDocPtr doc = NULL;       /* document pointer */
        !            29:     xmlNodePtr root_node = NULL, node = NULL, node1 = NULL;/* node pointers */
        !            30:     xmlDtdPtr dtd = NULL;       /* DTD pointer */
        !            31:     char buff[256];
        !            32:     int i, j;
        !            33: 
        !            34:     LIBXML_TEST_VERSION;
        !            35: 
        !            36:     /* 
        !            37:      * Creates a new document, a node and set it as a root node
        !            38:      */
        !            39:     doc = xmlNewDoc(BAD_CAST "1.0");
        !            40:     root_node = xmlNewNode(NULL, BAD_CAST "root");
        !            41:     xmlDocSetRootElement(doc, root_node);
        !            42: 
        !            43:     /*
        !            44:      * Creates a DTD declaration. Isn't mandatory. 
        !            45:      */
        !            46:     dtd = xmlCreateIntSubset(doc, BAD_CAST "root", NULL, BAD_CAST "tree2.dtd");
        !            47: 
        !            48:     /* 
        !            49:      * xmlNewChild() creates a new node, which is "attached" as child node
        !            50:      * of root_node node. 
        !            51:      */
        !            52:     xmlNewChild(root_node, NULL, BAD_CAST "node1",
        !            53:                 BAD_CAST "content of node 1");
        !            54:     /* 
        !            55:      * The same as above, but the new child node doesn't have a content 
        !            56:      */
        !            57:     xmlNewChild(root_node, NULL, BAD_CAST "node2", NULL);
        !            58: 
        !            59:     /* 
        !            60:      * xmlNewProp() creates attributes, which is "attached" to an node.
        !            61:      * It returns xmlAttrPtr, which isn't used here.
        !            62:      */
        !            63:     node =
        !            64:         xmlNewChild(root_node, NULL, BAD_CAST "node3",
        !            65:                     BAD_CAST "this node has attributes");
        !            66:     xmlNewProp(node, BAD_CAST "attribute", BAD_CAST "yes");
        !            67:     xmlNewProp(node, BAD_CAST "foo", BAD_CAST "bar");
        !            68: 
        !            69:     /*
        !            70:      * Here goes another way to create nodes. xmlNewNode() and xmlNewText
        !            71:      * creates a node and a text node separately. They are "attached"
        !            72:      * by xmlAddChild() 
        !            73:      */
        !            74:     node = xmlNewNode(NULL, BAD_CAST "node4");
        !            75:     node1 = xmlNewText(BAD_CAST
        !            76:                    "other way to create content (which is also a node)");
        !            77:     xmlAddChild(node, node1);
        !            78:     xmlAddChild(root_node, node);
        !            79: 
        !            80:     /* 
        !            81:      * A simple loop that "automates" nodes creation 
        !            82:      */
        !            83:     for (i = 5; i < 7; i++) {
        !            84:         sprintf(buff, "node%d", i);
        !            85:         node = xmlNewChild(root_node, NULL, BAD_CAST buff, NULL);
        !            86:         for (j = 1; j < 4; j++) {
        !            87:             sprintf(buff, "node%d%d", i, j);
        !            88:             node1 = xmlNewChild(node, NULL, BAD_CAST buff, NULL);
        !            89:             xmlNewProp(node1, BAD_CAST "odd", BAD_CAST((j % 2) ? "no" : "yes"));
        !            90:         }
        !            91:     }
        !            92: 
        !            93:     /* 
        !            94:      * Dumping document to stdio or file
        !            95:      */
        !            96:     xmlSaveFormatFileEnc(argc > 1 ? argv[1] : "-", doc, "UTF-8", 1);
        !            97: 
        !            98:     /*free the document */
        !            99:     xmlFreeDoc(doc);
        !           100: 
        !           101:     /*
        !           102:      *Free the global variables that may
        !           103:      *have been allocated by the parser.
        !           104:      */
        !           105:     xmlCleanupParser();
        !           106: 
        !           107:     /*
        !           108:      * this is to debug memory for regression tests
        !           109:      */
        !           110:     xmlMemoryDump();
        !           111:     return(0);
        !           112: }
        !           113: #else
        !           114: int main(void) {
        !           115:     fprintf(stderr, "tree support not compiled in\n");
        !           116:     exit(1);
        !           117: }
        !           118: #endif