sasa_c_xml.c

Go to the documentation of this file.

/* ---------------------------------------------------- */
/* Copyright 2006-2010, CERFACS, Toulouse, France. */
/* Copyright 2006-2010, Centre National de la Recherche Scientifique, Paris, France. */
/* All rights reserved. Use is subject to OASIS4 license terms. */
/* ---------------------------------------------------- */
/*
   file sasa_c_xml.c
   C source file for sasa
*/


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <libxml/parser.h>
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include "sasa_c_xml.h"

/*
 
  !DESCRIPTION:
 
   This file gathers the c interface of the xml extraction tools. 
   The extraction is done with the 'xpath' technics.

  !FILES USED:

         <stdio.h>
         <string.h>
         <stdlib.h>
         <libxml/parser.h>
         <libxml/xpath.h>
         "sasa_c_f90.h"

  !REVISION HISTORY:

    Date      Programmer   Description
  ----------  ----------   -----------
   ??.??.??   P. Bourcier   Creation
   30.01.04   D. Declat     The character management has been modified.
                            Some routines had been deleted.
   21.05.07   F. Dufour     Fix possible memory access violation and minors memory leaks
   04.06.07   F. Dufour     Add support for namespace prefix
   20.06.07   F. Dufour     Add support for default namespace in xpath expression
   22.03.10   JM Epitalon   Simultaneous access to multiple files
//EOP

 ----------------------------------------------------------------------
  $Id: sasa_c_xml.c 2399 2010-06-21 08:09:39Z coquart $
  $Author: coquart $
 ---------------------------------------------------------------------- */

/* table of pointers to open documents */
#define MAX_OPEN_DOCUMENTS    100
xmlDocPtr open_doc[MAX_OPEN_DOCUMENTS];
/* Number of open document */
int nb_open_doc = -1;

int
sasaOpenXml(const char *filename)
{
    xmlDocPtr doc;
    int num_doc;
        int i;
    
    /* Initialise table if not yet done */
    if (nb_open_doc == -1)
    {
        for (i = 0; i < MAX_OPEN_DOCUMENTS; i += 1)
            open_doc[i] = NULL;
        nb_open_doc = 0;
    }

    if (nb_open_doc == MAX_OPEN_DOCUMENTS)
    {
        fprintf(stderr, "%s:%d: number of open XML documents is too large.\n", 
                  __FILE__, __LINE__);
        return -1;
    }
    else
    {
        /* parse an XML file and build a tree */
        doc = xmlParseFile(filename);
        if(doc == (xmlDocPtr) NULL)
        {
            fprintf(stderr, "%s:%d: document not parsed successfully.\n", 
                    __FILE__, __LINE__);
            return -1;
        }
        else
        {
            /* Look for an empty slot in open doc table */
            for (num_doc = 0; open_doc[num_doc] != NULL; num_doc += 1)
                ;
            /* store pointer to open doc into slot */
            open_doc[num_doc] = doc;
            nb_open_doc += 1;
            
            return num_doc;
        }
    }
}  /* end sasaOpenXml */


int
sasaCloseXml(int num_doc)
{
    xmlDocPtr doc;
    
    /* free the document */
    doc = open_doc[num_doc];
    xmlFreeDoc(doc);
    
    /* reset pointer to open doc */
    open_doc[num_doc] = NULL;
    nb_open_doc -= 1;
    
    return EXIT_SUCCESS;
    
}  /* end sasaCloseXml */


/* - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = */


int
getXmlNodeCount(int num_doc, const char *nodeName, int *nodeNumber)
{
    xmlDocPtr doc;
    size_t length = 0;
    char *xpathBase = "count (//", *xpath = NULL;
    char *nodeNameNs = NULL;
    xmlNodePtr  root = NULL;

    xmlXPathContextPtr context    = NULL;
    xmlChar            *xpathExpr = NULL;
    xmlXPathObjectPtr  result     = NULL;
    
    doc = open_doc[num_doc];
    root = xmlDocGetRootElement(doc);
    
    if(root == NULL)
    {
        printf("XML File Error : No root element !\n");
        *nodeNumber = 0;
        
        return EXIT_FAILURE;
    }

    if(nodeName == NULL || (*nodeName) == '\0')
    {
        printf("No node name to count !\n");
        *nodeNumber = 0;
        
        return EXIT_FAILURE;
    }
    
    context = xmlXPathNewContext(doc);
    
    
    /* Register prefixed namespace(s) defined in the root node */
    if(root->ns != NULL)
    {
        xmlNsPtr ns = root->nsDef->next;
        
        xmlXPathRegisterNs(context, (const xmlChar *)root->nsDef->prefix, (const xmlChar *)root->nsDef->href);
        
        do
        {
            xmlXPathRegisterNs(context, (const xmlChar *)ns->prefix, (const xmlChar *)ns->href);
            
            ns = ns->next;
        }while(ns != NULL);
    }
    
    /* If a default namespace is defined
     *  
     * IMPORTANT: XPath 1.0 has no concept of a default namespace. Unprefixed names in XPath only match names which have no namespace.
     * So, if the document uses a default namespace, it is required to associate a non-empty prefix with the default namespace
     * via register-namespace  and add that prefix to names in XPath expressions intended to match nodes in the default namespace.
    */

    if(root->ns && !root->ns->prefix)
    {
        char *c, *start;
        char **nodeNameNsTab = NULL;
        unsigned int nb_tab  = 1, i, nb_tab_alloc = 10;
        
        xmlXPathRegisterNs(context, (const xmlChar *)"default", root->ns->href);
        
        c = start = (char *)nodeName;
        
        nodeNameNsTab = (char **)calloc(nb_tab_alloc, sizeof(char *));
        
        do
        {
            if((*c) == '/')
            {
                nodeNameNsTab[nb_tab - 1] = (char *)calloc((c - start) + 1, 1);
                strncpy(nodeNameNsTab[nb_tab - 1], (const char *)start, c - start);
                if (nb_tab == nb_tab_alloc)
                {
                    nb_tab_alloc += 10;
                    nodeNameNsTab = (char **)realloc(nodeNameNsTab, nb_tab_alloc * sizeof(char *));
                }
                nb_tab += 1;
                start = c + 1;
            }
            
            ++c;
        }while((*c) != '\0');
        
        nodeNameNsTab[nb_tab - 1] = (char *)calloc((c - start) + 1, 1);
        strcpy(nodeNameNsTab[nb_tab - 1], (const char *)start);
        
        for(i = 0; i < nb_tab; ++i)
        {
            char *tmp = NULL;
            /* : and @ punctuation mark detection */
            unsigned int detected = 0; 
            c = (char *)nodeNameNsTab[i];
            
            do
            {
                if((*c) == ':' || (*c) == '@')
                {
                    detected = 1;
                    start = c + 1;
                }
                ++c;
            }while((*c) != '\0');
            
            if(!detected)
            {
                tmp = (char *)calloc(strlen(nodeNameNsTab[i]) + 9, 1);
                strcpy(tmp, "default:");
                strcpy(&tmp[8], (const char *)nodeNameNsTab[i]);

                free(nodeNameNsTab[i]);
                nodeNameNsTab[i] = tmp;
            }
        }


        length = strlen(xpathBase) + nb_tab;
        
        for(i = 0; i < nb_tab; ++i)
        {
            length += strlen(nodeNameNsTab[i]);
            
        }
        
        xpath  = (char *)calloc(length + 1, 1);
        
        strcpy(xpath, xpathBase);
        
        for(i = 0; i < nb_tab; ++i)
        {
            if(i)
                strcat(xpath, "/");
            strcat(xpath, (const char *)nodeNameNsTab[i]);
            free(nodeNameNsTab[i]);
        }
        
        free(nodeNameNsTab);
        
        strcat(xpath, ")");
        
    }
    else
    {
        nodeNameNs = (char *)nodeName;
        
        length = strlen(xpathBase) + strlen(nodeNameNs) + 1;
        xpath  = (char *) calloc(length + 1, 1);
        
        if(xpath == NULL)
        { 
            printf("%s:%d: realloc failed.\n", __FILE__, __LINE__);
            *nodeNumber = 0;
            
            return EXIT_FAILURE;
        }
        
        strcpy(xpath, xpathBase);
        strcat(xpath, nodeNameNs);
        strcat(xpath, ")");
    }
    
    
    
    xpathExpr = (xmlChar*) xpath;
    result = xmlXPathEvalExpression(xpathExpr, context);
    
    free(xpath);
    
    if(result->type != XPATH_NUMBER)
    {
        *nodeNumber = 0;
#ifdef DEBUG
        printf("getXmlNodeCount : No result\n");
#endif
        xmlXPathFreeObject(result);
        xmlXPathFreeContext(context);
        
        return EXIT_NOTFOUND;
    }
    else
    {
        *nodeNumber = (int) result->floatval;
#ifdef DEBUG
        printf("getXmlNodeCount : nodeNumber : %d\n", *nodeNumber);
#endif
        xmlXPathFreeObject(result);
        xmlXPathFreeContext(context);
        
        return EXIT_FOUND;
    }  
    
    
}  /* end sasaGetXmlNodeCount */


/* - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = */


int
getXmlInfo(int num_doc, char *xpathSearchString, char **xpathResultString)
{
    xmlDocPtr doc;
    xmlXPathContextPtr context    = NULL;
    xmlChar            *xpathExpr = NULL;
    xmlXPathObjectPtr  result     = NULL;
    xmlNodeSetPtr      nodeSet    = NULL;
    xmlNodePtr         *curNode   = NULL;
    
    xmlNodePtr  root = NULL;
    doc = open_doc[num_doc];
    root = xmlDocGetRootElement(doc);
    
    context = xmlXPathNewContext(doc);
    
    /* Register prefixed namespace(s) defined in the root node */
    if(root->ns != NULL)
    {
        xmlNsPtr ns = root->nsDef->next;
        
        xmlXPathRegisterNs(context, (const xmlChar *)root->nsDef->prefix, (const xmlChar *)root->nsDef->href);
        
        do
        {
            xmlXPathRegisterNs(context, (const xmlChar *)ns->prefix, (const xmlChar *)ns->href);
            
            ns = ns->next;
        }while(ns != NULL);
    }
    
    
    /* If a default namespace is defined
     *  
     * IMPORTANT: XPath 1.0 has no concept of a default namespace. Unprefixed names in XPath only match names which have no namespace.
     * So, if the document uses a default namespace, it is required to associate a non-empty prefix with the default namespace
     * via register-namespace  and add that prefix to names in XPath expressions intended to match nodes in the default namespace.
    */

    if(root->ns && !root->ns->prefix)
    {
        size_t length = 0;
        char *c, *start;
        char *xpath = NULL;
        char **nodeNameNsTab = NULL;
        unsigned int nb_tab  = 1, i, nb_tab_alloc = 10;
        
        xmlXPathRegisterNs(context, (const xmlChar *)"default", root->ns->href);
        printf("default namespace\n");
        c = (char *)xpathSearchString;
        
        c += 2;
        start = c;
        
        nodeNameNsTab = (char **)calloc(nb_tab_alloc, sizeof(char *));
        
        do
        {
            if((*c) == '/')
            {
                nodeNameNsTab[nb_tab - 1] = (char *)calloc((c - start) + 1, 1);
                strncpy(nodeNameNsTab[nb_tab - 1], (const char *)start, c - start);
                if (nb_tab == nb_tab_alloc)
                {
                    nb_tab_alloc += 10;
                    nodeNameNsTab = (char **)realloc(nodeNameNsTab, nb_tab_alloc * sizeof(char *));
                }
                nb_tab += 1;
                start = c + 1;
            }
            
            ++c;
        }while((*c) != '\0');
        
        nodeNameNsTab[nb_tab - 1] = (char *)calloc((c - start) + 1, 1);
        strcpy(nodeNameNsTab[nb_tab - 1], (const char *)start);
        
        for(i = 0; i < nb_tab; ++i)
        {
            char *tmp = NULL;
            /* : and @ punctuation mark detection */
            unsigned int detected = 0; 
            c = (char *)nodeNameNsTab[i];
            
            do
            {
                if((*c) == ':' || (*c) == '@')
                {
                    detected = 1;
                    start = c + 1;
                }
                ++c;
            }while((*c) != '\0');
            
            if(!detected)
            {
                tmp = (char *)calloc(strlen(nodeNameNsTab[i]) + 9, 1);
                strcpy(tmp, "default:");
                strcpy(&tmp[8], (const char *)nodeNameNsTab[i]);

                free(nodeNameNsTab[i]);
                nodeNameNsTab[i] = tmp;
            }
        }


        length = nb_tab;
        
        for(i = 0; i < nb_tab; ++i)
        {
            length += strlen(nodeNameNsTab[i]);
            
        }
        
        xpath  = (char *)calloc(length + 3, 1);
        
        strcpy(xpath, "//");
        
        for(i = 0; i < nb_tab; ++i)
        {
            if(i)
                strncat(xpath, "/", 1);
            strcat(xpath, (const char *)nodeNameNsTab[i]);
            free(nodeNameNsTab[i]);
        }
        
        free(nodeNameNsTab);
        
        xpathExpr = (xmlChar *)xpath;
    }
    else
    {
        xpathExpr = (xmlChar *) xpathSearchString;
    }
    
#ifdef DEBUG
    printf("getXmlInfo : xpathExpr: %s\n", xpathExpr);
#endif
    
    /* evaluate the XPath expression in the given context */
    result  = xmlXPathEvalExpression(xpathExpr, context);
    nodeSet = result->nodesetval;

    /* free allocated memory if xpathExpr was computed */
    if (xpathExpr != (xmlChar *) xpathSearchString)
        free(xpathExpr);
    
    if(xmlXPathNodeSetIsEmpty(nodeSet))
    {
#ifdef DEBUG
      printf("getXmlInfo : No result here ! %d\n", EXIT_NOTFOUND);
#endif
      *xpathResultString = NULL;
      xmlXPathFreeObject(result);
      xmlXPathFreeContext(context);

      return EXIT_NOTFOUND;
    }
    else
    {
      curNode = nodeSet->nodeTab;
      *xpathResultString = (char*) xmlNodeListGetString(doc, (*curNode)->children, 1);
#ifdef DEBUG
      printf("getXmlInfo : xpathResultString: %s\n", *xpathResultString);
#endif     
      xmlXPathFreeObject(result);
      xmlXPathFreeContext(context);

      return EXIT_FOUND;
    }
    
}  /* end getXmlInfo */