source: soft/giet_vm/giet_xml/xml_parser.c @ 317

//////////////////////////////////////////////////////////////////////////////////////
// File     : xml_parser.c
// Date     : 14/04/2012
// Author   : alain greiner
// Copyright (c) UPMC-LIP6
///////////////////////////////////////////////////////////////////////////////////////
// This program translate a "map.xml" source file to a binary file "map.bin" that 
// can be directly loaded in memory and used by the GIET-VM operating system.
//
// This map.xml file contains :
// 1) the multi-cluster/multi-processors hardware architecture description
// 2) the various multi-threaded software applications
// 3) the mapping directives bor both the tasks and the virtual segments.
// The corresponding C structures are defined in the "mapping_info.h" file.
// 
// This parser also generates the "hard_config.h" and the "giet_vsegs.ld" files,
// required  to compile the GIET-VM code. 
///////////////////////////////////////////////////////////////////////////////////////

#include  <stdlib.h>
#include  <fcntl.h>
#include  <sys/types.h>
#include  <sys/stat.h>
#include  <unistd.h>
#include  <stdio.h>
#include  <string.h>
#include  <assert.h>
#include  <libxml/xmlreader.h>
#include  <mapping_info.h>
#include  <irq_handler.h>

#define MAX_CLUSTERS   1024
#define MAX_PSEGS      4096
#define MAX_VSPACES    1024
#define MAX_TASKS      4096
#define MAX_MWMRS      4096
#define MAX_VSEGS      4096
#define MAX_VOBJS      8192
#define MAX_PROCS      1024
#define MAX_IRQS       8192
#define MAX_COPROCS    4096
#define MAX_CP_PORTS   8192
#define MAX_PERIPHS    8192

#define XML_PARSER_DEBUG  0

///////////////////////////////////////////////////////////////////////////////////
//     global variables used to store and index the data structures
///////////////////////////////////////////////////////////////////////////////////

mapping_header_t *   header;
mapping_cluster_t *  cluster[MAX_CLUSTERS];  // cluster array
mapping_pseg_t *     pseg[MAX_PSEGS];        // pseg array
mapping_vspace_t *   vspace[MAX_VSPACES];    // vspace array
mapping_vseg_t *     vseg[MAX_VSEGS];        // vseg array
mapping_vobj_t *     vobj[MAX_VOBJS];        // vobj array
mapping_task_t *     task[MAX_TASKS];        // task array
mapping_proc_t *     proc[MAX_PROCS];        // proc array
mapping_irq_t *      irq[MAX_IRQS];          // irq array
mapping_coproc_t *   coproc[MAX_COPROCS];    // coproc array
mapping_cp_port_t *  cp_port[MAX_CP_PORTS];  // coproc port array
mapping_periph_t *   periph[MAX_PERIPHS];    // peripheral array

// Index for the various arrays

unsigned int cluster_index  = 0;
unsigned int vspace_index = 0;
unsigned int global_index = 0;
unsigned int pseg_index = 0;        

unsigned int proc_index = 0;
unsigned int proc_loc_index = 0;

unsigned int irq_index = 0;
unsigned int irq_loc_index  = 0;

unsigned int coproc_index = 0;
unsigned int coproc_loc_index = 0;

unsigned int cp_port_index = 0;
unsigned int cp_port_loc_index = 0;

unsigned int periph_index = 0;
unsigned int periph_loc_index = 0;

unsigned int vseg_index = 0;
unsigned int vseg_loc_index = 0;

unsigned int task_index = 0;
unsigned int task_loc_index = 0;

unsigned int vobj_index = 0;
unsigned int vobj_loc_index = 0;
unsigned int vobj_count = 0;


//////////////////////////////
// for replicated peripheral
//////////////////////////////
char found_timer = 0;
char found_icu   = 0;
char found_xcu   = 0;
char found_dma   = 0;
char found_mmc   = 0;

////////////////////////////////////////////////////////////////////////
// These variables are used to generate the hard_config.h file.
////////////////////////////////////////////////////////////////////////

unsigned int total_procs      = 0; // total number of processors
unsigned int nb_procs_max     = 0; // max number of processors per cluster
unsigned int nb_tasks_max     = 0; // max number of tasks (in all vspaces)

unsigned int tim_channels     = 0; // number of user timers  (per cluster)
unsigned int dma_channels     = 0; // number of DMA channels (per cluster)

unsigned int tty_channels     = 0; // number of TTY channels
unsigned int ioc_channels     = 0; // number of HBA channels
unsigned int nic_channels     = 0; // number of NIC channels
unsigned int cma_channels     = 0; // number of CMA channels 
unsigned int pic_channels     = 0; // number of PIC channels

unsigned int use_iob          = 0; // using IOB component
unsigned int use_pic          = 0; // using PIC component
unsigned int use_xcu          = 0; // using XCU (not ICU)
unsigned int use_fbf          = 0; // using Frame Buffer 

// These variables define the IOC peripheral subtype

unsigned int use_hba          = 0; // using SoClib AHCI controller
unsigned int use_bdv          = 0; // using SoCLIB block device controller
unsigned int use_spi          = 0; // using SDCard-SPI

////////////////////////////////////////////////////////////////
// These variables are used to generate the giet_vseg.ld file
////////////////////////////////////////////////////////////////

unsigned int periph_vbase_array[PERIPH_TYPE_MAX_VALUE] 
         = { [0 ... (PERIPH_TYPE_MAX_VALUE - 1)] = 0xFFFFFFFF };

//////////////////////////////////////////////////////////////////////
// This arrray is useful to build a temporary list of vobj references. 
// The struct vobj_ref_s is formed by a vspace_name and a vobj_name.
// This array is used to set the attribute vobj_id of a cp_port
// once all the vspace have been parsed.
/////////////////////////////////////////////////////////////////////
typedef struct vobj_ref_s 
{
    char vspace_name[32];
    char vobj_name[32];
} vobj_ref_t;

vobj_ref_t * cp_port_vobj_ref[MAX_CP_PORTS];    


//////////////////////////////////////////////////
unsigned int getIntValue( xmlTextReaderPtr reader, 
                          const char * attributeName, 
                          unsigned int * ok) 
{
    unsigned int value = 0;
    unsigned int i;
    char c;

    char * string = (char *) xmlTextReaderGetAttribute(reader, 
                                (const xmlChar *) attributeName);

    if (string == NULL) 
    {
        // missing argument
        *ok = 0;
        return 0;
    }
    else 
    {
        if ((string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X'))) 
        {
            // Hexa
            for (i = 2 ; (string[i] != 0) && (i < 10) ; i++) 
            {
                c = string[i];
                if      ((c >= '0') && (c <= '9')) { value = (value << 4) + string[i] - 48; }
                else if ((c >= 'a') && (c <= 'f')) { value = (value << 4) + string[i] - 87; }
                else if ((c >= 'A') && (c <= 'F')) { value = (value << 4) + string[i] - 55; }
                else 
                {
                    *ok = 0;
                    return 0;
                }
            }
        }
        else 
        {
            // Decimal
            for (i = 0; (string[i] != 0) && (i < 9); i++) 
            {
                c = string[i];
                if ((c >= '0') && (c <= '9')) value = (value * 10) + string[i] - 48;
                else 
                {
                    *ok = 0;
                    return 0;
                }
            }
        }
        *ok = 1;
        return value; 
    }
} // end getIntValue()

////////////////////////////////////////////////
paddr_t getPaddrValue( xmlTextReaderPtr reader, 
                       const char * attributeName, 
                       unsigned int * ok) 
{
    paddr_t value = 0;
    unsigned int i;
    char c;

    char * string = (char *) xmlTextReaderGetAttribute(reader, 
                                (const xmlChar *) attributeName);

    if (string == NULL) 
    {
        // missing argument
        *ok = 0;
        return 0;
    }
    else 
    {
        if ((string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X'))) 
        {
            // Hexa
            for (i = 2 ; (string[i] != 0) && (i < 18) ; i++) 
            {
                c = string[i];
                if      ((c >= '0') && (c <= '9')) { value = (value << 4) + string[i] - 48; }
                else if ((c >= 'a') && (c <= 'f')) { value = (value << 4) + string[i] - 87; }
                else if ((c >= 'A') && (c <= 'F')) { value = (value << 4) + string[i] - 55; }
                else 
                {
                    *ok = 0;
                    return 0;
                }
            }
        }
        else 
        {
            // Decimal not supported for paddr_t
            *ok = 0;
            return 0;
        }
        *ok = 1;
        return value; 
    }
} // end getPaddrValue()

////////////////////////////////////////////////
char * getStringValue( xmlTextReaderPtr reader, 
                       const char * attributeName, 
                       unsigned int * ok ) 
{
    char * string = (char *) xmlTextReaderGetAttribute(reader, 
                               (const xmlChar *) attributeName);


    if (string == NULL) 
    {
        // missing argument
        *ok = 0;
        return NULL;
    }
    else 
    {
        //we read only string smaller than 32 byte
        if (strlen(string) > 32) 
        {
            printf("[XML ERROR] all strings must be less than 32 bytes\n");
            exit(1);
        }

        *ok = 1;
        return string;
    }
} // end getStringValue()

///////////////////////////////////////////////////////////////////////////////////
// This function set the vbase addresses for all peripheral types, in order
// to generate the ldscript file, that contains one single virtual address
// for peripherals replicated in all clusters, and one virtual addresses for
// each non replicated peripheral type.
// 
// It makes the following checks on the virtual addresses:
// 
// - For replicated peripherals the virtual base address must be:
//   vbase = seg_type_base & 0XFF000000 + (cluster_xy * increment) & 0x00FF0000
//
// - For non-replicated peripherals, the cluster index must be cluster_io.
///////////////////////////////////////////////////////////////////////////////////
void set_periph_vbase_array()
{
    unsigned int vseg_id;      // vseg global index
    unsigned int periph_id;    // periph global index
    unsigned int pseg_id;      // pseg global index
    unsigned int cluster_id;   // cluster linear index
    unsigned int cluster_xy;   // cluster topological index
    unsigned int type;         // peripheral type 

    unsigned int type_mask    = 0xFF000000;
    unsigned int cluster_mask = 0x00FF0000;

#if XML_PARSER_DEBUG
printf("\n set peripherals vbase array\n");
#endif

    // scan all vsegs
    for (vseg_id = 0 ; vseg_id < header->vsegs ; vseg_id++)
    {
        // keep only vseg corresponding to a periph        
        if ( vobj[vseg[vseg_id]->vobj_offset]->type == VOBJ_TYPE_PERI )
        {
            pseg_id = vseg[vseg_id]->psegid; 

#if XML_PARSER_DEBUG
printf(" - found vseg %s associated to pseg %d", vseg[vseg_id]->name, pseg_id );
#endif

            // scan all periphs to retrieve peripheral type (same psegid)
            for ( periph_id = 0 ; periph_id < header->periphs ; periph_id++)
            {
                if( periph[periph_id]->psegid == pseg_id ) // matching !!!
                {
                    cluster_id = pseg[pseg_id]->clusterid;
                    type       = periph[periph_id]->type;

#if XML_PARSER_DEBUG
printf(" / matching periph type %d\n", type );
#endif

                    if ( (type == PERIPH_TYPE_DMA) ||
                         (type == PERIPH_TYPE_MMC) ||
                         (type == PERIPH_TYPE_ICU) ||
                         (type == PERIPH_TYPE_XCU) ||
                         (type == PERIPH_TYPE_TIM) )   // replicated peripheral
                    {
                        cluster_xy = (cluster[cluster_id]->x << header->y_width) +
                                      cluster[cluster_id]->y;

                        if( (vseg[vseg_id]->vbase & cluster_mask) != 
                            (header->increment * cluster_xy) )
                        {
                            printf("[XML ERROR] All replicated peripherals "
                                   "must have cluster bits = cluster_xy * increment\n");
                            printf("periph index = %d / periph type = %d / vbase = %x\n",
                                    periph_id, type, vseg[vseg_id]->vbase);
                            exit(1);
                        }
                        else if ( periph_vbase_array[type] == 0xFFFFFFFF ) // vbase not set
                        {
                            periph_vbase_array[type] = vseg[vseg_id]->vbase & type_mask;    
                        }
                        else if ((vseg[vseg_id]->vbase & type_mask) != (periph_vbase_array[type]))
                        {
                            printf("[XML ERROR] All peripherals with same type"
                                   " should share the same 8 MSB bits in vbase address\n");
                            printf("periph index = %d / periph type = %d / vbase = %x\n",
                                    periph_id, type, vseg[vseg_id]->vbase);
                            exit(1);
                        }
                    }
                    else                               // non replicated peripheral
                    {
                        if ( (cluster[cluster_id]->x == header->x_io) &&  
                             (cluster[cluster_id]->y == header->y_io) )   
                        {
                            periph_vbase_array[type] = vseg[vseg_id]->vbase;    
                        }
                        else
                        {
                            printf("[XML ERROR] Non replicated peripherals must be in cluster_io\n");
                            printf(" periph index = %d / periph type = %d / vbase = %x"
                                   " / pseg index = %d / cluster index = %d\n",
                                    periph_id, type, vseg[vseg_id]->vbase, pseg_id, cluster_id);
                            exit(1);
                        }
                    }
                }
            }
        }    
    }
}  // end set_periph_vbase_array()

///////////////////////////////////////////////////////////////
int getClusterId( unsigned int x, unsigned int y )
{
    // associative search of cluster index
    unsigned int cluster_id;

    for( cluster_id = 0 ; cluster_id < (header->x_size * header->y_size) ; cluster_id++ )
    {
        if( (cluster[cluster_id]->x == x) && (cluster[cluster_id]->y == y) )
        {
            return cluster_id;
        }
    }
    return -1;
}  // end getClusterId()

///////////////////////////////////////////////////////////////
int getPsegId(unsigned int x, unsigned int y, char * pseg_name) 
{
    int cluster_id = getClusterId( x, y );

    if ( cluster_id == -1 ) return -1;

    // associative search for pseg index
    unsigned int pseg_id;
    unsigned int pseg_min = cluster[cluster_id]->pseg_offset;
    unsigned int pseg_max = pseg_min + cluster[cluster_id]->psegs;

    for (pseg_id = pseg_min; pseg_id < pseg_max; pseg_id++) 
    {
        if (strcmp(pseg[pseg_id]->name, pseg_name) == 0) 
        {
            return pseg_id;
        }
    }
    return -1;
}  // end getPsegId()

///////////////////////////////////
int getVspaceId(char * vspace_name) 
{
    unsigned int vspace_id;

    for (vspace_id = 0; vspace_id < vspace_index; vspace_id++) 
    {
        if (strcmp(vspace[vspace_id]->name, vspace_name) == 0) 
        {
            return vspace_id;
        }
    }
    return -1;
}

///////////////////////////////////////////////////////////////////////////////////
int getVobjLocId(unsigned int vspace_id, char * vobj_name, unsigned int vspace_max) 
{
    unsigned int vobj_id;
    unsigned int vobj_min = vspace[vspace_id]->vobj_offset;
    unsigned int vobj_max = vobj_min + vspace_max;

    for (vobj_id = vobj_min; vobj_id < vobj_max; vobj_id++) 
    {
        if (strcmp(vobj[vobj_id]->name, vobj_name) == 0) return (vobj_id - vobj_min);
    }
    return -1;
}

///////////////////////////////////////////////////////////
unsigned int alignTo( unsigned int value, unsigned int pow2 )
{
    unsigned int mask = (1 << pow2) - 1;
    return ( (value + mask) & ~mask);
}

////////////////////
void setVsegLength()
{
    // for a given vseg identified vseg_index 
    // scan all contained vobjs to compute the vseg lenth

    unsigned int vobj_id;
    unsigned int cur_length = 0;

    unsigned int first = vseg[vseg_index]->vobj_offset;
    unsigned int last  = first + vseg[vseg_index]->vobjs;

    for ( vobj_id = first ; vobj_id < last ; vobj_id++ ) 
    {
        if (vobj[vobj_id]->align)
        {
            cur_length = alignTo( cur_length, vobj[vobj_id]->align );
        }
        cur_length += vobj[vobj_id]->length;
    }
    vseg[vseg_index]->length = alignTo( cur_length, 12 );
}

///////////////////////
void checkVsegOverlap()
{
    // for a given vseg identified by vseg_index, 
    // check overlap with all vsegs in same vspace,
    // and check overlap with all global vsegs.

    unsigned int vseg_id;
    unsigned int prev_vbase;                          // previous vseg vbase
    unsigned int prev_length;                         // previous vseg length

    unsigned int vbase  = vseg[vseg_index]->vbase;    // new vseg vbase
    unsigned int length = vseg[vseg_index]->length;   // new vseg length
  
    // checking overlap with other vsegs in same vspace
    if ( header->vspaces > 0 )
    {
        unsigned int first = vspace[vspace_index]->vseg_offset;   
        unsigned int last  = vseg_index;
    
        for( vseg_id = first ; vseg_id < last ; vseg_id++ )
        {
            prev_vbase  = vseg[vseg_id]->vbase;
            prev_length = vseg[vseg_id]->length;
            if ( ((vbase + length) > prev_vbase) && ((prev_vbase + prev_length) > vbase) )
            { 
                printf("[XML ERROR] vseg %s in vspace %s overlaps other vseg %s\n",
                vseg[vseg_index]->name, vspace[vspace_index]->name, vseg[vseg_id]->name );
                exit(1);
            }
        }
    }

    // checking overlap with existing global vsegs
    for ( vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ )
    {
        prev_vbase  = vseg[vseg_id]->vbase;
        prev_length = vseg[vseg_id]->length;
        if ( ((vbase + length) > prev_vbase) && ((prev_vbase + prev_length) > vbase) )
        { 
            printf("[XML ERROR] vseg %s in vspace %s overlaps global vseg %s\n",
            vseg[vseg_index]->name, vspace[vspace_index]->name, vseg[vseg_id]->name );
            exit(1);
        }
    }
}

//////////////////////////////////////
void taskNode(xmlTextReaderPtr reader) 
{
    unsigned int ok;
    unsigned int value;
    unsigned int x,y;
    char * str;

    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

    if (task_index >= MAX_TASKS) 
    {
        printf("[XML ERROR] The number of tasks is larger than %d\n", MAX_TASKS);
        exit(1);
    }

#if XML_PARSER_DEBUG
printf("   task %d\n", task_loc_index);
#endif

    task[task_index] = (mapping_task_t *) malloc(sizeof(mapping_task_t));

    ////////// get name attribute
    str = getStringValue(reader, "name", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("      name      = %s\n", str);
#endif
        strncpy( task[task_index]->name, str, 31 );
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <name> attribute for task (%d,%d)\n", 
                vspace_index, task_loc_index);
        exit(1);
    }

    ///////// get trdid attribute (optional)
    task[task_index]->trdid = getIntValue(reader, "trdid", &ok);
#if XML_PARSER_DEBUG
printf("      trdid     = %d\n", x);
#endif
    if ( !ok ) 
    {
        task[task_index]->trdid = task_loc_index;
    }  

    ///////// get x coordinate 
    x = getIntValue(reader, "x", &ok);
#if XML_PARSER_DEBUG
printf("      x         = %d\n", x);
#endif
    if ( !(ok && (x < header->x_size)) ) 
    {
        printf("[XML ERROR] illegal or missing < x > attribute for task (%d,%d)\n",
                vspace_index, task_loc_index);
        exit(1);
    }  

    ///////// get y coordinate 
    y = getIntValue(reader, "y", &ok);
#if XML_PARSER_DEBUG
printf("      y         = %d\n", y);
#endif
    if ( !(ok && (y < header->y_size)) ) 
    {
        printf("[XML ERROR] illegal or missing < y > attribute for task (%d,%d)\n",
                vspace_index, task_loc_index);
        exit(1);
    }  

    ///////// set clusterid attribute
    int index = getClusterId( x, y );
#if XML_PARSER_DEBUG
printf("      clusterid = %d\n", index);
#endif
    if( index >= 0 )
    {
        task[task_index]->clusterid = index;
    }
    else
    {
        printf("[XML ERROR] <clusterid> not found for task (%d,%d)\n",
                vspace_index, task_loc_index);
        exit(1);
    }

    ////////// get p attribute
    value = getIntValue(reader, "p", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("      proclocid = %x\n", value);
#endif
        if (value >= cluster[task[task_index]->clusterid]->procs) 
        {
            printf("[XML ERROR] <proclocid> too large for task (%d,%d)\n",
                    vspace_index, task_loc_index);
            exit(1);
        }
        task[task_index]->proclocid = value;
    }  
    else 
    {
        printf("[XML ERROR] illegal or missing <p> attribute for task (%d,%d)\n", 
                vspace_index, task_loc_index);
        exit(1);
    }

    ////////// get stackname attribute
    str = getStringValue(reader, "stackname" , &ok);
    if (ok) 
    {
        int index = getVobjLocId(vspace_index, str , vobj_loc_index);
        if (index >= 0) 
        {
#if XML_PARSER_DEBUG
printf("      stackname = %s\n", str);
printf("      stackid   = %d\n", index);
#endif
            task[task_index]->stack_vobjid = index;
        }
        else 
        {
            printf("[XML ERROR] illegal or missing <stackname> for task (%d,%d)\n", 
                    vspace_index, task_loc_index);
            exit(1);
        }
    }  
    else 
    {
        printf("[XML ERROR] illegal or missing <stackname> for task (%d,%d)\n", 
                vspace_index, task_loc_index);
        exit(1);
    }

    ////////// get heap attribute
    str = getStringValue(reader, "heapname", &ok);
    if (ok) 
    {
        int index = getVobjLocId(vspace_index, str, vobj_loc_index);
        if (index >= 0) 
        {
#if XML_PARSER_DEBUG
printf("      heapname  = %s\n", str);
printf("      heapid    = %d\n", index);
#endif
            task[task_index]->heap_vobjid = index;
        }
        else 
        {
            printf("[XML ERROR] illegal or missing <heapname> for task (%d,%d)\n", 
                   vspace_index, task_loc_index);
            exit(1);
        }
    }  
    else 
    {
        task[task_index]->heap_vobjid = -1;
    }

    ////////// get startid  attribute
    value = getIntValue(reader, "startid", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("      startid   = %x\n", value);
#endif
        task[task_index]->startid = value;
    }  
    else 
    {
        printf("[XML ERROR] illegal or missing <startid> attribute for task (%d,%d)\n", 
                vspace_index, task_loc_index);
        exit(1);
    }

    /////////// get use_tty  attribute (optionnal : 0 if missing)
    value = getIntValue(reader, "usetty", &ok);
#if XML_PARSER_DEBUG
printf("      usetty = %x\n", value);
#endif
    task[task_index]->use_tty = (ok)? value : 0;

    /////////// get use_nic  attribute (optionnal : 0 if missing)
    value = getIntValue(reader, "usenic", &ok);
#if XML_PARSER_DEBUG
printf("      usenic = %x\n", value);
#endif
    task[task_index]->use_nic = (ok)? value : 0;

    /////////// get use_tim attribute (optionnal : 0 if missing)
    value = getIntValue(reader, "usetim", &ok);
#if XML_PARSER_DEBUG
printf("      usetim = %x\n", value);
#endif
    task[task_index]->use_tim = (ok)? value : 0;

    /////////// get use_hba  attribute (optionnal : 0 if missing)
    value = getIntValue(reader, "usehba", &ok);
#if XML_PARSER_DEBUG
printf("      usehba = %x\n", value);
#endif
    task[task_index]->use_hba = (ok)? value : 0;

    /////////// get usecma  attribute (optionnal : 0 if missing)
    value = getIntValue(reader, "usecma", &ok);
#if XML_PARSER_DEBUG
printf("      usecma = %x\n", value);
#endif
    task[task_index]->use_cma = (ok)? value : 0;

    task_index++;
    task_loc_index++;
} // end taskNode()

//////////////////////////////////////
void vobjNode(xmlTextReaderPtr reader) 
{
    unsigned int ok;
    unsigned int value;
    char * str;

    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

    if (vobj_index >= MAX_VOBJS) 
    {
        printf("[XML ERROR] The number of vobjs is larger than %d\n", MAX_VOBJS);
        exit(1);
    }

#if XML_PARSER_DEBUG
printf("      vobj %d\n", vobj_loc_index);
#endif

    vobj[vobj_index] = (mapping_vobj_t *) malloc(sizeof(mapping_vobj_t));

    ///////// get name attribute
    str = getStringValue(reader, "name", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("        name = %s\n", str);
#endif
        strncpy(vobj[vobj_index]->name, str, 31);
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <name> attribute for vobj (%d,%d)\n", 
                vseg_index, vobj_loc_index);
        exit(1);
    }

    //////// get type attribute
    str = getStringValue(reader, "type", &ok);
#if XML_PARSER_DEBUG
printf("        type = %s\n", str);
#endif

    if      (ok && (strcmp(str, "ELF")      == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_ELF;      }
    else if (ok && (strcmp(str, "PERI")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PERI;     }
    else if (ok && (strcmp(str, "BLOB")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BLOB;     }
    else if (ok && (strcmp(str, "PTAB")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_PTAB;     }
    else if (ok && (strcmp(str, "MWMR")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_MWMR;     }
    else if (ok && (strcmp(str, "LOCK")     == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_LOCK;     }
    else if (ok && (strcmp(str, "BUFFER")   == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BUFFER;   }
    else if (ok && (strcmp(str, "BARRIER")  == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_BARRIER;  }
    else if (ok && (strcmp(str, "CONST")    == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_CONST;    }
    else if (ok && (strcmp(str, "MEMSPACE") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_MEMSPACE; }
    else if (ok && (strcmp(str, "SCHED")    == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_SCHED;    }
    else 
    {
        printf("[XML ERROR] illegal or missing <type> attribute for vobj (%d,%d)\n", 
                vspace_index, vobj_loc_index);
        exit(1);
    }
    // some more checking
    if ( (vobj[vobj_index]->type == VOBJ_TYPE_ELF) ||
         (vobj[vobj_index]->type == VOBJ_TYPE_PERI) )
    {
        assert( (vobj_count == 0) && 
        "[XML ERROR] an ELF or PERI vobj must be alone in a vseg");
    }
        

    ////////// get length attribute 
    value = getIntValue(reader, "length", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("        length = %x\n", value);
#endif
        vobj[vobj_index]->length = value;
    }  
    else {
        printf("[XML ERROR] illegal or missing <length> attribute for vobj (%d,%d)\n", 
                vspace_index, vobj_loc_index);
        exit(1);
    }

    ////////// get align attribute (optional : 0 if missing)
    value = getIntValue(reader, "align", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("        align = %d\n", value);
#endif
        vobj[vobj_index]->align = value;
    }  
    else 
    {
        vobj[vobj_index]->align = 0;
    }

    ////////// get binpath attribute (optional : "" if missing)
    str = getStringValue(reader, "binpath", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("        binpath = %s\n", str);
#endif
        strncpy(vobj[vobj_index]->binpath, str, 63);
    }  
    else 
    {
        vobj[vobj_index]->binpath[0] = 0;
    }

    ////////// get init attribute (optional, mandatory for mwmr and barrier)
    value = getIntValue(reader, "init", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("        init  = %d\n", value);
#endif
        vobj[vobj_index]->init = value;
    }  
    else 
    {
        if ((vobj[vobj_index]->type == VOBJ_TYPE_MWMR) || 
            (vobj[vobj_index]->type == VOBJ_TYPE_BARRIER) ||
            (vobj[vobj_index]->type == VOBJ_TYPE_CONST)) 
        {
            printf("[XML ERROR] illegal or missing <value> attribute for vobj (%d,%d). \
                    All MWMR or BARRIER or CONST vobj must have a init value \n", 
                    vspace_index, vobj_loc_index);
            exit(1);
        }
        vobj[vobj_index]->init = 0;
    }

    vobj_index++;
    vobj_count++;
    vobj_loc_index++;
} // end vobjNode()

//////////////////////////////////////
void vsegNode(xmlTextReaderPtr reader) 
{
    unsigned int ok;
    unsigned int value;
    unsigned int x,y;
    char * str;

    vobj_count = 0;

    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

    if (vseg_index >= MAX_VSEGS) 
    {
        printf("[XML ERROR] The number of vsegs is larger than %d\n", MAX_VSEGS);
        exit(1);
    }

#if XML_PARSER_DEBUG
printf("    vseg %d\n", vseg_loc_index);
#endif

    vseg[vseg_index] = (mapping_vseg_t *) malloc(sizeof(mapping_vseg_t));

    ////////// set vobj_offset attribute
    vseg[vseg_index]->vobj_offset = vobj_index;

#if XML_PARSER_DEBUG
printf("      vobj_offset = %d\n", vobj_index);
#endif

    ///////// set mapped attribute
    vseg[vseg_index]->mapped = 0;

    //////// set next_vseg attribute
    vseg[vseg_index]->next_vseg = 0;
  
    ///////// get name attribute
    str = getStringValue(reader, "name", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("      name        = %s\n", str);
#endif
        strncpy( vseg[vseg_index]->name, str, 31);
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <name> attribute for vseg (%d,%d)\n", 
                vspace_index, vseg_loc_index);
        exit(1);
    }

    ////////// get ident attribute (optional : 0 if missing)
    value = getIntValue(reader, "ident", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("      ident       = %d\n", value);
#endif
        vseg[vseg_index]->ident = value;
    }  
    else 
    {
        vseg[vseg_index]->ident = 0;
    }

    /////////// get vbase attribute
    value = getIntValue(reader, "vbase", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("      vbase       = 0x%x\n", value);
#endif
        vseg[vseg_index]->vbase = value;
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <vbase> attribute for vseg (%d,%d)\n", 
                vspace_index, vseg_loc_index);
        exit(1);
    }

    ////////// get x coordinate
    x = getIntValue(reader, "x", &ok);
#if XML_PARSER_DEBUG
printf("      x           = %d\n", x);
#endif
    if ( !(ok && (x < header->x_size)) ) 
    {
        printf("[XML ERROR] illegal or missing < x > attribute for vseg %d\n", 
                vseg_loc_index);
        exit(1);
    }

    ////////// get y coordinate
    y = getIntValue(reader, "y", &ok);
#if XML_PARSER_DEBUG
printf("      y           = %d\n", y);
#endif
    if ( !(ok && (y < header->y_size)) ) 
    {
        printf("[XML ERROR] illegal or missing < y > attribute for vseg %d\n", 
                vseg_loc_index);
        exit(1);
    }

    ///////// get psegname attribute
    str = getStringValue(reader, "psegname", &ok);
#if XML_PARSER_DEBUG
printf("      psegname    = %s\n", str);
#endif
    if (ok == 0) 
    {
        printf("[XML ERROR] illegal or missing <psegname> for vseg %d\n", 
                vseg_loc_index);
        exit(1);
    }

    /////////// set psegid field
    int psegid = getPsegId( x, y, str );
#if XML_PARSER_DEBUG
printf("      psegid      = %d\n", psegid);
#endif
    if (psegid >= 0) 
    {
        vseg[vseg_index]->psegid = psegid;
    }
    else 
    {
        printf("[XML ERROR] pseg not found for vseg %d / x = %d / y = %d / psegname = %s\n", 
                vseg_loc_index, x, y, str );
        exit(1);
    }  

    //////// get mode attribute
    str = getStringValue(reader, "mode", &ok);
#if XML_PARSER_DEBUG
printf("      mode        = %s\n", str);
#endif
    if      (ok && (strcmp(str, "CXWU") == 0)) { vseg[vseg_index]->mode = 0xF; }
    else if (ok && (strcmp(str, "CXW_") == 0)) { vseg[vseg_index]->mode = 0xE; }
    else if (ok && (strcmp(str, "CX_U") == 0)) { vseg[vseg_index]->mode = 0xD; }
    else if (ok && (strcmp(str, "CX__") == 0)) { vseg[vseg_index]->mode = 0xC; }
    else if (ok && (strcmp(str, "C_WU") == 0)) { vseg[vseg_index]->mode = 0xB; }
    else if (ok && (strcmp(str, "C_W_") == 0)) { vseg[vseg_index]->mode = 0xA; }
    else if (ok && (strcmp(str, "C__U") == 0)) { vseg[vseg_index]->mode = 0x9; }
    else if (ok && (strcmp(str, "C___") == 0)) { vseg[vseg_index]->mode = 0x8; }
    else if (ok && (strcmp(str, "_XWU") == 0)) { vseg[vseg_index]->mode = 0x7; }
    else if (ok && (strcmp(str, "_XW_") == 0)) { vseg[vseg_index]->mode = 0x6; }
    else if (ok && (strcmp(str, "_X_U") == 0)) { vseg[vseg_index]->mode = 0x5; }
    else if (ok && (strcmp(str, "_X__") == 0)) { vseg[vseg_index]->mode = 0x4; }
    else if (ok && (strcmp(str, "__WU") == 0)) { vseg[vseg_index]->mode = 0x3; }
    else if (ok && (strcmp(str, "__W_") == 0)) { vseg[vseg_index]->mode = 0x2; }
    else if (ok && (strcmp(str, "___U") == 0)) { vseg[vseg_index]->mode = 0x1; }
    else if (ok && (strcmp(str, "____") == 0)) { vseg[vseg_index]->mode = 0x0; }
    else {
        printf("[XML ERROR] illegal or missing <mode> attribute for vseg (%d,%d)\n", 
                vspace_index, vseg_loc_index);
        exit(1);
    }

    ////////// get vobjs in vseg
    int status = xmlTextReaderRead(reader);
    while (status == 1) 
    {
        const char * tag = (const char *) xmlTextReaderConstName(reader);

        if      (strcmp(tag, "vobj")     == 0 ) { vobjNode(reader); }
        else if (strcmp(tag, "#text"  )  == 0 ) { }
        else if (strcmp(tag, "#comment") == 0 ) { }
        else if (strcmp(tag, "vseg")     == 0 ) 
        {
            vseg[vseg_index]->vobjs = vobj_count;
            setVsegLength();
            checkVsegOverlap();
            vseg_index++;
            vseg_loc_index++;
            return;
        }
        else 
        {
            printf("[XML ERROR] Unknown tag %s", tag);
            exit(1);
        }
        status = xmlTextReaderRead (reader);
    }
} // end vsegNode()

////////////////////////////////////////
void vspaceNode(xmlTextReaderPtr reader) 
{
    char * str;
    unsigned int ok;
    unsigned int nb_task_vspace = 0;

    vobj_loc_index = 0;
    vseg_loc_index = 0;
    task_loc_index = 0;

    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

#if XML_PARSER_DEBUG
printf("\n  vspace %d\n", vspace_index);
#endif

    vspace[vspace_index] = (mapping_vspace_t *) malloc(sizeof(mapping_vspace_t));
    header->vspaces      = header->vspaces + 1;

    ////////// get name attribute
    str = getStringValue(reader, "name", &ok);
    if (ok) {
#if XML_PARSER_DEBUG
printf("  name = %s\n", str);
#endif
        strncpy(vspace[vspace_index]->name, str, 31);
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <name> attribute for vspace %d\n", 
                vspace_index);
        exit(1);
    }

    ////////// set vseg_offset and task_offset attributes
    vspace[vspace_index]->vseg_offset = vseg_index;
    vspace[vspace_index]->vobj_offset = vobj_index;
    vspace[vspace_index]->task_offset = task_index;

#if XML_PARSER_DEBUG
    printf("  vseg_offset = %d\n", vseg_index);
    printf("  vobj_offset = %d\n", vobj_index);
    printf("  task_offset = %d\n", task_index);
#endif

    ////////// get startname attribute
    str = getStringValue(reader, "startname", &ok);
    if (ok) {
        //used after parsing the vobjs
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <startname> attribute for vspace %s\n", 
                vspace[vspace_index]->name);
        exit(1);
    }

    int status = xmlTextReaderRead(reader);
    while (status == 1) 
    {
        const char * tag = (const char *) xmlTextReaderConstName(reader);

        if (strcmp(tag, "vseg") == 0) 
        {
            vsegNode(reader);
        }
        else if (strcmp(tag, "task") == 0) 
        {
            taskNode(reader);
            nb_task_vspace++;
        }
        else if (strcmp(tag, "#text")    == 0) { }
        else if (strcmp(tag, "#comment") == 0) { }
        else if (strcmp(tag, "vspace")   == 0) 
        {
            vspace[vspace_index]->vobjs = vobj_loc_index; 
            vspace[vspace_index]->tasks = task_loc_index ;
            vspace[vspace_index]->vsegs = vseg_loc_index ;

            // get index of the vobj containing the start vector
            int index = getVobjLocId(vspace_index, str , vobj_loc_index);
            if (index == -1) 
            {
                printf("[XML ERROR] vobj containing start vector not found in vspace %s\n",
                        vspace[vspace_index]->name);
                exit(1);
            }
            else 
            {
                vspace[vspace_index]->start_offset = index;
#if XML_PARSER_DEBUG
                printf("      startname = %s\n", str);
                printf("      startid   = %d\n", index);
                printf("  end vspace %d\n\n", vspace_index);
#endif
            }

            // checking startid values for all tasks in vspace
            int task_id;
            int task_min = vspace[vspace_index]->task_offset;
            int task_max = task_min + vspace[vspace_index]->tasks; 
            for (task_id = task_min; task_id < task_max; task_id++) {
                if (task[task_id]->startid >= vspace[vspace_index]->tasks) 
                {
                    printf("[XML ERROR] <startid> too large for task (%d,%d)\n", 
                            vspace_index, task_id );
                    exit(1);
                }
            }

            nb_tasks_max += nb_task_vspace;
            vspace_index++;
            return;
        }
        else 
        {
            printf("[XML ERROR] Unknown tag %s", tag);
            exit(1);
        }
        status = xmlTextReaderRead(reader);
    }
} // end vspaceNode()

/////////////////////////////////////
void irqNode(xmlTextReaderPtr reader) 
{
    unsigned int ok;
    unsigned int value;
    char * str;

    unsigned int is_pic = (periph[periph_index]->type == PERIPH_TYPE_PIC);
    unsigned int is_icu = (periph[periph_index]->type == PERIPH_TYPE_ICU) ||
                          (periph[periph_index]->type == PERIPH_TYPE_XCU);

    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

    if (irq_index >= MAX_IRQS) 
    {
        printf("[XML ERROR] The number of irqs is larger than %d\n", MAX_IRQS);
    }

#if XML_PARSER_DEBUG
printf("      irq %d\n", irq_loc_index);
#endif

    irq[irq_index] = (mapping_irq_t *) malloc(sizeof(mapping_irq_t));

    ///////// get srcid attribute
    value = getIntValue(reader, "srcid", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("        srcid   = %d\n", value);
#endif
        irq[irq_index]->srcid = value;
        if (value >= 32) 
        {
            printf("[XML ERROR] IRQ <srcid> too large for periph %d in cluster %d\n",
                    cluster_index, periph_loc_index);
            exit(1);
        }
    }
    else 
    {
        printf("[XML ERROR] missing IRQ <srcid> for periph %d in cluster %d\n",
                cluster_index, periph_loc_index);
        exit(1);
    }

    ///////// get srctype attribute ... if ICU or XCU
    if ( is_icu )
    {
        str = getStringValue(reader, "srctype", &ok);
        if (ok) 
        {
#if XML_PARSER_DEBUG
printf("        srctype = %s\n", str);
#endif
            if      ( strcmp(str, "HWI") == 0 ) irq[irq_index]->srctype = IRQ_TYPE_HWI;
            else if ( strcmp(str, "WTI") == 0 ) irq[irq_index]->srctype = IRQ_TYPE_WTI;
            else if ( strcmp(str, "PTI") == 0 ) irq[irq_index]->srctype = IRQ_TYPE_PTI;
            else    
            {
                printf("[XML ERROR] illegal IRQ <srctype> for periph %d in cluster %d\n",
                       cluster_index, periph_loc_index);
                exit(1);
            }
        }
        else 
        {
            printf("[XML ERROR] missing IRQ <srctype> for periph %d in cluster %d\n",
                   cluster_index, periph_loc_index);
            exit(1);
        }
    }

    ///////// get isr attribute ... if ICU or XCU
    if ( is_icu )
    {
        str = getStringValue(reader, "isr", &ok);
        if (ok) 
        {
#if XML_PARSER_DEBUG
printf("        isr     = %s\n", str);
#endif
            if      (strcmp(str, "ISR_TICK"   ) == 0)  irq[irq_index]->isr = ISR_TICK;
            else if (strcmp(str, "ISR_BDV"    ) == 0)  irq[irq_index]->isr = ISR_BDV;
            else if (strcmp(str, "ISR_CMA"    ) == 0)  irq[irq_index]->isr = ISR_CMA;
            else if (strcmp(str, "ISR_TTY_RX" ) == 0)  irq[irq_index]->isr = ISR_TTY_RX;
            else if (strcmp(str, "ISR_TTY_TX" ) == 0)  irq[irq_index]->isr = ISR_TTY_TX;
            else if (strcmp(str, "ISR_TIMER"  ) == 0)  irq[irq_index]->isr = ISR_TIMER;
            else if (strcmp(str, "ISR_WAKUP"  ) == 0)  irq[irq_index]->isr = ISR_WAKUP;
            else if (strcmp(str, "ISR_NIC_RX" ) == 0)  irq[irq_index]->isr = ISR_NIC_RX;
            else if (strcmp(str, "ISR_NIC_TX" ) == 0)  irq[irq_index]->isr = ISR_NIC_TX;
            else if (strcmp(str, "ISR_MMC"    ) == 0)  irq[irq_index]->isr = ISR_MMC;
            else if (strcmp(str, "ISR_DEFAULT") == 0)  irq[irq_index]->isr = ISR_DEFAULT;
            else 
            {
                printf("[XML ERROR] illegal IRQ <isr> for periph %d in cluster %d\n",
                       periph_loc_index, cluster_index );
                exit(1);
            }
        }  
        else 
        {
            printf("[XML ERROR] missing IRQ <isr> for periph %d in cluster %d\n",
                    cluster_index, periph_loc_index);
            exit(1);
        }
    }

    ///////// get channel attribute (optionnal : 0 if missing)
    value = getIntValue(reader, "channel", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("        channel = %d\n", value);
#endif
        irq[irq_index]->channel = value;
    }
    else 
    {
        irq[irq_index]->channel = 0;
    }

    ///////// get dstx attribute ... if PIC
    if ( is_pic )
    {
        value = getIntValue(reader, "dstx", &ok);
        if (ok) 
        {
#if XML_PARSER_DEBUG
printf("        dstx    = %d\n", value);
#endif

            if ( value < header->x_size )
            {
                irq[irq_index]->dstx = value;
            }
            else
            {
                printf("[XML ERROR] IRQ <dstx> too large for periph %d in cluster %d\n",
                       cluster_index, periph_loc_index);
                exit(1);
            }
        }
        else 
        {
            printf("[XML ERROR] missing IRQ <dstx> for periph %d in cluster %d\n",
                   cluster_index, periph_loc_index);
            exit(1);
        }
    }

    ///////// get dsty attribute ... if PIC
    if ( is_pic )
    {
        value = getIntValue(reader, "dsty", &ok);
        if (ok) 
        {
#if XML_PARSER_DEBUG
printf("        dsty    = %d\n", value);
#endif

            if ( value < header->y_size )
            {
                irq[irq_index]->dsty = value;
            }
            else
            {
                printf("[XML ERROR] IRQ <dsty> too large for periph %d in cluster %d\n",
                       cluster_index, periph_loc_index);
                exit(1);
            }
        }
        else 
        {
            printf("[XML ERROR] missing IRQ <dsty> for periph %d in cluster %d\n",
                    cluster_index, periph_loc_index);
            exit(1);
        }
    }

    ///////// get dstid attribute
    value = getIntValue(reader, "dstid", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("        dstid   = %d\n", value);
#endif
        irq[irq_index]->dstid = value;
        if (value >= 32) 
        {
            printf("[XML ERROR] IRQ <dstid> too large for periph %d in cluster %d\n",
                    cluster_index, periph_loc_index);
            exit(1);
        }
    }
    else 
    {
        printf("[XML ERROR] missing IRQ <dstid> for periph %d in cluster %d\n",
                cluster_index, periph_loc_index);
        exit(1);
    }

    irq_index++;
    irq_loc_index++;

} // end irqNode



////////////////////////////////////////
void cpPortNode(xmlTextReaderPtr reader) 
{
    char * str;
    unsigned int ok;

    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

    if (cp_port_index >= MAX_CP_PORTS) 
    {
        printf("[XML ERROR] The number of ports (for coprocs) is larger than %d\n", 
                 MAX_CP_PORTS);
        exit(1);
    }

#if XML_PARSER_DEBUG
printf("\n  port %d\n", cp_port_index);
#endif

    cp_port[cp_port_index] = (mapping_cp_port_t *) malloc(sizeof(mapping_cp_port_t));
    cp_port_vobj_ref[cp_port_index] = (vobj_ref_t *) malloc(sizeof(vobj_ref_t));

    ///////// get direction attribute
    str = getStringValue(reader, "direction", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("      direction = %s\n", str);
#endif
        if (strcmp(str, "TO_COPROC")   ==  0) 
        {
            cp_port[cp_port_index]->direction = PORT_TO_COPROC;
        }
        else if (strcmp(str, "FROM_COPROC") ==  0) 
        {
            cp_port[cp_port_index]->direction = PORT_FROM_COPROC;
        }
        else 
        {
            printf("[XML ERROR] illegal <direction> for cp_port %d in cluster %d\n",
                    cp_port_index, cluster_index);
            exit(1);
        }
    }  
    else 
    {
        printf("[XML ERROR] missing <direction> for cp_port %d in cluster %d\n",
                cp_port_index, cluster_index);
        exit(1);
    }

    /////////// get vspacename attribute 
    str = getStringValue(reader, "vspacename", &ok);
#if XML_PARSER_DEBUG
printf("      vspacename = %s\n", str);
#endif
    if (ok) 
    {
        strncpy(cp_port_vobj_ref[cp_port_index]->vspace_name, str, 31);
    }
    else 
    {
        printf("[XML ERROR] missing <vspacename> for cp_port %d in cluster %d\n",
                cp_port_index, cluster_index);
        exit(1);
    }

    /////////// get vobjname attribute 
    str = getStringValue(reader, "vobjname", &ok);
#if XML_PARSER_DEBUG
printf("      vobjname = %s\n", str);
#endif
    if (ok) 
    {
        strncpy(cp_port_vobj_ref[cp_port_index]->vobj_name, str, 31);
    }
    else 
    {
        printf("[XML ERROR] missing <vobjname> for cp_port %d in cluster %d\n",
                cp_port_index, cluster_index);
        exit(1);
    }
    cp_port_index++;
    cp_port_loc_index++;
} // end cpPortNode()

////////////////////////////////////////
void periphNode(xmlTextReaderPtr reader) 
{
    char * str;
    unsigned int value;
    unsigned int ok;

    irq_loc_index = 0;

    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

    if (periph_index >= MAX_PERIPHS) 
    {
        printf("[XML ERROR] The number of periphs is larger than %d\n", MAX_PERIPHS);
        exit(1);
    }

#if XML_PARSER_DEBUG
printf("\n    periph %d\n", periph_index);
#endif

    periph[periph_index] = (mapping_periph_t *) malloc(sizeof(mapping_periph_t));

    ///////// get channels attribute (optionnal : 1 if missing)
    value = getIntValue(reader, "channels", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("      channels    = %d\n", value);
#endif
        periph[periph_index]->channels = value;
    }
    else 
    {
        periph[periph_index]->channels = 1;
    }

    /////////// get psegname attribute 
    str = getStringValue(reader, "psegname", &ok);
    if (ok == 0) 
    {
        printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n", 
                coproc_index, cluster_index);
        exit(1);
    }

    /////////// set psegid attribute
    int index = getPsegId( cluster[cluster_index]->x, cluster[cluster_index]->y, str);
    if (index >= 0) 
    {
#if XML_PARSER_DEBUG
printf("      clusterid   = %d\n", cluster_index);
printf("      psegname    = %s\n", str);
printf("      psegid      = %d\n", index);
#endif
        periph[periph_index]->psegid = index;
    }
    else 
    {
        printf("[XML ERROR] pseg not found for periph %d / clusterid = %d / psegname = %s\n", 
                periph_loc_index, cluster_index, str );
        exit(1);
    }  

    /////////// get type attribute 
    str = getStringValue(reader, "type", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("      type        = %s\n", str);
#endif
        unsigned int error = 0;

        // initialize peripheral subtype
        periph[periph_index]->subtype = 0xFFFFFFFF;

        // The CMA, FBF, HBA, IOB, IOC, NIC, ROM, SIM, TTY, peripherals are not 
        // replicated in all clusters but can be instanciated twice. 

        ////////////////////////////
        if (strcmp(str, "CMA") == 0) 
        {
            periph[periph_index]->type = PERIPH_TYPE_CMA;
            if ( cma_channels < periph[periph_index]->channels )
            {
                cma_channels = periph[periph_index]->channels;
            }
        }
        /////////////////////////////////
        else if (strcmp(str, "FBF") == 0) 
        {
            periph[periph_index]->type = PERIPH_TYPE_FBF;
            use_fbf = 1;
        }
        /////////////////////////////////
        else if (strcmp(str, "IOB") == 0) 
        {
            periph[periph_index]->type = PERIPH_TYPE_IOB;
            use_iob = 1;
        }
        /////////////////////////////////
        else if (strcmp(str, "IOC") == 0) 
        {
            char* subtype = getStringValue(reader, "subtype", &ok);
            if (!ok)
            {
                printf("[XML ERROR] IOC peripheral needs a subtype: BDV, HBA or SPI\n");
                exit(1);
            } 

            if ( strcmp(subtype, "BDV") == 0 )
            {
                periph[periph_index]->type    = PERIPH_TYPE_IOC;
                periph[periph_index]->subtype = PERIPH_SUBTYPE_BDV;
                ioc_channels = 1;
                if ( header->use_ram_disk == 0 ) use_bdv = 1;
            }
            else if ( strcmp(subtype, "HBA") == 0 )
            {
                periph[periph_index]->type    = PERIPH_TYPE_IOC;
                periph[periph_index]->subtype = PERIPH_SUBTYPE_HBA;
                ioc_channels = periph[periph_index]->channels;
                if ( header->use_ram_disk == 0 ) use_hba = 1;
            }
            else if ( strcmp(subtype, "SPI") == 0 )
            {
                periph[periph_index]->type    = PERIPH_TYPE_IOC;
                periph[periph_index]->subtype = PERIPH_SUBTYPE_SPI;
                ioc_channels = periph[periph_index]->channels;
                if ( header->use_ram_disk == 0 ) use_spi = 1;
            }
            else
            {
                printf("[XML ERROR] illegal subtype for IOC peripheral\n");
                exit(1);
            }
        } 
        /////////////////////////////////
        else if (strcmp(str, "NIC") == 0) 
        {
            periph[periph_index]->type = PERIPH_TYPE_NIC;
            if ( nic_channels < periph[periph_index]->channels )
            {
                nic_channels = periph[periph_index]->channels;
            }
        }
        /////////////////////////////////
        else if (strcmp(str, "ROM") == 0) 
        {
            periph[periph_index]->type = PERIPH_TYPE_ROM;
        } 
        /////////////////////////////////
        else if (strcmp(str, "SIM") == 0) 
        {
            periph[periph_index]->type = PERIPH_TYPE_SIM;
        } 
        /////////////////////////////////
        else if (strcmp(str, "TTY") == 0) 
        {
            periph[periph_index]->type = PERIPH_TYPE_TTY;
            if ( tty_channels < periph[periph_index]->channels )
            {
                tty_channels = periph[periph_index]->channels;
            }
        }
        /////////////////////////////////
        else if (strcmp(str, "PIC") == 0) 
        {
            periph[periph_index]->type = PERIPH_TYPE_PIC;
            if ( pic_channels < periph[periph_index]->channels )
            {
                pic_channels = periph[periph_index]->channels;
            }
            use_pic = 1;
        }


        // The DMA, ICU, MMC, TIM, XCU peripherals can be replicated in all clusters
        // but no more than one component of each type per cluster

        /////////////////////////////////
        else if (strcmp(str, "DMA") == 0) 
        {
            periph[periph_index]->type = PERIPH_TYPE_DMA;
            if (found_dma)  error = 1; 
            found_dma = 1;
            if (dma_channels < periph[periph_index]->channels)
                dma_channels = periph[periph_index]->channels;
        }
        //////////////////////////////////
        else if (strcmp(str, "ICU") == 0) 
        {
            periph[periph_index]->type = PERIPH_TYPE_ICU;
            if (found_icu || use_xcu)  error = 1; 
            found_icu = 1;

            if ( periph[periph_index]->channels < 
                 (header->irq_per_proc * cluster[cluster_index]->procs) )
            {
                printf("[XML ERROR] ICU channels smaller than PROCS * IRQ_PER_PROC\n");
                printf(" - icu channels = %d\n - nprocs = %d\n - irq_per_proc = %d\n",
                       periph[periph_index]->channels, 
                       cluster[cluster_index]->procs, 
                       header->irq_per_proc );
                exit(1);
            }
        }
        //////////////////////////////////
        else if (strcmp(str, "MMC") == 0) 
        {
            periph[periph_index]->type = PERIPH_TYPE_MMC;
            if (found_mmc)  error = 1; 
            found_mmc = 1;
            if ( periph[periph_index]->channels != 1 ) error = 1;
        }
        //////////////////////////////////
        else if (strcmp(str, "TIM") == 0 ) 
        {
            periph[periph_index]->type = PERIPH_TYPE_TIM;
            if (found_timer || use_xcu)  error = 1; 
            found_timer = 1;
            if (tim_channels < periph[periph_index]->channels) 
                tim_channels = periph[periph_index]->channels;
        }
        //////////////////////////////////
        else if (strcmp(str, "XCU") == 0) 
        {
            periph[periph_index]->type = PERIPH_TYPE_XCU;
            if (found_xcu || found_icu || found_timer)  error = 1; 
            found_xcu    = 1;
            found_timer  = 1;
            tim_channels = 32; 
            use_xcu      = 1;

            if ( periph[periph_index]->channels < 
                 (header->irq_per_proc * cluster[cluster_index]->procs) )
            {
                printf("[XML ERROR] XCU channels smaller than PROCS * IRQ_PER_PROC\n");
                printf(" - xcu channels = %d\n - nprocs = %d\n - irq_per_proc = %d\n",
                       periph[periph_index]->channels, 
                       cluster[cluster_index]->procs, 
                       header->irq_per_proc );
                exit(1);
            }
        }
        else 
        {
            printf("[XML ERROR] illegal peripheral type: %s in cluster %d\n",
                    str, cluster_index);
            exit(1);
        }

        if (error) 
        {
            printf("[XML ERROR] illegal peripheral %s in cluster %d\n",
                    str, cluster_index);
            exit(1);
        }
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <type> for peripheral  %d in cluster %d\n",
                periph_loc_index, cluster_index);
        exit(1);
    }

    ////////////// set irq_offset attribute
    periph[periph_index]->irq_offset = irq_index;

    ///////////// get IRQs
    int status = xmlTextReaderRead(reader);
    while (status == 1) 
    {
        const char * tag = (const char *) xmlTextReaderConstName(reader);

        if (strcmp(tag, "irq") == 0) 
        {
            if ( (periph[periph_index]->type != PERIPH_TYPE_ICU) &&
                 (periph[periph_index]->type != PERIPH_TYPE_XCU) &&
                 (periph[periph_index]->type != PERIPH_TYPE_PIC) )
            {
                printf("[XML ERROR] periph %d in cluster(%d,%d) "
                       " only ICU, XCU and PIC can contain IRQs",
                periph_loc_index, cluster[cluster_index]->x, cluster[cluster_index]->y);
                exit(1);
            }
            else
            {
                  irqNode(reader);
            }
        }
        else if (strcmp(tag, "#text")    == 0) { }
        else if (strcmp(tag, "#comment") == 0) { }
        else if (strcmp(tag, "periph")   == 0) 
        {
            periph[periph_index]->irqs = irq_loc_index;
            cluster[cluster_index]->periphs++;
            periph_loc_index++;
            periph_index++;

#if XML_PARSER_DEBUG
printf("      irqs        = %d\n", irq_loc_index);
printf("      irq_offset  = %d\n", irq_index);
#endif
            return;
        }
        else 
        {
            printf("[XML ERROR] Unknown tag %s", tag);
            exit(1);
        }
        status = xmlTextReaderRead(reader);
    }
} // end periphNode

////////////////////////////////////////
void coprocNode(xmlTextReaderPtr reader) 
{
    char * str;
    unsigned int ok;

    cp_port_loc_index = 0;

    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

    if (coproc_index >= MAX_COPROCS) 
    {
        printf("[XML ERROR] The number of coprocs is larger than %d\n", MAX_COPROCS);
        exit(1);
    }

#if XML_PARSER_DEBUG
printf("\n  coproc %d\n", coproc_index);
#endif

    coproc[coproc_index] = (mapping_coproc_t *) malloc(sizeof(mapping_coproc_t));

    /////////// get name attribute 
    str = getStringValue(reader, "name", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
printf("      name = %s\n", str);
#endif
        strncpy(coproc[coproc_index]->name, str, 31);
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <name> for coproc %d in cluster %d\n",
                coproc_index, cluster_index);
        exit(1);
    }

    /////////// get psegname attribute 
    str = getStringValue(reader, "psegname", &ok);
    if (ok == 0) 
    {
        printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n", 
                coproc_index, cluster_index);
        exit(1);
    }

    /////////// set psegid attribute
    int index = getPsegId( cluster[cluster_index]->x, cluster[cluster_index]->y, str);
    if (index >= 0) 
    {
#if XML_PARSER_DEBUG
printf("      clusterid = %d\n", cluster_index);
printf("      psegname  = %s\n", str);
printf("      psegid    = %d\n", index);
#endif
        coproc[coproc_index]->psegid = index;
        assert(pseg[index]->type == PSEG_TYPE_PERI && 
        "coproc psegname attribute must refer to a pseg of type PERI" );
    }
    else 
    {
        printf("[XML ERROR] pseg not found for coproc %d / clusterid = %d / psegname = %s\n", 
                coproc_index, cluster_index, str );
        exit(1);
    }  

    ////////// set port_offset 
    coproc[coproc_index]->port_offset = cp_port_index;

#if XML_PARSER_DEBUG
printf("      port_offset = %d\n", cp_port_index);
#endif

    int status = xmlTextReaderRead(reader);
    while (status == 1) 
    {
        const char * tag = (const char *) xmlTextReaderConstName(reader);

        if (strcmp(tag, "port") == 0 ) 
        {
            cpPortNode(reader);
        }
        else if (strcmp(tag, "#text")    == 0 ) { }
        else if (strcmp(tag, "#comment") == 0 ) { }
        else if (strcmp(tag, "coproc") == 0 ) 
        {
            coproc[coproc_index]->ports = cp_port_loc_index;
            cluster[cluster_index]->coprocs++;
            coproc_loc_index++;
            coproc_index++;
            return;
        }
        else 
        {
            printf("[XML ERROR] Unknown tag %s", tag);
            exit(1);
        }
        status = xmlTextReaderRead(reader);
    }
} // end coprocNode()


//////////////////////////////////////
void procNode(xmlTextReaderPtr reader) 
{
    unsigned int ok;
    unsigned int value;

    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

    if (proc_index >= MAX_PROCS) 
    {
        printf("[XML ERROR] The number of procs is larger than %d\n", MAX_PROCS);
        exit(1);
    }

#if XML_PARSER_DEBUG
printf("\n    proc %d\n", proc_index);
#endif

    proc[proc_index] = (mapping_proc_t *) malloc(sizeof(mapping_proc_t));

    /////////// get index attribute (optional)
    value = getIntValue(reader, "index", &ok);
    if (ok && (value != proc_loc_index)) 
    {
        printf("[XML ERROR] wrong local proc index / expected value is %d", 
                proc_loc_index);
        exit(1);
    }
    proc[proc_index]->index = proc_loc_index;

    cluster[cluster_index]->procs++;
    proc_loc_index++;
    proc_index++;
    total_procs++;
} // end procNode()


//////////////////////////////////////
void psegNode(xmlTextReaderPtr reader) 
{
    unsigned int ok;
    paddr_t      ll_value;
    char * str;

    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

    if (pseg_index >= MAX_PSEGS) 
    {
        printf("[XML ERROR] The number of psegs is larger than %d\n", MAX_PSEGS);
        exit(1);
    }

#if XML_PARSER_DEBUG
printf("    pseg %d\n", pseg_index);
#endif

    pseg[pseg_index] = (mapping_pseg_t *) malloc(sizeof(mapping_pseg_t));

    /////// get name attribute
    str = getStringValue(reader, "name", &ok);
#if XML_PARSER_DEBUG
printf("      name = %s\n", str);
#endif
    if (ok) 
    {
        strncpy(pseg[pseg_index]->name, str, 31);
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <name> for pseg %d in cluster %d\n",
                pseg_index, cluster_index);
        exit(1);
    }

    //////// get type attribute
    str = getStringValue(reader, "type", &ok);
#if XML_PARSER_DEBUG
printf("      type = %s\n", str);
#endif
    if      (ok && (strcmp(str, "RAM" ) == 0)) { pseg[pseg_index]->type = PSEG_TYPE_RAM; }
    else if (ok && (strcmp(str, "ROM" ) == 0)) { pseg[pseg_index]->type = PSEG_TYPE_ROM; }
    else if (ok && (strcmp(str, "PERI") == 0)) { pseg[pseg_index]->type = PSEG_TYPE_PERI; }
    else 
    {
        printf("[XML ERROR] illegal or missing <type> for pseg %s in cluster %d\n",
                pseg[pseg_index]->name, cluster_index);
        exit(1);
    }

    //////// get base attribute
    ll_value = getPaddrValue(reader, "base", &ok);
#if XML_PARSER_DEBUG
printf("      base = 0x%llx\n", ll_value);
#endif
    if (ok) 
    {
        pseg[pseg_index]->base = ll_value;
    }
    else {
        printf("[XML ERROR] illegal or missing <base> for pseg %s in cluster %d\n",
                pseg[pseg_index]->name, cluster_index);
        exit(1);
    }

    //////// get length attribute
    ll_value = getPaddrValue(reader, "length", &ok);
#if XML_PARSER_DEBUG
printf("      length = 0x%llx\n", ll_value);
#endif
    if (ok) 
    {
        pseg[pseg_index]->length = ll_value;
    }  
    else 
    {
        printf("[XML ERROR] illegal or missing <length> for pseg %s in cluster %d\n",
                pseg[pseg_index]->name, cluster_index);
        exit(1);
    }

    //////// set cluster attribute
    pseg[pseg_index]->clusterid = cluster_index;

    //////// set next_vseg attribute
    pseg[pseg_index]->next_vseg = 0;

    pseg_index++;
    cluster[cluster_index]->psegs++;
} // end psegNode()


/////////////////////////////////////////
void clusterNode(xmlTextReaderPtr reader) 
{
    unsigned int ok;
    unsigned int value;

    cluster[cluster_index] = (mapping_cluster_t *) malloc(sizeof(mapping_cluster_t));

    //initialise variables that will be incremented by *Node() functions
    cluster[cluster_index]->psegs = 0;
    cluster[cluster_index]->procs = 0;
    cluster[cluster_index]->coprocs = 0;
    cluster[cluster_index]->periphs = 0;

    //initialise global variables
    proc_loc_index = 0;
    coproc_loc_index = 0;
    periph_loc_index = 0;

    // for replicated periph
    found_timer = 0;
    found_icu   = 0;
    found_xcu   = 0;
    found_dma   = 0;
    found_mmc   = 0;

    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT)  return;

#if XML_PARSER_DEBUG
printf("\n  cluster %d\n", cluster_index);
#endif

    /////////// get x coordinate
    value = getIntValue(reader, "x", &ok);
#if XML_PARSER_DEBUG
printf("    x             = %d\n", value);
#endif
    if (ok && (value < header->x_size) ) 
    {
        cluster[cluster_index]->x = value;
    }
    else
    {
        printf("[XML ERROR] Illegal or missing < x > attribute for cluster %d", 
                cluster_index);
        exit(1);
    }

    /////////// get y coordinate
    value = getIntValue(reader, "y", &ok);
#if XML_PARSER_DEBUG
printf("    y             = %d\n", value);
#endif
    if (ok && (value < header->y_size) ) 
    {
        cluster[cluster_index]->y = value;
    }
    else
    {
        printf("[XML ERROR] Illegal or missing < y > attribute for cluster %d", 
                cluster_index);
        exit(1);
    }

    ////////// set offsets
    cluster[cluster_index]->pseg_offset = pseg_index;
    cluster[cluster_index]->proc_offset = proc_index;
    cluster[cluster_index]->coproc_offset = coproc_index;
    cluster[cluster_index]->periph_offset = periph_index;

#if XML_PARSER_DEBUG
printf("    pseg_offset   = %d\n", pseg_index);
printf("    proc_offset   = %d\n", proc_index);
printf("    coproc_offset = %d\n", coproc_index);
printf("    periph_offset = %d\n", coproc_index);
#endif

    ////////// get psegs, procs, coprocs and periphs
    int status = xmlTextReaderRead(reader);

    while (status == 1) 
    {
        const char * tag = (const char *) xmlTextReaderConstName(reader);

        if      (strcmp(tag, "pseg")     == 0) psegNode(reader);
        else if (strcmp(tag, "proc")     == 0) procNode(reader);
        else if (strcmp(tag, "coproc")   == 0) coprocNode(reader);
        else if (strcmp(tag, "periph")   == 0) periphNode(reader);
        else if (strcmp(tag, "#text")    == 0) { }
        else if (strcmp(tag, "#comment") == 0) { }
        else if (strcmp(tag, "cluster")  == 0) 
        {
            ///////// TIMER and ICU peripheral are mandatory when nprocs != 0

            unsigned int procs = cluster[cluster_index]->procs;
            if ( procs && !found_timer && !found_xcu)
            {
                printf("[XML ERROR] missing timer peripheral in cluster %d\n", cluster_index);
                exit(1);
            }

            if ( procs && !found_icu && !found_xcu) 
            {
                printf("[XML ERROR] missing icu peripheral in cluster %d\n", cluster_index);
                exit(1);
            }

            if (nb_procs_max < procs) nb_procs_max = procs;

#if XML_PARSER_DEBUG
printf("    psegs   = %d\n", cluster[cluster_index]->psegs);
printf("    procs   = %d\n", cluster[cluster_index]->procs);
printf("    coprocs = %d\n", cluster[cluster_index]->coprocs);
printf("    periphs = %d\n", cluster[cluster_index]->periphs);
printf("    end cluster %d\n", cluster_index);
#endif
            cluster_index++;
            return;
        }
        status = xmlTextReaderRead(reader);
    }
} // end clusterNode()


//////////////////////////////////////////////
void clusterSetNode(xmlTextReaderPtr reader) 
{
    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

#if XML_PARSER_DEBUG
printf("\n  clusters set\n");
#endif

    int status = xmlTextReaderRead(reader);
    while (status == 1) 
    {
        const char * tag = (const char *) xmlTextReaderConstName(reader);

        if      (strcmp(tag, "cluster")    == 0) { clusterNode(reader); }
        else if (strcmp(tag, "#text")      == 0) { }
        else if (strcmp(tag, "#comment")   == 0) { }
        else if (strcmp(tag, "clusterset") == 0) 
        {
            // checking number of clusters
            if ( cluster_index != (header->x_size * header->y_size) ) 
            {
                printf("[XML ERROR] Wrong number of clusters\n");
                exit(1);
            }

            // checking TTY terminal for system boot
            if ( tty_channels == 0 )
            {
                printf("[XML ERROR] missing TTY peripheral\n");
                exit(1);
            }

            // checking IOC sub-types
            if ( (use_bdv + use_hba + use_spi) > 1 )
            {
                printf("[XML ERROR] all IOC peripherals must have the same type\n");
                exit(1);
            }

#if XML_PARSER_DEBUG
            printf("  end cluster set\n\n");
#endif
            header->psegs = pseg_index;
            header->procs = proc_index;
            header->irqs = irq_index;
            header->coprocs = coproc_index;
            header->cp_ports = cp_port_index;
            header->periphs = periph_index;
            return;
        }
        else 
        {
            printf("[XML ERROR] Unknown tag in clusterset node : %s",tag);
            exit(1);
        }
        status = xmlTextReaderRead(reader);
    }
} // end clusterSetNode()


///////////////////////////////////////////
void globalSetNode(xmlTextReaderPtr reader) 
{
    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

#if XML_PARSER_DEBUG
    printf("  globals set\n");
#endif

    int status = xmlTextReaderRead(reader);
    while (status == 1) 
    {
        const char * tag = (const char *) xmlTextReaderConstName(reader);

        if      (strcmp(tag, "vseg")      == 0) 
        { 
            vsegNode( reader ); 
            header->globals = header->globals + 1;
        }
        else if (strcmp(tag, "#text")     == 0) { }
        else if (strcmp(tag, "#comment")  == 0) { }
        else if (strcmp(tag, "globalset") == 0) 
        {
#if XML_PARSER_DEBUG
            printf("  end global set\n\n");
#endif
            vseg_loc_index = 0;
            return;
        }
        else 
        {
            printf("[XML ERROR] Unknown tag in globalset node : %s",tag);
            exit(1);
        }
        status = xmlTextReaderRead(reader);
    }
} // end globalSetNode()


///////////////////////////////////////////
void vspaceSetNode(xmlTextReaderPtr reader)
{
    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) {
        return;
    }

#if XML_PARSER_DEBUG
    printf("\n  vspaces set\n");
#endif

    int status = xmlTextReaderRead ( reader );
    while (status == 1) {
        const char * tag = (const char *) xmlTextReaderConstName(reader);

        if (strcmp(tag, "vspace") == 0) {
            vspaceNode(reader);
        }
        else if (strcmp(tag, "#text"    ) == 0 ) { }
        else if (strcmp(tag, "#comment" ) == 0 ) { }
        else if (strcmp(tag, "vspaceset") == 0 ) 
        {
            header->vsegs = vseg_index;
            header->vobjs = vobj_index;
            header->tasks = task_index;
            return;
        }
        else 
        {
            printf("[XML ERROR] Unknown tag in vspaceset node : %s",tag);
            exit(1);
        }
        status = xmlTextReaderRead(reader);
    }
} // end globalSetNode()


////////////////////////////////////////
void headerNode(xmlTextReaderPtr reader) 
{
    char * name;
    unsigned int value;
    unsigned int ok;

    if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT) return;

#if XML_PARSER_DEBUG
    printf("mapping_info\n");
#endif

    header = (mapping_header_t *) malloc(sizeof(mapping_header_t));

    ////////// get name attribute
    name = getStringValue(reader, "name", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
        printf("  name = %s\n", name);
#endif
        strncpy( header->name, name, 31);
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <name> attribute in header\n");
        exit(1);
    }

    /////////// get signature attribute
    value = getIntValue(reader, "signature", &ok);
    if ( ok && (value == IN_MAPPING_SIGNATURE) )
    {
#if XML_PARSER_DEBUG
        printf("  signature = %x\n", value);
#endif
        header->signature = IN_MAPPING_SIGNATURE;
    }
    else
    {
        printf("[XML ERROR] illegal or missing <signature> for mapping %s\n",
        header->name );
        exit(1);
    }

    /////////// get x_width attribute
    value = getIntValue(reader, "x_width", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
        printf("  x_width = %d\n", value);
#endif
        header->x_width = value;
    }

    /////////// get y_width attribute
    value = getIntValue(reader, "y_width", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
        printf("  y_width = %d\n", value);
#endif
        header->y_width = value;
    }

    /////////// get x_size attribute
    unsigned int x_size = getIntValue(reader, "x_size", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
        printf("  x_size  = %d\n", x_size);
#endif
        header->x_size = x_size;
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <x_size> attribute in header\n");
        exit(1);
    }

    /////////// get y_size attribute
    unsigned int y_size = getIntValue(reader, "y_size", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
        printf("  y_size  = %d\n", y_size);
#endif
        header->y_size = y_size;
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <y_size> attribute in header\n");
        exit(1);
    }

    /////////// get x_io attribute
    unsigned int x_io = getIntValue(reader, "x_io", &ok);
#if XML_PARSER_DEBUG
        printf("  x_io      = %d\n", x_io);
#endif
    if ( ok && (x_io < x_size) ) 
    {
        header->x_io = x_io;
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <x_io> attribute in header\n");
        exit(1);
    }

    /////////// get y_io attribute
    unsigned int y_io = getIntValue(reader, "y_io", &ok);
#if XML_PARSER_DEBUG
        printf("  y_io      = %d\n", y_io);
#endif
    if ( ok &&(y_io < y_size) ) 
    {
        header->y_io = y_io;
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <y_io> attribute in header\n");
        exit(1);
    }

    // check the number of cluster
    if ( (x_size * y_size) >= MAX_CLUSTERS )
    {
        printf("[XML ERROR] Number of clusters cannot be larger than %d\n", MAX_CLUSTERS);
        exit(1);
    }

    ///////// get irq_per_proc attribute
    value = getIntValue(reader, "irq_per_proc", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
        printf("  irq_per_proc = %d\n", value);
#endif
        header->irq_per_proc = value;
    }
    else 
    {
        printf("[XML ERROR] illegal or missing <irq_per_proc> attribute in mapping\n");
        exit(1);
    }

    ///////// get use_ram_disk attribute (default = 0)
    value = getIntValue(reader, "use_ram_disk", &ok);
    if (ok) 
    {
#if XML_PARSER_DEBUG
        printf("  use_ram_disk = %d\n", value);
#endif
        header->use_ram_disk = value;
    }
    else 
    {
        header->use_ram_disk = 0;
    }

    ///////// set other header fields 
    header->increment = 0x10000;
    header->globals   = 0;
    header->vspaces   = 0;
    header->psegs     = 0;
    header->vsegs     = 0;
    header->vobjs     = 0;
    header->tasks     = 0;
    header->procs     = 0;
    header->irqs      = 0;
    header->coprocs   = 0;
    header->cp_ports  = 0;
    header->periphs   = 0;


    int status = xmlTextReaderRead(reader);
    while (status == 1) 
    {
        const char * tag = (const char *) xmlTextReaderConstName(reader);

        if      (strcmp(tag, "clusterset")   == 0) { clusterSetNode(reader); }
        else if (strcmp(tag, "globalset")    == 0) { globalSetNode(reader); }
        else if (strcmp(tag, "vspaceset")    == 0) { vspaceSetNode(reader); }
        else if (strcmp(tag, "#text")        == 0) { }
        else if (strcmp(tag, "#comment")     == 0) { }
        else if (strcmp(tag, "mapping_info") == 0) 
        {
#if XML_PARSER_DEBUG
            printf("end mapping_info\n");
#endif
            return;
        }
        else 
        {
            printf("[XML ERROR] Unknown tag in header node : %s\n",tag);
            exit(1);
        }
        status = xmlTextReaderRead(reader);
    }
} // end headerNode()


///////////////////////////////////////
void BuildTable(int fdout, const char * type, unsigned int nb_elem,
                unsigned int elem_size, char ** table) 
{
    unsigned int i;
    // write element
    for (i = 0; i < nb_elem; i++) {
        if (elem_size != write(fdout, table[i], elem_size)) {
            printf("function %s: %s(%d) write  error \n", __FUNCTION__, type, i);
            exit(1);
        }

#if XML_PARSER_DEBUG
        printf("Building binary: writing %s %d\n", type, i);
#endif
    }
}

/////////////////////////////////////
int open_file(const char * file_path) 
{
    //open file
    int fdout = open( file_path, (O_CREAT | O_RDWR), (S_IWUSR | S_IRUSR) );
    if (fdout < 0) 
    {
        perror("open");
        exit(1);
    }

    //reinitialise the file
    if (ftruncate(fdout, 0)) 
    {
        perror("truncate");
        exit(1);
    }

    //#if XML_PARSER_DEBUG
    printf("%s\n", file_path);
    //#endif

    return fdout;
}


/////////////////////////////////////
void buildBin(const char * file_path) 
{
    unsigned int length;

    int fdout = open_file(file_path);

#if XML_PARSER_DEBUG
printf("Building map.bin for %s\n", header->name);
printf("signature = %x\n", header->signature);
printf("x_size    = %d\n", header->x_size);
printf("y_size    = %d\n", header->y_size);
printf("x_width   = %d\n", header->x_width);
printf("y_width   = %d\n", header->y_width);
printf("vspaces   = %d\n", header->vspaces);
printf("psegs     = %d\n", header->psegs);
printf("vobjs     = %d\n", header->vobjs);
printf("vsegs     = %d\n", header->vsegs);
printf("tasks     = %d\n", header->tasks);
printf("procs     = %d\n", header->procs);
printf("irqs      = %d\n", header->irqs);
printf("coprocs   = %d\n", header->coprocs);
printf("periphs   = %d\n", header->periphs);
#endif

    // write header to binary file
    length = write(fdout, (char *) header, sizeof(mapping_header_t));
    if (length != sizeof(mapping_header_t)) 
    {
        printf("write header error : length = %d \n", length);
        exit(1);
    }

    // write clusters
    BuildTable(fdout, "cluster", cluster_index, sizeof(mapping_cluster_t), (char **) cluster);
    // write psegs
    BuildTable(fdout, "pseg", pseg_index, sizeof(mapping_pseg_t), (char **) pseg);
    // write vspaces
    BuildTable(fdout, "vspace", vspace_index, sizeof(mapping_vspace_t), (char **) vspace);
    // write vsegs
    BuildTable(fdout, "vseg", vseg_index, sizeof(mapping_vseg_t), (char **) vseg);
    // write vobjs
    BuildTable(fdout, "vobj", vobj_index, sizeof(mapping_vobj_t), (char **) vobj);
    // write tasks array
    BuildTable(fdout, "task", task_index, sizeof(mapping_task_t), (char **) task);
    //building procs array
    BuildTable(fdout, "proc", proc_index, sizeof(mapping_proc_t), (char **) proc);
    //building irqs array
    BuildTable(fdout, "irq", irq_index, sizeof(mapping_irq_t), (char **) irq);
    //building coprocs array
    BuildTable(fdout, "coproc", coproc_index, sizeof(mapping_coproc_t), (char **) coproc);
    //building cp_ports array
    BuildTable(fdout, "cp_port", cp_port_index, sizeof(mapping_cp_port_t),(char **) cp_port);
    //building periphs array
    BuildTable(fdout, "periph", periph_index, sizeof(mapping_periph_t), (char **) periph);

    close(fdout);

} // end buildBin()


///////////////////////////////////////////////////////////////////////
// this function set the value the vobj_id fiels of all cp_ports
///////////////////////////////////////////////////////////////////////
void prepareBuild() 
{
    unsigned int i;
    //asign for all cp_ports the correct vspaceid and vobjid
    for (i = 0; i < cp_port_index; i++) {
        int vspace_id = getVspaceId(cp_port_vobj_ref[i]->vspace_name);
        if (vspace_id < 0) {
            printf("[XML ERROR] illegal  <vspacename> for cp_port %d,\n", i);
            exit(1);
        }
        cp_port[i]->vspaceid = vspace_id;

        int vobj_id = getVobjLocId(vspace_id, cp_port_vobj_ref[i]->vobj_name, vspace[vspace_id]->vobjs);
        if (vobj_id >= 0) {

#if XML_PARSER_DEBUG
            printf("\ncp_port = %d\n", i);
            printf("      vspace_name  = %s\n", cp_port_vobj_ref[i]->vspace_name);
            printf("      vobj_name    = %s\n", cp_port_vobj_ref[i]->vobj_name);
            printf("      vobj_index   = %d\n", vobj_id);
#endif
            cp_port[i]->mwmr_vobjid = vobj_id;

            assert((vobj[ vspace[vspace_id]->vobj_offset + vobj_id]->type == VOBJ_TYPE_MWMR)
                    && "coproc ports have to refer to a vobj of type MWMR");
        }
        else {
            printf("[XML ERROR] illegal  <vobjname> for cp_port %d,\n", i);
            exit(1);
        }
    }
}

//////////////////////////////////////////
void file_write(int fdout, char * towrite) 
{
    unsigned int size = strlen(towrite);
    if (size != write(fdout, towrite, size)) 
    {
        printf("file_write error");
        exit(1);
    }
}

//////////////////////////////////////////////////
void def_int_write(int fdout, char * def, int num) 
{
    char  buf[64];
    sprintf(buf, "#define\t %s  %d\n", def, num);
    file_write(fdout, buf);
}

//////////////////////////////////////////////////
void def_hex_write(int fdout, char * def, int num) 
{
    char  buf[64];
    sprintf(buf, "#define\t %s  0x%x\n", def, num);
    file_write(fdout, buf);
}

///////////////////////////////////
void  genHd(const char * file_path) 
{
    int fdout = open_file(file_path);

    char prol[80];
    sprintf(prol, "/* Generated from file %s.xml */\n\n",header->name);

    char * ifdef  = "#ifndef _HARD_CONFIG_H\n#define _HARD_CONFIG_H\n\n";
    char * epil   = "\n#endif //_HARD_CONFIG_H";

    file_write(fdout, prol);
    file_write(fdout, ifdef);

    def_int_write(fdout, "X_SIZE            ", header->x_size);
    def_int_write(fdout, "Y_SIZE            ", header->y_size);
    def_int_write(fdout, "X_WIDTH           ", header->x_width);
    def_int_write(fdout, "Y_WIDTH           ", header->y_width);
    def_int_write(fdout, "X_IO              ", header->x_io);
    def_int_write(fdout, "Y_IO              ", header->y_io);

    file_write(fdout, "\n");

    def_int_write(fdout, "TOTAL_PROCS       ", total_procs);
    def_int_write(fdout, "NB_PROCS_MAX      ", nb_procs_max);
    def_int_write(fdout, "NB_TASKS_MAX      ", nb_tasks_max);

    file_write(fdout, "\n");

    def_int_write(fdout, "NB_TIM_CHANNELS   ", tim_channels);
    def_int_write(fdout, "NB_DMA_CHANNELS   ", dma_channels);

    file_write(fdout, "\n");

    def_int_write(fdout, "NB_TTY_CHANNELS   ", tty_channels);
    def_int_write(fdout, "NB_IOC_CHANNELS   ", ioc_channels);
    def_int_write(fdout, "NB_NIC_CHANNELS   ", nic_channels);
    def_int_write(fdout, "NB_CMA_CHANNELS   ", cma_channels);

    file_write(fdout, "\n");

    def_int_write(fdout, "USE_XICU          ", use_xcu);
    def_int_write(fdout, "USE_IOB           ", use_iob);
    def_int_write(fdout, "USE_PIC           ", use_pic);
    def_int_write(fdout, "USE_FBF           ", use_fbf);

    file_write(fdout, "\n");

    def_int_write(fdout, "USE_IOC_RDK       ", header->use_ram_disk);
    def_int_write(fdout, "USE_IOC_HBA       ", use_hba);
    def_int_write(fdout, "USE_IOC_BDV       ", use_bdv);
    def_int_write(fdout, "USE_IOC_SPI       ", use_spi);

    file_write(fdout, "\n");

    def_int_write(fdout, "IRQ_PER_PROCESSOR ", header->irq_per_proc);

    file_write(fdout, epil);

    close(fdout);
}

////////////////////////////////////////////////////////
void ld_write(int fdout, char * seg, unsigned int addr) 
{
    char buf[64];
    sprintf(buf, "%s = 0x%x;\n", seg, addr);
    file_write(fdout, buf);
}

//////////////////////////////////
void genLd(const char * file_path) 
{
    int          fdout = open_file(file_path);
    unsigned int count;
    unsigned int vseg_id;
    unsigned int base;      // vseg base
    unsigned int size;      // vseg size

    char prol[80];
    sprintf(prol, "/* Generated from file %s.xml */\n\n",header->name);

    file_write(fdout, prol);

    // boot mandatory global vsegs 
    for (vseg_id = 0 , count = 0 ; vseg_id < header->vsegs ; vseg_id++)
    {
        if ( strcmp(vseg[vseg_id]->name, "seg_boot_code") == 0 )
        {
            base = vseg[vseg_id]->vbase;
            size = vobj[vseg[vseg_id]->vobj_offset]->length;
            ld_write(fdout, "seg_boot_code_base      ", base);
            ld_write(fdout, "seg_boot_code_size      ", size);
            count++;
        }
        else if ( strcmp(vseg[vseg_id]->name, "seg_boot_data") == 0 )
        {
            base = vseg[vseg_id]->vbase;
            size = vobj[vseg[vseg_id]->vobj_offset]->length;
            ld_write(fdout, "seg_boot_data_base      ", base);
            ld_write(fdout, "seg_boot_data_size      ", size);
            count++;
        }
        else if ( strcmp(vseg[vseg_id]->name, "seg_boot_stack") == 0 )
        {
            base = vseg[vseg_id]->vbase;
            size = vobj[vseg[vseg_id]->vobj_offset]->length;
            ld_write(fdout, "seg_boot_stack_base     ", base);
            ld_write(fdout, "seg_boot_stack_size     ", size);
            count++;        
        }
        else if ( strcmp(vseg[vseg_id]->name, "seg_boot_mapping") == 0 )
        {
            base = vseg[vseg_id]->vbase;
            size = vobj[vseg[vseg_id]->vobj_offset]->length;
            ld_write(fdout, "seg_boot_mapping_base   ", base);
            ld_write(fdout, "seg_boot_mapping_size   ", size);
            count++;
        }
        else if ( strcmp(vseg[vseg_id]->name, "seg_boot_buffer") == 0 )
        {
            base = vseg[vseg_id]->vbase;
            size = vobj[vseg[vseg_id]->vobj_offset]->length;
            ld_write(fdout, "seg_boot_buffer_base    ", base);
            ld_write(fdout, "seg_boot_buffer_size    ", size);
            count++;
        }
    }

    if ( count != 5 )
    { 
        printf ("[XML ERROR] Missing mandatory Boot global vseg : only %d\n", count);
        printf ("Mandatory segments are :\n");
        printf (" - seg_boot_code\n");
        printf (" - seg_boot_data\n");
        printf (" - seg_boot_stack\n");
        printf (" - seg_boot_mapping\n");
        printf (" - seg_boot_buffer\n");
        exit(0);
    }

    file_write(fdout, "\n");

    // kernel mandatory global vsegs 
    for (vseg_id = 0, count = 0 ; vseg_id < header->vsegs ; vseg_id++)
    {
        if ( strcmp(vseg[vseg_id]->name, "seg_kernel_code") == 0 )
        {
            base = vseg[vseg_id]->vbase;
            size = vobj[vseg[vseg_id]->vobj_offset]->length;
            ld_write(fdout, "seg_kernel_code_base    ", base);
            ld_write(fdout, "seg_kernel_code_size    ", size);
            count++;
        }
        else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_data") == 0 )
        {
            base = vseg[vseg_id]->vbase;
            size = vobj[vseg[vseg_id]->vobj_offset]->length;
            ld_write(fdout, "seg_kernel_data_base    ", base);
            ld_write(fdout, "seg_kernel_data_size    ", size);
            count++;
        }
        else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_uncdata") == 0 )
        {
            base = vseg[vseg_id]->vbase;
            size = vobj[vseg[vseg_id]->vobj_offset]->length;
            ld_write(fdout, "seg_kernel_uncdata_base ", base);
            ld_write(fdout, "seg_kernel_uncdata_size ", size);
            count++;
        }
        else if ( strcmp(vseg[vseg_id]->name, "seg_kernel_init") == 0 )
        {
            base = vseg[vseg_id]->vbase;
            size = vobj[vseg[vseg_id]->vobj_offset]->length;
            ld_write(fdout, "seg_kernel_init_base    ", base);
            ld_write(fdout, "seg_kernel_init_size    ", size);
            count++;
        }
    }
    if ( count != 4 )
    { 
        printf ("[XML ERROR] Missing mandatory Kernel global vseg : only %d\n", count);
        printf ("Mandatory segments are :\n");
        printf (" - seg_kernel_code\n");
        printf (" - seg_kernel_data\n");
        printf (" - seg_kernel_uncdata\n");
        printf (" - seg_kernel_init\n");
        exit(0);
    }

    file_write(fdout, "\n");

    // boot and kernel optionnal global vsegs (pseudo ROMs)
    unsigned int seg_ram_disk_base    = 0xFFFFFFFF;
    unsigned int seg_ram_disk_size    = 0;
    unsigned int seg_reset_code_base  = 0xFFFFFFFF;
    unsigned int seg_reset_code_size  = 0;
    for (vseg_id = 0 ; vseg_id < header->vsegs ; vseg_id++)
    {
        if ( strcmp(vseg[vseg_id]->name, "seg_reset_code") == 0 )
        {
            seg_reset_code_base = vseg[vseg_id]->vbase;
            seg_reset_code_size = vobj[vseg[vseg_id]->vobj_offset]->length;
        }
        if ( strcmp(vseg[vseg_id]->name, "seg_ram_disk") == 0 )
        {
            seg_ram_disk_base   = vseg[vseg_id]->vbase;
            seg_ram_disk_size   = vobj[vseg[vseg_id]->vobj_offset]->length;
        }
    }

    ld_write(fdout, "seg_reset_code_base     ", seg_reset_code_base);
    ld_write(fdout, "seg_reset_code_size     ", seg_reset_code_size);
    ld_write(fdout, "seg_ram_disk_base       ", seg_ram_disk_base);
    ld_write(fdout, "seg_ram_disk_size       ", seg_ram_disk_size);
    
    file_write(fdout, "\n");

    // fill the peripherals base address array 
    set_periph_vbase_array();

    //  non replicated peripherals
    ld_write(fdout, "seg_cma_base            ",   periph_vbase_array[PERIPH_TYPE_CMA]);
    ld_write(fdout, "seg_fbf_base            ",   periph_vbase_array[PERIPH_TYPE_FBF]);
    ld_write(fdout, "seg_iob_base            ",   periph_vbase_array[PERIPH_TYPE_IOB]);
    ld_write(fdout, "seg_ioc_base            ",   periph_vbase_array[PERIPH_TYPE_IOC]);
    ld_write(fdout, "seg_nic_base            ",   periph_vbase_array[PERIPH_TYPE_NIC]);
    ld_write(fdout, "seg_rom_base            ",   periph_vbase_array[PERIPH_TYPE_ROM]);
    ld_write(fdout, "seg_sim_base            ",   periph_vbase_array[PERIPH_TYPE_SIM]);
    ld_write(fdout, "seg_tty_base            ",   periph_vbase_array[PERIPH_TYPE_TTY]);
    ld_write(fdout, "seg_pic_base            ",   periph_vbase_array[PERIPH_TYPE_PIC]);

    file_write(fdout, "\n");

    // replicated peripherals
    ld_write(fdout, "seg_dma_base            ",   periph_vbase_array[PERIPH_TYPE_DMA]);
    ld_write(fdout, "seg_icu_base            ",   periph_vbase_array[PERIPH_TYPE_ICU]);
    ld_write(fdout, "seg_mmc_base            ",   periph_vbase_array[PERIPH_TYPE_MMC]);
    ld_write(fdout, "seg_tim_base            ",   periph_vbase_array[PERIPH_TYPE_TIM]);
    ld_write(fdout, "seg_xcu_base            ",   periph_vbase_array[PERIPH_TYPE_XCU]);

    file_write(fdout, "\n");

    ld_write(fdout, "vseg_cluster_increment  ",   header->increment);

    close(fdout);
}

//////////////////////////////////////////////////////
char * buildPath(const char * path, const char * name) 
{
    char * res = calloc(strlen(path) + strlen(name) + 1, 1);
    strcat(res, path);
    strcat(res, "/");
    strcat(res, name);
    return res; 
}


//////////////////////////////////
int main(int argc, char * argv[]) 
{
    if (argc < 3) {
        printf("Usage: xml2bin <input_file_path> <output_path>\n");
        return 1;
    }

    struct stat dir_st;
    if (stat( argv[2], &dir_st)) {
        perror("bad path");
        exit(1);
    }

    if ((dir_st.st_mode & S_IFDIR) == 0) {
        printf("path is not a dir: %s", argv[2] );
        exit(1);
    }

    char * map_path = buildPath(argv[2], "map.bin"); 
    char * ld_path = buildPath(argv[2], "giet_vsegs.ld"); 
    char * hd_path = buildPath(argv[2], "hard_config.h"); 

    LIBXML_TEST_VERSION;

    int status;
    xmlTextReaderPtr reader = xmlReaderForFile(argv[1], NULL, 0);

    if (reader != NULL) 
    {
        status = xmlTextReaderRead (reader);
        while (status == 1) 
        {
            const char * tag = (const char *) xmlTextReaderConstName(reader);

            if (strcmp(tag, "mapping_info") == 0) 
            { 
                headerNode(reader);
                prepareBuild();
                buildBin(map_path);
                genHd(hd_path);
                genLd(ld_path);
            }
            else 
            {
                printf("[XML ERROR] Wrong file type: \"%s\"\n", argv[1]);
                return 1;
            }
            status = xmlTextReaderRead(reader);
        }
        xmlFreeTextReader(reader);

        if (status != 0) 
        {
            printf("[XML ERROR] Wrong Syntax in \"%s\" file\n", argv[1]);
            return 1;
        }
    }
    return 0;
} // end main()


// Local Variables:
// tab-width: 4
// c-basic-offset: 4
// c-file-offsets:((innamespace . 0)(inline-open . 0))
// indent-tabs-mode: nil
// End:
// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4