source: soft/giet_vm/xml/xml_parser.c @ 188

Last change on this file since 188 was 188, checked in by karaoui, 12 years ago

removing DUSTRIBUTED_SCHEDULER
File size: 54.0 KB
Line 
1///////////////////////////////////////////////////////////////////////////////////////
2// File     : xml_parser.c
3// Date     : 14/04/2012
4// Author   : alain greiner
5// Copyright (c) UPMC-LIP6
6///////////////////////////////////////////////////////////////////////////////////////
7// This program translate an xml file containing a MAPPING_INFO data structure
8// to a binary file that can be directly loaded in the boot ROM and used by the GIET.
9// The C strcutures are defined in the mapping_info.h file.
10///////////////////////////////////////////////////////////////////////////////////////
11
12#include  <stdlib.h>
13#include  <fcntl.h>
14#include  <sys/types.h>
15#include  <sys/stat.h>
16#include  <unistd.h>
17#include  <stdio.h>
18#include  <string.h>
19#include  <assert.h>
20#include  <libxml/xmlreader.h>
21#include  <mapping_info.h>
22
23#define MAX_CLUSTERS    1024
24#define MAX_PSEGS               4096
25#define MAX_VSPACES             1024
26#define MAX_TASKS               4096
27#define MAX_MWMRS               4096
28#define MAX_VSEGS               4096
29#define MAX_VOBJS               8192
30#define MAX_PROCS               1024
31#define MAX_IRQS                8192
32#define MAX_COPROCS             4096
33#define MAX_CP_PORTS    8192
34#define MAX_CP_REGS             8192
35
36#define XML_PARSER_DEBUG        0
37
38///////////////////////////////////////////////////////////////////////////////////
39//      global variables used to store and index the data structures
40///////////////////////////////////////////////////////////////////////////////////
41
42mapping_header_t*       header;
43mapping_cluster_t*      cluster[MAX_CLUSTERS];  // cluster array
44mapping_pseg_t*         pseg[MAX_PSEGS];                // pseg array
45mapping_vspace_t*       vspace[MAX_VSPACES];    // vspace array
46mapping_vseg_t*         vseg[MAX_VSEGS];                // vseg array
47mapping_vobj_t*         vobj[MAX_VOBJS];                // vobj array
48mapping_task_t*         task[MAX_TASKS];                // task array
49mapping_proc_t*         proc[MAX_PROCS];                // proc array
50mapping_irq_t*          irq[MAX_IRQS];                  // irq array
51mapping_coproc_t*       coproc[MAX_COPROCS];            // coproc array
52mapping_coproc_port_t*  cp_port[MAX_CP_PORTS];  // coproc port array
53mapping_coproc_reg_t*   cp_reg[MAX_CP_REGS];     // coproc reg array
54
55typedef struct vobj_ref_s
56{
57    char vspace_name[32];
58    char vobj_name[32];
59}vobj_ref_t;
60
61// This arrray is useful to temporary save the a vobj referece
62// formed by a vspace_name and a vobj_name (struct vobj_ref_s).
63// This arry will be used to set the attribute vobj_id of coproc_port
64// once all the vspace have been parsed.
65vobj_ref_t*                 cp_port_vobj_ref[MAX_CP_PORTS];     
66
67unsigned int            cluster_index  = 0;
68unsigned int            vspace_index   = 0;
69unsigned int            global_index   = 0;
70unsigned int            pseg_index     = 0;             
71
72unsigned int            proc_index     = 0;
73unsigned int            proc_loc_index = 0;
74
75unsigned int            irq_index      = 0;
76unsigned int            irq_loc_index  = 0;
77
78unsigned int            coproc_index     = 0;
79unsigned int            coproc_loc_index = 0;
80
81unsigned int            cp_port_index     = 0;
82unsigned int            cp_port_loc_index = 0;
83
84unsigned int            cp_reg_index     = 0;
85unsigned int            cp_reg_loc_index = 0;
86
87unsigned int            vseg_index     = 0;
88unsigned int            vseg_loc_index = 0;
89unsigned int            task_index     = 0;
90unsigned int            task_loc_index = 0;
91unsigned int            vobj_index     = 0;
92unsigned int            vobj_loc_index = 0;
93unsigned int            vobj_count     = 0;
94
95unsigned int            tty_index      = 1;
96unsigned int            fb_index       = 0;
97           
98//////////////////////////////////////////////////
99unsigned int getIntValue( xmlTextReaderPtr reader, 
100                          const char*      attributeName, 
101                          unsigned int*    ok )
102{
103    unsigned int        value = 0;
104    unsigned int        i;
105    char        c;
106
107    char* string = (char*)xmlTextReaderGetAttribute(reader, (const xmlChar*)attributeName);
108
109    if ( string == NULL )  // missing argument
110    {
111        *ok = 0;
112        return 0;
113    }
114    else
115    {
116        if ( (string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X')) )  // Hexa
117        {
118            for ( i = 2 ; (string[i] != 0) && (i < 10) ; i++ )
119            {
120                c = string[i];
121                if      ((c >= '0') && (c <= '9')) value = (value<<4) + string[i] - 48;
122                else if ((c >= 'a') && (c <= 'f')) value = (value<<4) + string[i] - 87;
123                else if ((c >= 'A') && (c <= 'F')) value = (value<<4) + string[i] - 55;
124                else   
125                {
126                    *ok = 0;
127                    return 0;
128                }
129            }
130        }
131        else                                                            // Decimal
132        {
133            for ( i = 0 ; (string[i] != 0) && (i < 9) ; i++ )
134            {
135                c = string[i];
136                if ((c >= '0') && (c <= '9')) value = (value*10) + string[i] - 48;
137                else 
138                {
139                    *ok = 0;
140                    return 0;
141                }
142            }
143        }
144        *ok = 1;
145        return value; 
146    }
147} // end getIntValue()
148
149///////////////////////////////////////////////
150char* getStringValue ( xmlTextReaderPtr reader, 
151                       const char*      attributeName, 
152                       unsigned int*    ok )
153{
154    char* string = (char*)xmlTextReaderGetAttribute(reader, (const xmlChar*)attributeName);
155
156    if ( string == NULL )  // missing argument
157    {
158        *ok = 0;
159        return NULL;
160    }
161    else
162    {
163        *ok = 1;
164        return string;
165    }
166} // end getStringValue()
167
168///////////////////////////////////////
169int getPsegId( unsigned int     cluster_id,
170               char*        pseg_name )
171{
172    unsigned int pseg_id;
173    unsigned int pseg_min = cluster[cluster_id]->pseg_offset;
174    unsigned int pseg_max = pseg_min + cluster[cluster_id]->psegs;
175
176    for ( pseg_id = pseg_min ; pseg_id < pseg_max ; pseg_id++ )
177    {
178        if ( strcmp(pseg[pseg_id]->name, pseg_name) == 0 ) return pseg_id;
179    }
180    return -1;
181}
182
183////////////////////////////////////////////
184int getVspaceId( char*         vspace_name)
185////////////////////////////////////////////
186{
187    unsigned int vspace_id;
188
189    for( vspace_id = 0; vspace_id < vspace_index ; vspace_id++)
190    {
191        if( !strcmp(vspace[vspace_id]->name, vspace_name))
192        {
193            return vspace_id;
194        }
195    }
196    return -1;
197}
198
199////////////////////////////////////////////
200int getVobjLocId( unsigned int  vspace_id,
201                  char*             vobj_name,
202                  unsigned int  vspace_max)
203////////////////////////////////////////////
204{
205    unsigned int vobj_id;
206    unsigned int vobj_min = vspace[vspace_id]->vobj_offset;
207    unsigned int vobj_max = vobj_min + vspace_max;
208
209    for ( vobj_id = vobj_min ; vobj_id < vobj_max ; vobj_id++ )
210    {
211        if ( strcmp(vobj[vobj_id]->name, vobj_name) == 0 )
212        {
213             return (vobj_id - vobj_min);
214        }
215    }
216    return -1;
217}
218
219///////////////////////////////////////////
220void cpPortNode ( xmlTextReaderPtr reader )
221///////////////////////////////////////////
222{
223    char*           str;
224    unsigned int    ok;
225
226    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
227
228    if ( cp_port_index >= MAX_CP_PORTS )
229    {
230        printf("[XML ERROR] The number of ports (for coprocs) is larger than %d\n", MAX_CP_PORTS);
231    }
232
233#if XML_PARSER_DEBUG
234printf("\n  port %d\n", cp_port_index);
235#endif
236
237    cp_port[cp_port_index] = (mapping_coproc_port_t*)malloc(sizeof(mapping_coproc_port_t));
238    cp_port_vobj_ref[cp_port_index] = (vobj_ref_t*)malloc(sizeof(vobj_ref_t));
239
240
241   
242    ///////// get direction attribute
243    str = getStringValue( reader, "direction", &ok );
244    if ( ok )
245    {
246#if XML_PARSER_DEBUG
247printf("      direction = %s\n", str);
248#endif
249        if      ( strcmp(str, "TO_COPROC")   ) cp_port[cp_port_index]->direction = PORT_TO_COPROC;
250        else if ( strcmp(str, "FROM_COPROC") ) cp_port[cp_port_index]->direction = PORT_FROM_COPROC;
251        else
252        {
253            printf("[XML ERROR] illegal <direction> for coproc_port %d in cluster %d\n",
254                   cp_port_index, cluster_index);
255            exit(1);
256        }
257    } 
258    else
259    {
260        printf("[XML ERROR] missing <direction> for coproc_port %d in cluster %d\n",
261               cp_port_index, cluster_index);
262        exit(1);
263    }
264   
265    /////////// get vspacename attribute
266    str = getStringValue( reader, "vspacename", &ok );
267#if XML_PARSER_DEBUG
268printf("      vspacename = %s\n", str);
269#endif
270    if ( ok ) 
271    {
272        strncpy(cp_port_vobj_ref[cp_port_index]->vspace_name, str, 31);
273    }
274    else
275    {
276        printf("[XML ERROR] missing <vspacename> for coproc_port %d in cluster %d\n",
277               cp_port_index, cluster_index);
278        exit(1);
279    }
280
281    /////////// get vobjname attribute
282    str = getStringValue( reader, "vobjname", &ok );
283#if XML_PARSER_DEBUG
284printf("      vobjname = %s\n", str);
285#endif
286    if ( ok ) 
287    {
288        strncpy(cp_port_vobj_ref[cp_port_index]->vobj_name, str, 31);
289    }
290    else
291    {
292        printf("[XML ERROR] missing <vobjname> for coproc_port %d in cluster %d\n",
293               cp_port_index, cluster_index);
294        exit(1);
295    }
296   
297    cp_port_index++;
298    cp_port_loc_index++;
299
300} // end cpPortNode()
301
302/////////////////////////////////////////
303void cpRegNode ( xmlTextReaderPtr reader )
304/////////////////////////////////////////
305{
306    char*           str;
307    unsigned int    value;
308    unsigned int    ok;
309
310    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
311
312    /* TWO: check source file consistency if possible */
313    if ( cp_reg_index >= MAX_CP_REGS )
314    {
315        printf("[XML ERROR] The number of regs (for coprocs) is larger than %d\n", MAX_CP_REGS);
316    }
317
318#if XML_PARSER_DEBUG
319printf("\n  reg %d\n", cp_reg_index);
320#endif
321
322    /* THIRD*/
323    cp_reg[cp_reg_index] = (mapping_coproc_reg_t*)malloc(sizeof(mapping_coproc_reg_t));
324
325    /* FOURTH: read all attribute*/
326
327    /////////// get name attribute
328    str = getStringValue( reader, "name", &ok );
329#if XML_PARSER_DEBUG
330printf("      name = %s\n", str);
331#endif
332    if ( ok ) 
333    {
334        strncpy(cp_reg[cp_reg_index]->name, str, 31);
335    }
336    else
337    {
338        printf("[XML ERROR] illegal or missing <name> for coproc_reg %d in cluster %d\n",
339               cp_reg_index, cluster_index);
340        exit(1);
341    }
342   
343    ///////// get type attribute
344    str = getStringValue( reader, "type", &ok );
345    if ( ok )
346    {
347#if XML_PARSER_DEBUG
348printf("      type = %s\n", str);
349#endif
350        if      ( strcmp(str, "STATUS")   ) cp_reg[cp_reg_index]->type = REG_TYPE_STATUS;
351        else if ( strcmp(str, "CONFIG")   ) cp_reg[cp_reg_index]->type = REG_TYPE_CONFIG;
352        else
353        {
354            printf("[XML ERROR] illegal <type> for coproc_reg %d in cluster %d\n",
355                   cp_reg_index, cluster_index);
356            exit(1);
357        }
358    } 
359    else
360    {
361        printf("[XML ERROR] missing <type> for coproc_reg %d in cluster %d\n",
362               cp_reg_index, cluster_index);
363        exit(1);
364    }
365
366    ///////// get value attribute
367    value = getIntValue(reader, "value", &ok);
368    if ( ok )
369    {
370#if XML_PARSER_DEBUG
371printf("        value   = %d\n", value);
372#endif
373        cp_reg[cp_reg_index]->value = value;
374    }
375    else
376    {
377        printf("[XML ERROR] illegal or missing <value> for coproc_reg %d in cluster %d\n",
378               cp_reg_index, cluster_index);
379        exit(1);
380    }
381
382    ///////// get channel attribute
383    value = getIntValue(reader, "channel", &ok);
384    if ( ok )
385    {
386#if XML_PARSER_DEBUG
387printf("        channel   = %d\n", value);
388#endif
389        cp_reg[cp_reg_index]->channel_id = value;
390    }
391    else
392    {
393        printf("[XML ERROR] illegal or missing <channel> for coproc_reg %d in cluster %d\n",
394               cp_reg_index, cluster_index);
395        exit(1);
396    }
397
398    ///////// get index attribute
399    value = getIntValue(reader, "index", &ok);
400    if ( ok )
401    {
402#if XML_PARSER_DEBUG
403printf("        index   = %d\n", value);
404#endif
405        cp_reg[cp_reg_index]->loc_id = value;
406    }
407    else
408    {
409        printf("[XML ERROR] illegal or missing <index> for coproc_reg %d in cluster %d\n",
410               cp_reg_index, cluster_index);
411        exit(1);
412    }
413   
414    cp_reg_index++;
415    cp_reg_loc_index++;
416
417} // end cpRegNode()
418
419/////////////////////////////////////////
420void coprocNode ( xmlTextReaderPtr reader )
421/////////////////////////////////////////
422{
423    char*           str;
424    unsigned int        ok;
425
426    cp_port_loc_index = 0;
427    cp_reg_loc_index = 0;
428
429    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
430
431    if ( coproc_index >= MAX_COPROCS )
432    {
433        printf("[XML ERROR] The number of coprocs is larger than %d\n", MAX_COPROCS);
434    }
435
436#if XML_PARSER_DEBUG
437printf("\n  coproc %d\n", coproc_index);
438#endif
439
440    coproc[coproc_index] = (mapping_coproc_t*)malloc(sizeof(mapping_coproc_t));
441
442
443    /////////// get name attribute
444    str = getStringValue( reader, "name", &ok );
445    if ( ok ) 
446    {
447#if XML_PARSER_DEBUG
448printf("      name = %s\n", str);
449#endif
450        strncpy(coproc[coproc_index]->name, str, 31);
451    }
452    else
453    {
454        printf("[XML ERROR] illegal or missing <name> for coproc %d in cluster %d\n",
455               coproc_index, cluster_index);
456        exit(1);
457    }
458
459    /////////// get psegname attribute
460    str = getStringValue(reader,"psegname", &ok);
461    if ( ok == 0 )
462    {
463        printf("[XML ERROR] illegal or missing <psegname> for coproc %d in cluster %d\n", 
464                 coproc_index, cluster_index);
465        exit(1);
466    }
467
468    /////////// set psegid attribute
469    int index = getPsegId( cluster_index, str );
470    if ( index >= 0 ) 
471    {
472#if XML_PARSER_DEBUG
473printf("      clusterid = %d\n", cluster_index);
474printf("      psegname  = %s\n", str);
475printf("      psegid    = %d\n", index);
476#endif
477        coproc[coproc_index]->psegid = index;
478        assert(pseg[index]->type == PSEG_TYPE_PERI && "coproc psegname attribute must refer to a pseg of type PERI" );
479    }
480    else             
481    {
482        printf("[XML ERROR] pseg not found for coproc %d / clusterid = %d / psegname = %s\n", 
483                   coproc_index, cluster_index, str );
484        exit(1);
485    } 
486
487    ////////// set port_offset and reg_offset attribute
488    coproc[coproc_index]->port_offset = cp_port_index;
489    coproc[coproc_index]->reg_offset = cp_reg_index;
490
491#if XML_PARSER_DEBUG
492printf("    port_offset = %d\n", cp_port_index);
493printf("    reg_offset = %d\n", cp_reg_index);
494#endif
495
496    int status = xmlTextReaderRead(reader);
497    while ( status == 1 ) 
498    {
499        const char* tag = (const char*)xmlTextReaderConstName(reader);
500
501        if      ( strcmp(tag,"port")    == 0 ) cpPortNode(reader);
502        else if ( strcmp(tag,"reg")   == 0 ) cpRegNode(reader);
503        else if ( strcmp(tag,"#text"  ) == 0 ) { }
504        else if ( strcmp(tag,"#comment") == 0 );
505        else if ( strcmp(tag,"coproc")  == 0 ) 
506        {
507            coproc[coproc_index]->ports = cp_port_loc_index;
508            coproc[coproc_index]->regs = cp_reg_loc_index;
509            coproc_loc_index++;
510            coproc_index++;
511            return;
512        }
513        else 
514        {
515            printf("[XML ERROR] Unknown tag %s",tag);
516            exit(1);
517        }
518        status = xmlTextReaderRead ( reader );
519    }
520} // end coprocNode()
521
522///////////////////////////////////////
523void irqNode( xmlTextReaderPtr reader )
524///////////////////////////////////////
525{
526    unsigned int        ok;
527    unsigned int        value;
528    char*               str;
529
530    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
531
532    if ( irq_index >= MAX_IRQS )
533    {
534        printf("[XML ERROR] The number of irqs is larger than %d\n", MAX_IRQS);
535    }
536
537#if XML_PARSER_DEBUG
538printf("     irq %d\n", irq_loc_index);
539#endif
540
541    irq[irq_index] = (mapping_irq_t*)malloc(sizeof(mapping_irq_t));
542
543    ///////// get type attribute
544    str = getStringValue(reader,"type", &ok);
545    if ( ok )
546    {
547#if XML_PARSER_DEBUG
548printf("        type    = %s\n", str);
549#endif
550        if      ( strcmp(str, "HARD") ) irq[irq_index]->type = IRQ_TYPE_HARD;
551        else if ( strcmp(str, "SOFT") ) irq[irq_index]->type = IRQ_TYPE_SOFT;
552        else
553        {
554            printf("[XML ERROR] undefined IRQ  <type> for processor %d in cluster %d\n",
555                   cluster_index, proc_loc_index );
556            exit(1);
557        }
558    } 
559    else
560    {
561        printf("[XML ERROR] missing IRQ <type> for processor %d in cluster %d\n",
562               cluster_index, proc_loc_index );
563        exit(1);
564    }
565
566    ///////// get irqid attribute
567    value = getIntValue(reader, "icuid", &ok);
568    if ( ok )
569    {
570#if XML_PARSER_DEBUG
571printf("        icuid   = %d\n", value);
572#endif
573        irq[irq_index]->icuid = value;
574        if ( value >= 32 )
575        {
576            printf("[XML ERROR] IRQ <icuid> too large for processor %d in cluster %d\n",
577                   cluster_index, proc_loc_index );
578            exit(1);
579        }
580    }
581    else
582    {
583        printf("[XML ERROR] missing IRQ <icuid> for processor %d in cluster %d\n",
584               cluster_index, proc_loc_index );
585        exit(1);
586    }
587
588    ///////// get isr attribute
589    str = getStringValue(reader,"isr", &ok);
590    if ( ok )
591    {
592#if XML_PARSER_DEBUG
593printf("        isr     = %s\n", str);
594#endif
595        if      ( strcmp(str, "ISR_SWITCH") ) irq[irq_index]->isr = ISR_SWITCH;
596        else if ( strcmp(str, "ISR_IOC")    ) irq[irq_index]->isr = ISR_IOC;
597        else if ( strcmp(str, "ISR_FBDMA")  ) irq[irq_index]->isr = ISR_FBDMA;
598        else if ( strcmp(str, "ISR_TTY")    ) irq[irq_index]->isr = ISR_TTY;
599        else
600        {
601            printf("[XML ERROR] illegal IRQ <isr> for processor %d in cluster %d\n",
602                   cluster_index, proc_loc_index );
603            exit(1);
604        }
605    } 
606    else
607    {
608        printf("[XML ERROR] missing IRQ <isr> for processor %d in cluster %d\n",
609               cluster_index, proc_loc_index );
610        exit(1);
611    }
612
613    ///////// get channel attribute (optionnal : 0 if missing)
614    value = getIntValue(reader, "channel", &ok);
615    if ( ok )
616    {
617#if XML_PARSER_DEBUG
618printf("        channel = %d\n", value);
619#endif
620        irq[irq_index]->channel = value;
621    }
622    else
623    {
624        irq[irq_index]->channel = 0;
625    }
626
627    irq_index++;
628    irq_loc_index++;
629
630} // end irqNode
631
632/////////////////////////////////////////
633void procNode ( xmlTextReaderPtr reader )
634/////////////////////////////////////////
635{
636    unsigned int        ok;
637    unsigned int    value;
638
639    irq_loc_index = 0;
640
641    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
642
643    if ( proc_index >= MAX_PROCS )
644    {
645        printf("[XML ERROR] The number of procs is larger than %d\n", MAX_PROCS);
646    }
647
648#if XML_PARSER_DEBUG
649printf("\n  proc %d\n", proc_index);
650#endif
651
652    proc[proc_index] = (mapping_proc_t*)malloc(sizeof(mapping_proc_t));
653
654
655    /////////// get index attribute (optional)
656    value = getIntValue(reader,"index",&ok);
657    if ( ok && (value != proc_index) )
658    {
659            printf("[XML ERROR] wrong proc index / expected value is %d", 
660                proc_index);
661            exit(1);
662    }
663
664    ////////// set irq_offset attribute
665    proc[proc_index]->irq_offset = irq_index;
666#if XML_PARSER_DEBUG
667printf("    irq_offset = %d\n", irq_index);
668#endif
669
670    int status = xmlTextReaderRead(reader);
671    while ( status == 1 ) 
672    {
673        const char* tag = (const char*)xmlTextReaderConstName(reader);
674
675        if      ( strcmp(tag,"irq")    == 0 ) irqNode(reader);
676        else if ( strcmp(tag,"#text")   == 0 ) { }
677        else if ( strcmp(tag,"#comment") == 0 );
678        else if ( strcmp(tag,"proc")  == 0 ) 
679        {
680            proc[proc_index]->irqs = irq_loc_index;
681            proc_loc_index++;
682            proc_index++;
683            return;
684        }
685        else 
686        {
687            printf("[XML ERROR] Unknown tag %s",tag);
688            exit(1);
689        }
690        status = xmlTextReaderRead ( reader );
691    }
692} // end procNode()
693
694
695/////////////////////////////////////////
696void taskNode ( xmlTextReaderPtr reader )
697/////////////////////////////////////////
698{
699    unsigned int        ok;
700    unsigned int        value;
701    char*               str;
702
703    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
704
705    if ( task_index >= MAX_TASKS )
706    {
707        printf("[XML ERROR] The number of tasks is larger than %d\n", MAX_TASKS);
708    }
709
710#if XML_PARSER_DEBUG
711printf("   task %d\n", task_loc_index);
712#endif
713
714    task[task_index] = (mapping_task_t*)malloc(sizeof(mapping_task_t));
715
716    ////////// get name attribute
717    str = getStringValue(reader, "name", &ok);
718    if ( ok )
719    {
720#if XML_PARSER_DEBUG
721printf("      name = %s\n", str);
722#endif
723        strncpy( task[task_index]->name, str, 31 );
724    }
725    else
726    {
727        printf("[XML ERROR] illegal or missing <name> attribute for task (%d,%d)\n", 
728               vspace_index, task_loc_index);
729        exit(1);
730    }
731
732    ///////// get clusterid attribute
733    value = getIntValue(reader,"clusterid", &ok);
734    if ( ok )
735    {
736#if XML_PARSER_DEBUG
737printf("      clusterid = %x\n", value);
738#endif
739        if ( value >= header->clusters )
740        {
741            printf("[XML ERROR] <clusterid> too large for task (%d,%d)\n",
742                   vspace_index, task_loc_index);
743            exit(1);
744        }
745        task[task_index]->clusterid = value;
746    } 
747    else
748    {
749        printf("[XML ERROR] illegal or missing <clusterid> attribute for task (%d,%d)\n",
750               vspace_index, task_loc_index);
751        exit(1);
752    }
753
754    ////////// get proclocid attribute
755    value = getIntValue(reader,"proclocid", &ok);
756    if ( ok )
757    {
758#if XML_PARSER_DEBUG
759printf("      proclocid = %x\n", value);
760#endif
761        if ( value >= cluster[task[task_index]->clusterid]->procs )
762        {
763            printf("[XML ERROR] <proclocid> too large for task (%d,%d)\n",
764                   vspace_index, task_loc_index);
765            exit(1);
766        }
767        task[task_index]->proclocid = value;
768    } 
769    else
770    {
771        printf("[XML ERROR] illegal or missing <locprocid> attribute for task (%d,%d)\n", 
772                vspace_index, task_loc_index);
773        exit(1);
774    }
775
776    ////////// get stackname attribute
777    str = getStringValue(reader, "stackname" , &ok);
778    if ( ok )
779    {
780        int index = getVobjLocId( vspace_index, str , vobj_loc_index);
781        if ( index >= 0 ) 
782        {
783#if XML_PARSER_DEBUG
784printf("      stackname = %s\n", str);
785printf("      stackid   = %d\n", index);
786#endif
787            task[task_index]->vobjlocid = index;
788        }
789        else             
790        {
791            printf("[XML ERROR] illegal or missing <stackname> for task (%d,%d)\n", 
792                    vspace_index, task_loc_index);
793            exit(1);
794        }
795    } 
796    else
797    {
798        printf("[XML ERROR] illegal or missing <stackname> for task (%d,%d)\n", 
799                vspace_index, task_loc_index);
800        exit(1);
801    }
802
803    ////////// get startid  attribute
804    value = getIntValue(reader,"startid", &ok);
805    if ( ok )
806    {
807#if XML_PARSER_DEBUG
808printf("      startid = %x\n", value);
809#endif
810        task[task_index]->startid = value;
811    } 
812    else
813    {
814        printf("[XML ERROR] illegal or missing <startid> attribute for task (%d,%d)\n", 
815                vspace_index, task_loc_index);
816        exit(1);
817    }
818
819    /////////// get use_tty  attribute (optionnal : 0 if missing)
820    value = getIntValue(reader,"usetty", &ok);
821    if ( ok )
822    {
823#if XML_PARSER_DEBUG
824printf("      usetty = %x\n", value);
825#endif
826        if ( (value != 0) && (tty_index >= header->ttys) )
827        {
828            printf("[XML ERROR] The tty index is too large for task (%d,%d)\n", 
829                vspace_index, task_loc_index);
830            exit(1);
831        }
832        task[task_index]->use_tty = value;
833        if (value != 0) tty_index++;
834    } 
835    else
836    {
837        task[task_index]->use_tty = 0;
838    }
839
840    /////////// get use_fb  attribute (optionnal : 0 if missing)
841    value = getIntValue(reader,"usefb", &ok);
842    if ( ok )
843    {
844#if XML_PARSER_DEBUG
845printf("      usefb = %x\n", value);
846#endif
847        if ( (value != 0) && (fb_index >= header->fbs) )
848        {
849            printf("[XML ERROR] The fb channel index is too large for task (%d,%d)\n", 
850                vspace_index, task_loc_index);
851            exit(1);
852        }
853        task[task_index]->use_fb = value;
854        if (value != 0) fb_index++;
855    } 
856    else
857    {
858        task[task_index]->use_fb = 0;
859    }
860
861    task_index++;
862    task_loc_index++;
863} // end taskNode()
864
865//////////////////////////////////////////
866void  vobjNode ( xmlTextReaderPtr reader )
867{
868    unsigned int        ok;
869    unsigned int        value;
870    char*               str;
871
872    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
873
874    if ( vobj_index >= MAX_VOBJS )
875    {
876        printf("[XML ERROR] The number of vobjs is larger than %d\n", MAX_VSEGS);
877        exit(1);
878    }
879
880#if XML_PARSER_DEBUG
881printf("      vobj %d\n", vobj_loc_index);
882#endif
883
884    vobj[vobj_index] = (mapping_vobj_t*)malloc(sizeof(mapping_vobj_t));
885
886    ///////// get name attribute
887    str = getStringValue(reader, "name", &ok);
888    if ( ok )
889    {
890#if XML_PARSER_DEBUG
891printf("        name = %s\n", str);
892#endif
893        strncpy( vobj[vobj_index]->name, str, 31);
894    }
895    else
896    {
897        printf("[XML ERROR] illegal or missing <name> attribute for vobj (%d,%d)\n", 
898                vseg_index, vobj_loc_index);
899        exit(1);
900    }
901
902    //////// get type attribute
903    str = getStringValue(reader, "type", &ok);
904#if XML_PARSER_DEBUG
905printf("        type = %s\n", str);
906#endif
907    if (ok && (strcmp(str, "ELF") == 0))
908    {
909        vobj[vobj_index]->type = VOBJ_TYPE_ELF;
910
911        //check that this vobj is the first in vseg
912        if(vobj_count != 0) 
913        {
914            printf("[XML ERROR] an ELF vobj must be alone in a vseg (%d,%d)\n", 
915                    vspace_index, vobj_loc_index);
916            exit(1);
917        }
918    }
919    else if (ok && (strcmp(str, "BLOB")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_BLOB;
920    else if (ok && (strcmp(str, "PTAB")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_PTAB;
921    else if (ok && (strcmp(str, "PERI")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_PERI;
922    else if (ok && (strcmp(str, "MWMR")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_MWMR;
923    else if (ok && (strcmp(str, "LOCK")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_LOCK;
924    else if (ok && (strcmp(str, "BUFFER")  == 0)) vobj[vobj_index]->type = VOBJ_TYPE_BUFFER;
925    else if (ok && (strcmp(str, "BARRIER") == 0)) vobj[vobj_index]->type = VOBJ_TYPE_BARRIER;
926    else
927    {
928        printf("[XML ERROR] illegal or missing <type> attribute for vobj (%d,%d)\n", 
929                vspace_index, vobj_loc_index);
930        exit(1);
931    }
932
933    ////////// get length attribute
934    value = getIntValue(reader,"length", &ok);
935    if ( ok )
936    {
937#if XML_PARSER_DEBUG
938printf("        length = %d\n", value);
939#endif
940        vobj[vobj_index]->length = value;
941    } 
942    else
943    {
944        printf("[XML ERROR] illegal or missing <length> attribute for vobj (%d,%d)\n", 
945                vspace_index, vobj_loc_index);
946        exit(1);
947    }
948
949    ////////// get align attribute (optional : 0 if missing)
950    value = getIntValue(reader,"align", &ok);
951    if ( ok )
952    {
953#if XML_PARSER_DEBUG
954printf("        align = %d\n", value);
955#endif
956        vobj[vobj_index]->align = value;
957    } 
958    else
959    {
960        vobj[vobj_index]->align = 0;
961    }
962
963    ////////// get binpath attribute (optional : '\0' if missing)
964    str = getStringValue(reader, "binpath", &ok);
965    if ( ok )
966    {
967#if XML_PARSER_DEBUG
968printf("        binpath = %s\n", str);
969#endif
970        strncpy(vobj[vobj_index]->binpath, str, 63);
971    } 
972    else
973    {
974        vobj[vobj_index]->binpath[0] = '\0';
975    }
976   
977    ////////// get init attribute (mandatory for mwmr and barrier)
978    value = getIntValue(reader,"init", &ok);
979    if ( ok )
980    {
981#if XML_PARSER_DEBUG
982printf("        init  = %d\n", value);
983#endif
984        vobj[vobj_index]->init = value;
985    } 
986    else
987    {
988        if((vobj[vobj_index]->type == VOBJ_TYPE_MWMR || vobj[vobj_index]->type == VOBJ_TYPE_BARRIER ))
989        {
990            printf("[XML ERROR] illegal or missing <value> attribute for vobj (%d,%d). \
991                                        All MWMR or BARRIER vobj must have a init value \n", 
992                    vspace_index, vobj_loc_index);
993            exit(1);
994        }
995        vobj[vobj_index]->init = 0;
996    }
997
998    vobj_index++;
999    vobj_count++;
1000    vobj_loc_index++;
1001} // end vobjNode()
1002
1003//////////////////////////////////////////
1004void  vsegNode ( xmlTextReaderPtr reader )
1005{
1006    unsigned int        ok;
1007    unsigned int        value;
1008    char*               str;
1009
1010        vobj_count = 0;
1011
1012    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
1013
1014    if ( vseg_index >= MAX_VSEGS )
1015    {
1016        printf("[XML ERROR] The number of vsegs is larger than %d\n", MAX_VSEGS);
1017        exit(1);
1018    }
1019
1020#if XML_PARSER_DEBUG
1021printf("    vseg %d\n", vseg_loc_index);
1022#endif
1023
1024    vseg[vseg_index] = (mapping_vseg_t*)malloc(sizeof(mapping_vseg_t));
1025   
1026    ////////// set vobj_offset attributes
1027    vseg[vseg_index]->vobj_offset = vobj_index;
1028#if XML_PARSER_DEBUG
1029printf("      vobj_offset = %d\n", vobj_index);
1030#endif
1031
1032    ///////// get name attribute
1033    str = getStringValue(reader, "name", &ok);
1034    if ( ok )
1035    {
1036#if XML_PARSER_DEBUG
1037printf("      name = %s\n", str);
1038#endif
1039        strncpy( vseg[vseg_index]->name, str, 31);
1040    }
1041    else
1042    {
1043        printf("[XML ERROR] illegal or missing <name> attribute for vseg (%d,%d)\n", 
1044                vspace_index, vseg_loc_index);
1045        exit(1);
1046    }
1047
1048    /////////// get vbase attribute
1049    value = getIntValue(reader,"vbase", &ok);
1050    if ( ok ) 
1051    {
1052#if XML_PARSER_DEBUG
1053printf("      vbase = 0x%x\n", value);
1054#endif
1055        vseg[vseg_index]->vbase = value;
1056    }
1057    else
1058    {
1059        printf("[XML ERROR] illegal or missing <vbase> attribute for vseg (%d,%d)\n", 
1060                vspace_index, vseg_loc_index);
1061        exit(1);
1062    }
1063
1064    ////////// get clusterid and psegname attributes
1065    value = getIntValue(reader,"clusterid", &ok);
1066    if ( ok == 0 )
1067    {
1068        printf("[XML ERROR] illegal or missing <clusterid> for vseg %d\n", 
1069                 vseg_loc_index);
1070        exit(1);
1071    }
1072    str = getStringValue(reader,"psegname", &ok);
1073    if ( ok == 0 )
1074    {
1075        printf("[XML ERROR] illegal or missing <psegname> for vseg %d\n", 
1076                 vseg_loc_index);
1077        exit(1);
1078    }
1079
1080    /////////// set psegid field
1081    int index = getPsegId( value, str );
1082    if ( index >= 0 ) 
1083    {
1084#if XML_PARSER_DEBUG
1085printf("      clusterid = %d\n", value);
1086printf("      psegname  = %s\n", str);
1087printf("      psegid    = %d\n", index);
1088#endif
1089        vseg[vseg_index]->psegid = index;
1090    }
1091    else             
1092    {
1093        printf("[XML ERROR] pseg not found for vseg %d / clusterid = %d / psegname = %s\n", 
1094                   vseg_loc_index, value, str );
1095        exit(1);
1096    } 
1097
1098    ////////// get ident attribute (optional : 0 if missing)
1099    value = getIntValue(reader,"ident", &ok);
1100    if ( ok )
1101    {
1102#if XML_PARSER_DEBUG
1103printf("      ident = %d\n", value);
1104#endif
1105        vseg[vseg_index]->ident = value;
1106    } 
1107    else
1108    {
1109        vseg[vseg_index]->ident = 0;
1110    }
1111
1112    //////// get mode attribute
1113    str = getStringValue(reader,"mode", &ok);
1114#if XML_PARSER_DEBUG
1115printf("      mode = %s\n", str);
1116#endif
1117    if      (ok && (strcmp(str, "CXWU") == 0)) vseg[vseg_index]->mode = 0xF;
1118    else if (ok && (strcmp(str, "CXW_") == 0)) vseg[vseg_index]->mode = 0xE;
1119    else if (ok && (strcmp(str, "CX_U") == 0)) vseg[vseg_index]->mode = 0xD;
1120    else if (ok && (strcmp(str, "CX__") == 0)) vseg[vseg_index]->mode = 0xC;
1121    else if (ok && (strcmp(str, "C_WU") == 0)) vseg[vseg_index]->mode = 0xB;
1122    else if (ok && (strcmp(str, "C_W_") == 0)) vseg[vseg_index]->mode = 0xA;
1123    else if (ok && (strcmp(str, "C__U") == 0)) vseg[vseg_index]->mode = 0x9;
1124    else if (ok && (strcmp(str, "C___") == 0)) vseg[vseg_index]->mode = 0x8;
1125    else if (ok && (strcmp(str, "_XWU") == 0)) vseg[vseg_index]->mode = 0x7;
1126    else if (ok && (strcmp(str, "_XW_") == 0)) vseg[vseg_index]->mode = 0x6;
1127    else if (ok && (strcmp(str, "_X_U") == 0)) vseg[vseg_index]->mode = 0x5;
1128    else if (ok && (strcmp(str, "_X__") == 0)) vseg[vseg_index]->mode = 0x4;
1129    else if (ok && (strcmp(str, "__WU") == 0)) vseg[vseg_index]->mode = 0x3;
1130    else if (ok && (strcmp(str, "__W_") == 0)) vseg[vseg_index]->mode = 0x2;
1131    else if (ok && (strcmp(str, "___U") == 0)) vseg[vseg_index]->mode = 0x1;
1132    else if (ok && (strcmp(str, "____") == 0)) vseg[vseg_index]->mode = 0x0;
1133    else
1134    {
1135        printf("[XML ERROR] illegal or missing <mode> attribute for vseg (%d,%d)\n", 
1136                vspace_index, vseg_loc_index);
1137        exit(1);
1138    }
1139   
1140    ////////// get vobjs in vseg
1141    int status = xmlTextReaderRead(reader);
1142    while ( status == 1 ) 
1143    {
1144        const char* tag = (const char*)xmlTextReaderConstName(reader);
1145
1146        if      ( strcmp(tag,"vobj")    == 0 ) vobjNode(reader);
1147        else if ( strcmp(tag,"#text"  ) == 0 ) { }
1148        else if ( strcmp(tag,"vseg")    == 0 ) 
1149        {
1150            vseg[vseg_index]->vobjs = vobj_count;
1151            vseg_index++;
1152            vseg_loc_index++;
1153            return;
1154        }
1155        else 
1156        {
1157            printf("[XML ERROR] Unknown tag %s",tag);
1158            exit(1);
1159        }
1160        status = xmlTextReaderRead ( reader );
1161    }
1162} // end vsegNode()
1163
1164//////////////////////////////////////////
1165void vspaceNode( xmlTextReaderPtr reader )
1166{
1167    char*               str;
1168    unsigned int        ok;
1169
1170    vobj_loc_index = 0;
1171        vseg_loc_index = 0;
1172        task_loc_index = 0;
1173
1174    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
1175
1176    // checking source file consistency
1177    if ( vspace_index >= header->vspaces )
1178    {
1179        printf("[XML ERROR] The vspace index is too large : %d\n", 
1180                 vspace_index);
1181        exit(1);
1182    }
1183
1184#if XML_PARSER_DEBUG
1185printf("\n  vspace %d\n", vspace_index);
1186#endif
1187
1188    vspace[vspace_index] = (mapping_vspace_t*)malloc(sizeof(mapping_vspace_t));
1189
1190    ////////// get name attribute
1191    str = getStringValue(reader, "name", &ok);
1192    if ( ok )
1193    {
1194#if XML_PARSER_DEBUG
1195printf("  name = %s\n", str);
1196#endif
1197        strncpy(vspace[vspace_index]->name, str, 31);
1198    }
1199    else
1200    {
1201        printf("[XML ERROR] illegal or missing <name> attribute for vspace %d\n", 
1202                 vspace_index);
1203        exit(1);
1204    }
1205
1206    ////////// set vseg_offset and task_offset attributes
1207    vspace[vspace_index]->vseg_offset = vseg_index;
1208    vspace[vspace_index]->vobj_offset = vobj_index;
1209    vspace[vspace_index]->task_offset = task_index;
1210   
1211#if XML_PARSER_DEBUG
1212printf("  vseg_offset = %d\n", vseg_index);
1213printf("  vobj_offset = %d\n", vobj_index);
1214printf("  task_offset = %d\n", task_index);
1215#endif
1216
1217    ////////// get startname attribute
1218    str = getStringValue(reader, "startname", &ok);
1219    if ( ok )
1220    {
1221        //used after parsing the vobjs
1222    }
1223    else
1224    {
1225        printf("[XML ERROR] illegal or missing <startname> attribute for vspace %d\n", 
1226                 vspace_index);
1227        exit(1);
1228    }
1229
1230    int status = xmlTextReaderRead(reader);
1231    while ( status == 1 ) 
1232    {
1233        const char* tag = (const char*)xmlTextReaderConstName(reader);
1234
1235        if      ( strcmp(tag,"vseg")    == 0 ) vsegNode(reader);
1236        else if ( strcmp(tag,"task")    == 0 ) taskNode(reader);
1237        else if ( strcmp(tag,"#text")   == 0 ) { }
1238        else if ( strcmp(tag,"#comment") == 0 );
1239        else if ( strcmp(tag,"vspace")  == 0 ) 
1240        {
1241            vspace[vspace_index]->vobjs = vobj_loc_index; 
1242            vspace[vspace_index]->tasks = task_loc_index ;
1243            vspace[vspace_index]->vsegs = vseg_loc_index ;
1244
1245            // get index of the vobj containing the start vector
1246            int index =  getVobjLocId( vspace_index, str , vobj_loc_index );
1247            if(index == -1)
1248            {
1249                printf("[XML ERROR] vobj containing the start vector not found %s\n",str);
1250                exit(-1);
1251            }
1252            else
1253            {
1254                vspace[vspace_index]->start_offset = index;
1255#if XML_PARSER_DEBUG
1256printf("      startname = %s\n", str);
1257printf("      startid   = %d\n", index);
1258printf("  end vspace %d\n\n", vspace_index);
1259#endif
1260            }
1261
1262            // checking startid values for all tasks in vspace
1263            int task_id;
1264            int task_min = vspace[vspace_index]->task_offset;
1265            int task_max = task_min + vspace[vspace_index]->tasks; 
1266            for ( task_id = task_min ; task_id < task_max ; task_id++ )
1267            {
1268                if ( task[task_id]->startid >= vspace[vspace_index]->tasks )
1269                {
1270                    printf("[XML ERROR] <startid> too large for task (%d,%d)\n", 
1271                           vspace_index, task_id );
1272                    exit(1);
1273                }
1274            }
1275
1276            vspace_index++;
1277            return;
1278        }
1279        else 
1280        {
1281            printf("[XML ERROR] Unknown tag %s",tag);
1282            exit(1);
1283        }
1284        status = xmlTextReaderRead ( reader );
1285    }
1286} // end vspaceNode()
1287
1288//////////////////////////////////////////
1289void  psegNode ( xmlTextReaderPtr reader )
1290{
1291    unsigned int        ok;
1292    unsigned int        value;
1293    char*               str;
1294
1295    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
1296
1297    if ( pseg_index >= MAX_PSEGS )
1298    {
1299        printf("[XML ERROR] The number of psegs is larger than %d\n", MAX_PSEGS);
1300        exit(1);
1301    }
1302
1303#if XML_PARSER_DEBUG
1304printf("    pseg %d\n", pseg_index);
1305#endif
1306
1307    pseg[pseg_index] = (mapping_pseg_t*)malloc(sizeof(mapping_pseg_t));
1308
1309    /////// get name attribute
1310    str = getStringValue( reader, "name", &ok );
1311#if XML_PARSER_DEBUG
1312printf("      name = %s\n", str);
1313#endif
1314    if ( ok ) 
1315    {
1316        strncpy(pseg[pseg_index]->name, str, 31);
1317    }
1318    else
1319    {
1320        printf("[XML ERROR] illegal or missing <name> for pseg %d in cluster %d\n",
1321               pseg_index, cluster_index);
1322        exit(1);
1323    }
1324
1325    //////// get type attribute
1326    str = getStringValue(reader, "type", &ok);
1327#if XML_PARSER_DEBUG
1328printf("      type = %s\n", str);
1329#endif
1330    if      (ok && (strcmp(str, "RAM" ) == 0)) pseg[pseg_index]->type = PSEG_TYPE_RAM;
1331    else if (ok && (strcmp(str, "ROM" ) == 0)) pseg[pseg_index]->type = PSEG_TYPE_ROM;
1332    else if (ok && (strcmp(str, "PERI") == 0)) pseg[pseg_index]->type = PSEG_TYPE_PERI;
1333    else
1334    {
1335        printf("[XML ERROR] illegal or missing <type> for pseg %s in cluster %d\n",
1336        pseg[pseg_index]->name, cluster_index);
1337        exit(1);
1338    }
1339
1340    //////// get base attribute
1341    value = getIntValue( reader, "base", &ok );
1342#if XML_PARSER_DEBUG
1343printf("      base = 0x%x\n", value);
1344#endif
1345    if ( ok ) 
1346    {
1347        pseg[pseg_index]->base = value;
1348    }
1349    else
1350    {
1351        printf("[XML ERROR] illegal or missing <base> for pseg %s in cluster %d\n",
1352        pseg[pseg_index]->name, cluster_index);
1353        exit(1);
1354    }
1355
1356    //////// get length attribute
1357    value = getIntValue( reader, "length", &ok );
1358#if XML_PARSER_DEBUG
1359printf("      length = 0x%x\n", value);
1360#endif
1361    if ( ok )
1362    {
1363        pseg[pseg_index]->length = value;
1364    } 
1365    else
1366    {
1367        printf("[XML ERROR] illegal or missing <length> for pseg %s in cluster %d\n",
1368        pseg[pseg_index]->name, cluster_index);
1369        exit(1);
1370    }
1371
1372    //////// set cluster attribute
1373    pseg[pseg_index]->cluster = cluster_index;
1374
1375    pseg_index++;
1376    cluster[cluster_index]->psegs++;
1377} // end psegNode()
1378
1379/////////////////////////////////////////////
1380void  clusterNode ( xmlTextReaderPtr reader )
1381{
1382    unsigned int ok;
1383    unsigned int value;
1384
1385    proc_loc_index = 0;
1386    coproc_loc_index = 0;
1387    cluster[cluster_index] = 0;
1388
1389    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
1390
1391    // checking source file consistency
1392    if ( cluster_index >= header->clusters )
1393    {
1394        printf("[XML ERROR] The cluster index is too large : %d\n", cluster_index);
1395        exit(1);
1396    }
1397
1398#if XML_PARSER_DEBUG
1399printf("  cluster %d\n", cluster_index);
1400#endif
1401
1402    cluster[cluster_index] = (mapping_cluster_t*)malloc(sizeof(mapping_cluster_t));
1403
1404    /////////// get index attribute (optional)
1405    value = getIntValue(reader,"index",&ok);
1406    if ( ok && (value != cluster_index) )
1407    {
1408            printf("[XML ERROR] wrong cluster index / expected value is %d", 
1409                cluster_index);
1410            exit(1);
1411    }
1412
1413
1414    ////////// set pseg_offset attribute
1415    cluster[cluster_index]->pseg_offset = pseg_index;
1416    cluster[cluster_index]->proc_offset = proc_index;
1417    cluster[cluster_index]->coproc_offset = coproc_index;
1418#if XML_PARSER_DEBUG
1419printf("    pseg_offset = %d\n", pseg_index);
1420printf("    proc_offset = %d\n", proc_index);
1421printf("    coproc_offset = %d\n", coproc_index);
1422#endif
1423
1424    ////////// get psegs, coproc and/or procs
1425    int status = xmlTextReaderRead(reader);
1426
1427    while ( status == 1 )
1428    {
1429        const char* tag = (const char*)xmlTextReaderConstName(reader);
1430
1431        if      ( strcmp(tag, "pseg")    == 0 ) psegNode(reader);
1432        else if ( strcmp(tag, "proc")    == 0 ) procNode(reader);
1433        else if ( strcmp(tag, "coproc")    == 0 ) coprocNode(reader);
1434        else if ( strcmp(tag, "#text")   == 0 ) { }
1435        else if ( strcmp(tag,"#comment") == 0 );
1436        else if ( strcmp(tag, "cluster") == 0 ) 
1437        {
1438#if XML_PARSER_DEBUG
1439printf("  end cluster %d\n", cluster_index);
1440#endif
1441            cluster[cluster_index]->procs = proc_loc_index;
1442            cluster[cluster_index]->coprocs = coproc_loc_index;
1443            //psegs = pseg_loc_index is done in psegNode(), so coprocNode() call to getPsegId() success
1444            cluster_index++;
1445            return;
1446        }
1447        status = xmlTextReaderRead(reader);
1448    }
1449} // end clusterNode()
1450
1451//////////////////////////////////////////////
1452void clusterSetNode( xmlTextReaderPtr reader )
1453{
1454    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
1455
1456#if XML_PARSER_DEBUG
1457printf("\n  clusters set\n");
1458#endif
1459
1460    int status = xmlTextReaderRead(reader);
1461    while ( status == 1 ) 
1462    {
1463        const char* tag = (const char*)xmlTextReaderConstName(reader);
1464
1465        if      ( strcmp(tag,"cluster") == 0 ) clusterNode(reader);
1466        else if ( strcmp(tag,"#text") == 0 ) { }
1467        else if ( strcmp(tag,"#comment") == 0 );
1468        else if ( strcmp(tag,"clusterset") == 0 ) 
1469        {
1470            // checking source file consistency
1471            if ( cluster_index != header->clusters )
1472            {
1473                printf("[XML ERROR] Wrong number of clusters\n");
1474                exit(1);
1475            }
1476            else
1477            {
1478#if XML_PARSER_DEBUG
1479printf("  end cluster set\n\n");
1480#endif
1481                header->psegs = pseg_index;
1482                header->procs = proc_index;
1483                header->irqs  = irq_index;
1484                header->coprocs = coproc_index;
1485                header->cp_ports = cp_port_index;
1486                header->cp_regs = cp_reg_index;
1487                return;
1488            }
1489        }
1490        else 
1491        {
1492            printf("[XML ERROR] Unknown tag in clusterset node : %s",tag);
1493            exit(1);
1494        }
1495        status = xmlTextReaderRead(reader);
1496    }
1497} // end clusterSetNode()
1498
1499/////////////////////////////////////////////
1500void globalSetNode( xmlTextReaderPtr reader )
1501{
1502    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
1503
1504#if XML_PARSER_DEBUG
1505printf("  globals set\n");
1506#endif
1507
1508    int status = xmlTextReaderRead(reader);
1509    while ( status == 1 ) 
1510    {
1511        const char* tag = (const char*)xmlTextReaderConstName(reader);
1512
1513        if      ( strcmp(tag,"vseg") == 0    ) vsegNode(reader);
1514        else if ( strcmp(tag,"#text"  ) == 0 ) { }
1515        else if ( strcmp(tag,"#comment") == 0 );
1516        else if ( strcmp(tag,"globalset") == 0  ) 
1517        {
1518            // checking source file consistency
1519            if ( vseg_index != header->globals )
1520            {
1521                printf("[XML ERROR] Wrong number of global vsegs\n");
1522                exit(1);
1523            }
1524            else
1525            {
1526#if XML_PARSER_DEBUG
1527printf("  end global set\n\n");
1528#endif
1529                vseg_loc_index = 0;
1530                return;
1531            }
1532        }
1533        else 
1534        {
1535            printf("[XML ERROR] Unknown tag in globalset node : %s",tag);
1536            exit(1);
1537        }
1538        status = xmlTextReaderRead ( reader );
1539    }
1540} // end globalSetNode()
1541
1542/////////////////////////////////////////////
1543void vspaceSetNode( xmlTextReaderPtr reader )
1544{
1545    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
1546
1547#if XML_PARSER_DEBUG
1548printf("\n  vspaces set\n");
1549#endif
1550
1551    int status = xmlTextReaderRead ( reader );
1552    while ( status == 1 ) 
1553    {
1554        const char* tag = (const char*)xmlTextReaderConstName(reader);
1555
1556        if      ( strcmp(tag,"vspace") == 0    ) vspaceNode(reader);
1557        else if ( strcmp(tag,"#text"  ) == 0 ) { }
1558        else if ( strcmp(tag,"#comment") == 0 );
1559        else if ( strcmp(tag,"vspaceset") == 0  ) 
1560        {
1561            // checking source file consistency
1562            if ( vspace_index != header->vspaces )
1563            {
1564                printf("[XML ERROR] Wrong number of vspaces\n");
1565                exit(1);
1566            }
1567            else
1568            {
1569                header->vsegs = vseg_index;
1570                header->vobjs = vobj_index;
1571                header->tasks = task_index;
1572                return;
1573            }
1574        }
1575        else 
1576        {
1577            printf("[XML ERROR] Unknown tag in vspaceset node : %s",tag);
1578            exit(1);
1579        }
1580        status = xmlTextReaderRead ( reader );
1581    }
1582} // end globalSetNode()
1583
1584//////////////////////////////////////////
1585void headerNode(xmlTextReaderPtr reader )
1586{
1587    char*               name;
1588    unsigned int        value;
1589    unsigned int        ok;
1590
1591    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
1592
1593#if XML_PARSER_DEBUG
1594printf("mapping_info\n");
1595#endif
1596
1597    header = (mapping_header_t*)malloc(sizeof(mapping_header_t));
1598
1599    ////////// get name attribute
1600    name = getStringValue(reader, "name", &ok);
1601    if ( ok )
1602    {
1603#if XML_PARSER_DEBUG
1604printf("  name = %s\n", name);
1605#endif
1606        strncpy( header->name, name, 31);
1607    }     
1608    else
1609    {
1610        printf("[XML ERROR] illegal or missing <name> attribute in header\n");
1611        exit(1);
1612    }
1613
1614    /////////// get clusters attribute
1615    value = getIntValue(reader, "clusters", &ok);
1616    if ( ok )
1617    {
1618        if ( value >= MAX_CLUSTERS )
1619        {
1620            printf("[XML ERROR] The number of clusters is larger than %d\n", MAX_CLUSTERS);
1621            exit(1);
1622        }
1623#if XML_PARSER_DEBUG
1624printf("  clusters = %d\n", value);
1625#endif
1626        header->clusters  = value;
1627    }
1628    else
1629    {
1630        printf("[XML ERROR] illegal or missing <clusters> attribute in header\n");
1631        exit(1);
1632    }
1633
1634    ///////// get ttys attribute
1635    value = getIntValue(reader, "ttys", &ok);
1636    if ( ok )
1637    {
1638#if XML_PARSER_DEBUG
1639printf("  ttys = %d\n", value);
1640#endif
1641        header->ttys  = value;
1642    }
1643    else
1644    {
1645        printf("[XML ERROR] illegal or missing <ttys> attribute in header\n");
1646        exit(1);
1647    }
1648
1649    ///////// get fbs attribute
1650    value = getIntValue(reader, "fbs", &ok);
1651    if ( ok )
1652    {
1653#if XML_PARSER_DEBUG
1654printf("  fbs = %d\n", value);
1655#endif
1656        header->fbs  = value;
1657    }
1658    else
1659    {
1660        printf("[XML ERROR] illegal or missing <fbs> attribute in header\n");
1661        exit(1);
1662    }
1663
1664    ///////// get vspaces attribute
1665    value = getIntValue(reader, "vspaces", &ok);
1666    if ( ok )
1667    {
1668        if ( value >= MAX_VSPACES )
1669        {
1670            printf("[XML ERROR] The number of vspaces is larger than %d\n", MAX_VSPACES);
1671            exit(1);
1672        }
1673#if XML_PARSER_DEBUG
1674printf("  vspaces = %d\n", value);
1675#endif
1676        header->vspaces  = value;
1677    }
1678    else
1679    {
1680        printf("[XML ERROR] illegal or missing <vspaces> attribute in mapping\n");
1681        exit(1);
1682    }
1683
1684    ////////// get globals attribute
1685    value = getIntValue(reader, "globals", &ok);
1686    if ( ok )
1687    {
1688        if ( value >= MAX_VSEGS )
1689        {
1690            printf("[XML ERROR] The number of globals is larger than %d\n", MAX_VSEGS);
1691            exit(1);
1692        }
1693#if XML_PARSER_DEBUG
1694printf("  globals = %d\n", value);
1695#endif
1696        header->globals  = value;
1697    }
1698    else
1699    {
1700        printf("[XML ERROR] illegal or missing <globals> attribute in mapping_info_header\n");
1701        exit(1);
1702    }
1703
1704    header->signature = IN_MAPPING_SIGNATURE;
1705
1706    int status = xmlTextReaderRead(reader);
1707    while ( status == 1 ) 
1708    {
1709        const char* tag = (const char*)xmlTextReaderConstName(reader);
1710
1711        if      ( strcmp(tag,"clusterset")   == 0 ) clusterSetNode(reader);
1712        else if ( strcmp(tag,"globalset")    == 0 ) globalSetNode(reader);
1713        else if ( strcmp(tag,"vspaceset")    == 0 ) vspaceSetNode(reader);
1714        else if ( strcmp(tag,"#text")        == 0 ) ;
1715        else if ( strcmp(tag,"#comment")     == 0 ) ;
1716        else if ( strcmp(tag,"mapping_info") == 0 ) 
1717        {
1718#if XML_PARSER_DEBUG
1719printf("end mapping_info\n");
1720#endif
1721            return;
1722        }
1723        else 
1724        {
1725            printf("[XML ERROR] Unknown tag in header node : %s\n",tag);
1726            exit(1);
1727        }
1728        status = xmlTextReaderRead(reader);
1729    }
1730} // end headerNode()
1731   
1732void BuildTable( int fdout,
1733               const char* type,
1734               unsigned int nb_elem,
1735               unsigned int elem_size,
1736               char** table)       
1737{
1738    unsigned int i;
1739    unsigned int length;
1740    // write element
1741    for ( i = 0 ; i < nb_elem ; i++ )
1742    {
1743        length = write(fdout, table[i], elem_size);
1744   
1745#if XML_PARSER_DEBUG
1746printf("Building binary: writing %s %d\n", type, i);
1747#endif
1748
1749        if ( length != elem_size )
1750        {
1751            printf("type: %s\n", type);
1752            perror("error writing");
1753            exit(1);
1754        }
1755    }
1756}
1757
1758///////////////////////////
1759void  buildBin( int fdout )
1760{
1761    unsigned int    vspace_id;
1762    unsigned int    vobj_id;
1763    unsigned int    length;
1764
1765    // write header to binary file
1766    length = write(fdout, (char*)header, sizeof(mapping_header_t));
1767   
1768#if XML_PARSER_DEBUG
1769printf("\n*** write header\n");
1770#endif
1771
1772    if ( length != sizeof(mapping_header_t) )
1773    {
1774        printf("write header error : length = %d \n", length);
1775        exit(1);
1776    }
1777
1778    // write clusters
1779    BuildTable(fdout, "cluster", cluster_index, sizeof(mapping_cluster_t), (char**) cluster);
1780
1781    // write psegs
1782    BuildTable(fdout, "pseg", pseg_index, sizeof(mapping_pseg_t), (char**) pseg);
1783
1784    // write vspaces
1785    for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
1786    {
1787        length = write(fdout, (char*)vspace[vspace_id], sizeof(mapping_vspace_t));
1788   
1789#if XML_PARSER_DEBUG
1790printf("write vspace %d\n", vspace_id);
1791printf("vspace->vobj_offset: %d\n", vspace[vspace_id]->vobj_offset);
1792printf("vspace->vobjs: %d\n", vspace[vspace_id]->vobjs);
1793printf("header->vobjs: %d\n", header->vobjs);
1794#endif
1795
1796        if ( length != sizeof(mapping_vspace_t) )
1797        {
1798            perror("write vspace");
1799            exit(1);
1800        }
1801    }
1802
1803    // write vsegs
1804    BuildTable(fdout, "vseg", vseg_index, sizeof(mapping_vseg_t), (char**) vseg);
1805   
1806    // write vobjs
1807    for ( vobj_id = 0 ; vobj_id < header->vobjs ; vobj_id++ )
1808    {
1809        length = write(fdout, (char*)vobj[vobj_id], sizeof(mapping_vobj_t));
1810   
1811#if XML_PARSER_DEBUG
1812printf("write vobj %d\n", vobj_id);
1813printf("write vobj name %s\n", vobj[vobj_id]->name);
1814printf("write vobj length %x\n", vobj[vobj_id]->length);
1815printf("write vobj type %d\n", vobj[vobj_id]->type);
1816#endif
1817
1818        if ( length != sizeof(mapping_vobj_t) )
1819        {
1820            perror("write vobj");
1821            exit(1);
1822        }
1823    }
1824
1825    // write tasks
1826    BuildTable(fdout, "task", task_index, sizeof(mapping_task_t), (char**) task);
1827    //building proc
1828    BuildTable(fdout, "proc", proc_index, sizeof(mapping_proc_t), (char**) proc);
1829    //building irq
1830    BuildTable(fdout, "irq", irq_index, sizeof(mapping_irq_t), (char**)irq);
1831    //building coproc
1832    BuildTable(fdout, "coproc", coproc_index, sizeof(mapping_coproc_t), (char**)coproc);
1833    //building cp_port
1834    BuildTable(fdout, "cp_port", cp_port_index, sizeof(mapping_coproc_port_t),(char**) cp_port);
1835    //building cp_reg
1836    BuildTable(fdout, "cp_reg", cp_reg_index, sizeof(mapping_coproc_reg_t), (char**)cp_reg);
1837
1838} // end buildBin()
1839
1840/////////////////////////////////////////
1841// this function set the value of vobj_id
1842// of the coproc_ports.
1843///////////////////
1844void prepareBuild()
1845{
1846    unsigned int i;
1847    for(i=0; i< cp_port_index; i++)
1848    {
1849        int vspace_id = getVspaceId( cp_port_vobj_ref[i]->vspace_name );
1850        if ( vspace_id < 0 ) 
1851        {
1852            printf("[XML ERROR] illegal  <vspacename> for coproc_port %d,\n", 
1853                    i);
1854            exit(1);
1855        }
1856        cp_port[i]->vspaceid = vspace_id;
1857       
1858        int vobj_id = getVobjLocId( vspace_id, cp_port_vobj_ref[i]->vobj_name, vspace[vspace_id]->vobjs );
1859        if ( vobj_id >= 0 ) 
1860        {
1861#if XML_PARSER_DEBUG
1862printf("coproc_port = %d\n", i);
1863printf("      vspace_name  = %s\n", cp_port_vobj_ref[i]->vspace_name);
1864printf("      vobj_name    = %s\n", cp_port_vobj_ref[i]->vobj_name);
1865printf("      vobj_index   = %d\n", vobj_id);
1866#endif
1867            cp_port[i]->vobjlocid = vobj_id;
1868            assert((vobj[ vspace[vspace_id]->vobj_offset + vobj_id]->type == VOBJ_TYPE_MWMR) && "coproc ports has to refere to a vobj of type MWMR");
1869        }
1870        else             
1871        {
1872            printf("[XML ERROR] illegal  <vobjname> for coproc_port %d,\n", 
1873                    i);
1874            exit(1);
1875        }
1876       
1877    }
1878}
1879
1880/////////////////////////////////////
1881int  main ( int argc, char* argv[] )
1882{
1883    if ( argc < 3 ) 
1884    {
1885        printf("Usage: xml2bin <input_file_path> <output_file_path>\n");
1886        return 1;
1887    }
1888
1889    int fdout = open( argv[2], (O_CREAT | O_RDWR), S_IRWXU );
1890    if ( fdout < 0)
1891    {
1892        perror("open");
1893        exit(1);
1894    }
1895   
1896    LIBXML_TEST_VERSION;
1897
1898    int status;
1899    xmlTextReaderPtr reader = xmlReaderForFile ( argv[1], NULL, 0 );
1900
1901    if ( reader != NULL ) 
1902    {
1903        status = xmlTextReaderRead ( reader );
1904        while ( status == 1 ) 
1905        {
1906            const char* tag = (const char*)xmlTextReaderConstName(reader);
1907
1908            if ( strcmp(tag,"mapping_info") == 0 )
1909            { 
1910                headerNode( reader );
1911                prepareBuild();
1912                buildBin( fdout );
1913            }
1914            else
1915            if ( strcmp(tag,"#comment") == 0 );// a way to skips comment
1916            else
1917            {
1918                printf("[XML ERROR] Wrong file type: \"%s\"\n", argv[1]);
1919                return 1;
1920            }
1921            status = xmlTextReaderRead ( reader );
1922        }
1923        xmlFreeTextReader ( reader );
1924
1925        if ( status != 0 ) 
1926        {
1927            printf("[XML ERROR] Wrong Syntax in \"%s\" file\n", argv[1]);
1928            return 1;
1929        }
1930    }
1931    return 0;
1932} // end main()
Note: See TracBrowser for help on using the repository browser.