/alps/pcitool

 In case the performance is not good enough, please consider the following : no more configuration file indicating where the files required are, hard code of formulas, and go to complete non evolutive code : get 1 access to xml file and context, and then make recursive descent to get all you need(investigation of libxml2 source code would be so needed to prove it's better to go recursive than just xpath).

 */

#define _XOPEN_SOURCE 700

#include "xml.h"

#include "error.h"

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include "pci.h"

#include "bank.h"

#include "register.h"

#include <libxml/parser.h>

#include <libxml/xpath.h>

#include <libxml/xpathInternals.h>

#include <dirent.h>

#include <errno.h>

 

 * this function takes a context from an AST and an XPath expression, to produce an object containing the nodes corresponding to the xpath expression

 * @param[in] doc the AST of the xml file

 * @param[in] xpath the xpath expression that will be evaluated

 */

static xmlXPathObjectPtr

        xmlXPathObjectPtr result;

        result=xmlXPathEvalExpression(xpath, doc); /**<the creation of the resulting object*/

        if(result==NULL){

        }

        

        if(xmlXPathNodeSetIsEmpty(result->nodesetval)){

        }

        

        return result;

}

 

 */

}

 

 

 * function to validate the xml file against the xsd

 * @param[in] xml_filename path to the xml file

 * @param[in] xsd_filename path to the xsd file

 */

static int

{

xmlDocPtr doc;

xmlSchemaPtr schema = NULL;

 * @param[in] doc the AST of the xml file, used for used lixbml functions

 */

static void

                

    char* ptr;

    xmlNodePtr cur;

    xmlChar *value;

 

    cur=mynode->children; /** we place ourselves in the childrens of the bank node*/

 

      /** we get each time the name of the node, corresponding to one property, and the value of the node*/

      value=xmlNodeListGetString(doc,cur->children,1);

        

 

            mybank->size=(size_t)strtol((char*)value,&ptr,0);

        

            mybank->read_addr=(uintptr_t)strtol((char*)value,&ptr,0);

 

              mybank->write_addr=(uintptr_t)strtol((char*)value,&ptr,0);

        

            mybank->access=(uint8_t)strtol((char*)value,&ptr,0);

        

              mybank->endianess=PCILIB_LITTLE_ENDIAN;

              mybank->endianess=PCILIB_BIG_ENDIAN;

              mybank->endianess=PCILIB_HOST_ENDIAN;

            }           

            mybank->raw_endianess=mybank->endianess;

          

            mybank->format=(char*)value;

 

              mybank->name=(char*)value;

    

                mybank->description=(char*)value;

        }

 

    cur=cur->next;

    }

}

                  

        

pcilib_xml_initialize_banks(pcilib_t* pci,xmlDocPtr doc){

        pcilib_register_bank_description_t mybank;

 

        xmlNodePtr mynode;      

        xmlXPathContextPtr context;

        int i;

 

        mynode=malloc(sizeof(xmlNode));

        /** we get the bank nodes using xpath expression*/

 

 

        /** for each of the bank nodes, we create the associated structure, and  push it in the pcilib environnement*/

          pcilib_add_register_banks(pci,1,&mybank);

        }

 

 

}

 

/** pcilib_xml_registers_compare

 * @param a one hypothetic register

 * @param b one other hypothetic register

 */

static int

pcilib_xml_compare_registers(void const *a, void const *b){

 

 

/** pcilib_xml_arrange_registers

 * @param[in,out] registers the list of registers in : not ranged out: ranged.

 * @param[in] size the number of registers. 

 */

 * @param[in] doc the AST of the xml file, required for some ibxml2 sub-fonctions

 * @param[in] mynode the xml node to create register from

 */

                

    char* ptr;

    xmlNodePtr cur;

    int i=0;

 

    /**we get the children of the register xml nodes, that contains the properties for it*/

        /* we iterate throug each children to get the associated property

            note :the use of strtol permits to get as well hexadecimal and decimal values

                */

                myregister->addr=(pcilib_register_addr_t)strtol((char*)value,&ptr,0);

 

                myregister->offset=(pcilib_register_size_t)strtol((char*)value,&ptr,0);

 

                myregister->bits=(pcilib_register_size_t)strtol((char*)value,&ptr,0);

 

                myregister->defvalue=(pcilib_register_value_t)strtol((char*)value,&ptr,0);

 

              myregister->rwmask=PCILIB_REGISTER_ALL_BITS;

              myregister->rwmask=0;

            }else{

              myregister->rwmask=(pcilib_register_value_t)strtol((char*)value,&ptr,0);

            }

 

            myregister->mode=PCILIB_REGISTER_R;

            myregister->mode=PCILIB_REGISTER_W;

            myregister->mode=PCILIB_REGISTER_RW;

            myregister->mode=PCILIB_REGISTER_W;

            myregister->mode=PCILIB_REGISTER_RW1C;

            myregister->mode=PCILIB_REGISTER_W1C;

          }

 

          myregister->name=(char*)value;

 

          /* not implemented yet*/        //      myregister->value_min=(pcilib_register_value_t)strtol((char*)value,&ptr,0);

 

          /* not implemented yet*/        //      myregister->value_max=(pcilib_register_value_t)strtol((char*)value,&ptr,0);   

 

          i++;

          myregister->description=(char*)value;

        }

    

 

    /** we then get properties that can not be parsed as the previous ones*/

          myregister->type=PCILIB_REGISTER_STANDARD;

          myregister->type=PCILIB_REGISTER_BITS;

  /* not implemented yet*/        myregister->type=PCILIB_REGISTER_FIFO;

        }

}       

 

/** pcilib_xml_initialize_registers

 *

 * this function create a list of registers from an abstract syntax tree

 *

 * @param[in] doc the xpath context of the xml file.

 * @param[in] pci the pcilib_t struct running, that will get filled

 */

void pcilib_xml_initialize_registers(pcilib_t* pci,xmlDocPtr doc){

        

        xmlNodePtr mynode;      

        xmlXPathContextPtr context;

        pcilib_register_description_t *registers=NULL;

        pcilib_register_description_t myregister;

        int i,j;

 

        

        /** we first get the nodes of standard and bits registers*/

        else return;

        

                

        /** we then iterate through standard registers nodes to create registers structures*/

                registers[i]=myregister;

        }

        

        j=i;

        /** we then iterate through bits  registers nodes to create registers structures*/

                registers[i+j]=myregister;

        }

        

        /**we arrange the register for them to be well placed for pci-l*/

        /**we fille the pcilib_t struct*/

}

 

 

/** pcilib_init_xml

 * this function will initialize the registers and banks from the xml files

 * @param[in,out] ctx the pciilib_t running that gets filled with structures

 */

 

    char *path,*pwd, **line, *line_xsd=NULL;

    int i=1,k;

    xmlDocPtr* docs;

    }

    

    /** we then open the directory corresponding to the ctx model*/

    if((rep=opendir(pwd))==NULL){

      pcilib_warning("could not open the directory for xml files: error %i\n",errno);

      return 1;

    /** for each xml file, we validate it, and get the registers and the banks*/

    docs=malloc((i-1)*sizeof(xmlDocPtr));

    for(k=0;k<i-1;k++){

      }

    }  

    free(pwd);

    free(line);

    free(line_xsd);

 

    return 0;

}