parsear - parse xml c# example

Analizador XML para C

Question

¿Puede sugerir algunos de los mejores analizadores XML para C?

Answer 1

¿Podría darnos alguna indicación de para qué plataformas está escribiendo? Esto debería pesar mucho sobre lo que es ''mejor''. Es posible que encuentre una biblioteca super ''xml-foo'' que no se envía comúnmente en la mayoría de los sistemas de forma predeterminada ... aunque es genial, la falta de la biblioteca podría evitar (o al menos) molestar a los usuarios.

Sobre todo, utilizo libxml2 .. porque es estándar o fácil de instalar en las plataformas a las que me dirijo.

Como puede ver, "lo mejor" también está determinado por la disponibilidad de la biblioteca en sus plataformas de destino.

Answer 2

¿Qué tal uno escrito en ensamblador puro :-) No te olvides de revisar los benchmarks .

Answer 3

Dos de los analizadores más utilizados son Expat y libxml .

Si estás de acuerdo con el uso de C ++, también hay Xerces-C++ .

Answer 4

Dos ejemplos con expat y libxml2 . El segundo es, en mi humilde opinión, mucho más fácil de usar ya que crea un árbol en la memoria, una estructura de datos con la que es fácil trabajar. expat, por otro lado, no construye nada (tienes que hacerlo tú mismo), solo te permite llamar a los manejadores en eventos específicos durante el análisis sintáctico. Pero el expatriado puede ser más rápido (no medí).

Con expat, leyendo un archivo XML y mostrando los elementos sangrados:

/* 
   A simple test program to parse XML documents with expat
   <http://expat.sourceforge.net/>. It just displays the element
   names.

   On Debian, compile with:

   gcc -Wall -o expat-test -lexpat expat-test.c  

   Inspired from <http://www.xml.com/pub/a/1999/09/expat/index.html> 
*/

#include <expat.h>
#include <stdio.h>
#include <string.h>

/* Keep track of the current level in the XML tree */
int             Depth;

#define MAXCHARS 1000000

void
start(void *data, const char *el, const char **attr)
{
    int             i;

    for (i = 0; i < Depth; i++)
        printf("  ");

    printf("%s", el);

    for (i = 0; attr[i]; i += 2) {
        printf(" %s=''%s''", attr[i], attr[i + 1]);
    }

    printf("/n");
    Depth++;
}               /* End of start handler */

void
end(void *data, const char *el)
{
    Depth--;
}               /* End of end handler */

int
main(int argc, char **argv)
{

    char           *filename;
    FILE           *f;
    size_t          size;
    char           *xmltext;
    XML_Parser      parser;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s filename/n", argv[0]);
        return (1);
    }
    filename = argv[1];
    parser = XML_ParserCreate(NULL);
    if (parser == NULL) {
        fprintf(stderr, "Parser not created/n");
        return (1);
    }
    /* Tell expat to use functions start() and end() each times it encounters
     * the start or end of an element. */
    XML_SetElementHandler(parser, start, end);
    f = fopen(filename, "r");
    xmltext = malloc(MAXCHARS);
    /* Slurp the XML file in the buffer xmltext */
    size = fread(xmltext, sizeof(char), MAXCHARS, f);
    if (XML_Parse(parser, xmltext, strlen(xmltext), XML_TRUE) ==
        XML_STATUS_ERROR) {
        fprintf(stderr,
            "Cannot parse %s, file may be too large or not well-formed XML/n",
            filename);
        return (1);
    }
    fclose(f);
    XML_ParserFree(parser);
    fprintf(stdout, "Successfully parsed %i characters in file %s/n", size,
        filename);
    return (0);
}

Con libxml2, un programa que muestra el nombre del elemento raíz y los nombres de sus hijos:

/*
   Simple test with libxml2 <http://xmlsoft.org>. It displays the name
   of the root element and the names of all its children (not
   descendents, just children).

   On Debian, compiles with:
   gcc -Wall -o read-xml2 $(xml2-config --cflags) $(xml2-config --libs) /
                    read-xml2.c    

*/

#include <stdio.h>
#include <string.h>
#include <libxml/parser.h>

int
main(int argc, char **argv)
{
    xmlDoc         *document;
    xmlNode        *root, *first_child, *node;
    char           *filename;

    if (argc < 2) {
        fprintf(stderr, "Usage: %s filename.xml/n", argv[0]);
        return 1;
    }
    filename = argv[1];

    document = xmlReadFile(filename, NULL, 0);
    root = xmlDocGetRootElement(document);
    fprintf(stdout, "Root is <%s> (%i)/n", root->name, root->type);
    first_child = root->children;
    for (node = first_child; node; node = node->next) {
        fprintf(stdout, "/t Child is <%s> (%i)/n", node->name, node->type);
    }
    fprintf(stdout, ".../n");
    return 0;
}

Answer 5

En Windows, es nativo con Win32 api ...

Answer 6

Mi preferencia personal es libxml2 . Es muy fácil de usar, pero nunca me molesté en compararlo, ya que solo lo he usado para el análisis de archivos de configuración.

Answer 7

Para C ++ sugiero usar CMarkup .

Answer 8

Puedes probar ezxml - es un analizador liviano escrito completamente en C.

Para C ++ puedes ver TinyXML++

Answer 9

El expatriado es bastante decente. Sin embargo, es difícil dar buenas recomendaciones sin más información.

Answer 10

http://www.minixml.org también es bastante bueno. Pequeño y justo ANSI C.