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

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

Adding BLOB type for vobj.
Don't forget to set as BLOB type the mapping_info vobj in the xml.
File size: 36.4 KB
Line 
1///////////////////////////////////////////////////////////////////////////////////////
2// File     : xml_parser.c
3// Date     : 04/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  <libxml/xmlreader.h>
20#include  <mapping_info.h>
21
22#define MAX_CLUSTERS    1024
23#define MAX_PSEGS               4096
24#define MAX_VSPACES             1024
25#define MAX_TASKS               4096
26#define MAX_MWMRS               4096
27#define MAX_VSEGS               4096
28#define MAX_VOBJS               8192
29
30#define XML_PARSER_DEBUG        0
31
32///////////////////////////////////////////////////////////////////////////////////
33//      global variables used to store and index the data structures
34///////////////////////////////////////////////////////////////////////////////////
35
36mapping_header_t*       header;
37mapping_cluster_t*      cluster[MAX_CLUSTERS];          // cluster array
38mapping_pseg_t*         pseg[MAX_PSEGS];                // pseg array
39mapping_vspace_t*       vspace[MAX_VSPACES];            // vspace array
40mapping_vseg_t*         vseg[MAX_VSEGS];                // vseg array
41mapping_vobj_t*         vobj[MAX_VOBJS];                // vobj array
42mapping_task_t*         task[MAX_TASKS];                // task array
43
44unsigned int            cluster_index  = 0;
45unsigned int            vspace_index   = 0;
46unsigned int            global_index   = 0;
47unsigned int            pseg_index     = 0;
48unsigned int            vseg_index     = 0;
49unsigned int            vseg_loc_index = 0;
50unsigned int            task_index     = 0;
51unsigned int            task_loc_index = 0;
52unsigned int            vobj_index     = 0;
53unsigned int            vobj_loc_index = 0;
54unsigned int            vobj_count     = 0;
55
56unsigned int            tty_index      = 1;
57unsigned int            fb_index       = 0;
58           
59//////////////////////////////////////////////////
60unsigned int getIntValue( xmlTextReaderPtr reader, 
61                          const char*      attributeName, 
62                          unsigned int*    ok )
63{
64    unsigned int        value = 0;
65    unsigned int        i;
66    char        c;
67
68    char* string = (char*)xmlTextReaderGetAttribute(reader, (const xmlChar*)attributeName);
69
70    if ( string == NULL )  // missing argument
71    {
72        *ok = 0;
73        return 0;
74    }
75    else
76    {
77        if ( (string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X')) )  // Hexa
78        {
79            for ( i = 2 ; (string[i] != 0) && (i < 10) ; i++ )
80            {
81                c = string[i];
82                if      ((c >= '0') && (c <= '9')) value = (value<<4) + string[i] - 48;
83                else if ((c >= 'a') && (c <= 'f')) value = (value<<4) + string[i] - 87;
84                else if ((c >= 'A') && (c <= 'F')) value = (value<<4) + string[i] - 55;
85                else   
86                {
87                    *ok = 0;
88                    return 0;
89                }
90            }
91        }
92        else                                                            // Decimal
93        {
94            for ( i = 0 ; (string[i] != 0) && (i < 9) ; i++ )
95            {
96                c = string[i];
97                if ((c >= '0') && (c <= '9')) value = (value*10) + string[i] - 48;
98                else 
99                {
100                    *ok = 0;
101                    return 0;
102                }
103            }
104        }
105        *ok = 1;
106        return value; 
107    }
108} // end getIntValue()
109
110///////////////////////////////////////////////
111char* getStringValue ( xmlTextReaderPtr reader, 
112                       const char*      attributeName, 
113                       unsigned int*    ok )
114{
115    char* string = (char*)xmlTextReaderGetAttribute(reader, (const xmlChar*)attributeName);
116
117    if ( string == NULL )  // missing argument
118    {
119        *ok = 0;
120        return NULL;
121    }
122    else
123    {
124        *ok = 1;
125        return string;
126    }
127} // end getStringValue()
128
129//////////////////////////
130int getPsegId( char* str )
131{
132    unsigned int pseg_id;
133
134    for ( pseg_id = 0 ; pseg_id < header->psegs ; pseg_id++ )
135    {
136        if ( strcmp(pseg[pseg_id]->name, str) == 0 ) return pseg_id;
137    }
138    return -1;
139}
140
141//////////////////////////////////////////
142int getVobjLocId( unsigned int  vspace_id,
143                  char*         str )
144{
145    unsigned int vobj_id;
146    unsigned int vobj_min = vspace[vspace_id]->vobj_offset;
147    unsigned int vobj_max = vobj_min + vobj_loc_index;
148
149    for ( vobj_id = vobj_min ; vobj_id < vobj_max ; vobj_id++ )
150    {
151        if ( strcmp(vobj[vobj_id]->name, str) == 0 )
152        {
153             return (vobj_id - vobj_min);
154        }
155    }
156    return -1;
157}
158
159//////////////////////////////////////////
160void  taskNode ( xmlTextReaderPtr reader )
161{
162    unsigned int        ok;
163    unsigned int        value;
164    char*               str;
165
166    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
167
168    if ( task_index >= MAX_TASKS )
169    {
170        printf("[XML ERROR] The number of tasks is larger than %d\n", MAX_TASKS);
171    }
172
173#if XML_PARSER_DEBUG
174printf("   task %d\n", task_loc_index);
175#endif
176
177    task[task_index] = (mapping_task_t*)malloc(sizeof(mapping_task_t));
178
179    ////////// get name attribute
180    str = getStringValue(reader, "name", &ok);
181    if ( ok )
182    {
183#if XML_PARSER_DEBUG
184printf("      name = %s\n", str);
185#endif
186        strncpy( task[task_index]->name, str, 31 );
187    }
188    else
189    {
190        printf("[XML ERROR] illegal or missing <name> attribute for task (%d,%d)\n", 
191               vspace_index, task_loc_index);
192        exit(1);
193    }
194
195    ///////// get clusterid attribute
196    value = getIntValue(reader,"clusterid", &ok);
197    if ( ok )
198    {
199#if XML_PARSER_DEBUG
200printf("      clusterid = %x\n", value);
201#endif
202        if ( value >= header->clusters )
203        {
204            printf("[XML ERROR] <clusterid> too large for task (%d,%d)\n",
205                   vspace_index, task_loc_index);
206            exit(1);
207        }
208        task[task_index]->clusterid = value;
209    } 
210    else
211    {
212        printf("[XML ERROR] illegal or missing <clusterid> attribute for task (%d,%d)\n",
213               vspace_index, task_loc_index);
214        exit(1);
215    }
216
217    ////////// get proclocid attribute
218    value = getIntValue(reader,"proclocid", &ok);
219    if ( ok )
220    {
221#if XML_PARSER_DEBUG
222printf("      proclocid = %x\n", value);
223#endif
224        if ( value >= cluster[task[task_index]->clusterid]->procs )
225        {
226            printf("[XML ERROR] <proclocid> too large for task (%d,%d)\n",
227                   vspace_index, task_loc_index);
228            exit(1);
229        }
230        task[task_index]->proclocid = value;
231    } 
232    else
233    {
234        printf("[XML ERROR] illegal or missing <locprocid> attribute for task (%d,%d)\n", 
235                vspace_index, task_loc_index);
236        exit(1);
237    }
238
239    ////////// get stackname attribute
240    str = getStringValue(reader, "stackname" , &ok);
241    if ( ok )
242    {
243        int index = getVobjLocId( vspace_index, str );
244        if ( index >= 0 ) 
245        {
246#if XML_PARSER_DEBUG
247printf("      stackname = %s\n", str);
248printf("      stackid   = %d\n", index);
249#endif
250            task[task_index]->vobjlocid = index;
251        }
252        else             
253        {
254            printf("[XML ERROR] illegal or missing <stackname> for task (%d,%d)\n", 
255                    vspace_index, task_loc_index);
256            exit(1);
257        }
258    } 
259    else
260    {
261        printf("[XML ERROR] illegal or missing <stackname> for task (%d,%d)\n", 
262                vspace_index, task_loc_index);
263        exit(1);
264    }
265
266    ////////// get startid  attribute
267    value = getIntValue(reader,"startid", &ok);
268    if ( ok )
269    {
270#if XML_PARSER_DEBUG
271printf("      startid = %x\n", value);
272#endif
273        task[task_index]->startid = value;
274    } 
275    else
276    {
277        printf("[XML ERROR] illegal or missing <startid> attribute for task (%d,%d)\n", 
278                vspace_index, task_loc_index);
279        exit(1);
280    }
281
282    /////////// get use_tty  attribute (optionnal : 0 if missing)
283    value = getIntValue(reader,"usetty", &ok);
284    if ( ok )
285    {
286#if XML_PARSER_DEBUG
287printf("      usetty = %x\n", value);
288#endif
289        if ( (value != 0) && (tty_index >= header->ttys) )
290        {
291            printf("[XML ERROR] The tty index is too large for task (%d,%d)\n", 
292                vspace_index, task_loc_index);
293            exit(1);
294        }
295        task[task_index]->use_tty = value;
296        if (value != 0) tty_index++;
297    } 
298    else
299    {
300        task[task_index]->use_tty = 0;
301    }
302
303    /////////// get use_fb  attribute (optionnal : 0 if missing)
304    value = getIntValue(reader,"usefb", &ok);
305    if ( ok )
306    {
307#if XML_PARSER_DEBUG
308printf("      usefb = %x\n", value);
309#endif
310        if ( (value != 0) && (fb_index >= header->fbs) )
311        {
312            printf("[XML ERROR] The fb channel index is too large for task (%d,%d)\n", 
313                vspace_index, task_loc_index);
314            exit(1);
315        }
316        task[task_index]->use_fb = value;
317        if (value != 0) fb_index++;
318    } 
319    else
320    {
321        task[task_index]->use_fb = 0;
322    }
323
324    task_index++;
325    task_loc_index++;
326} // end taskNode()
327
328//////////////////////////////////////////
329void  vobjNode ( xmlTextReaderPtr reader )
330{
331    unsigned int        ok;
332    unsigned int        value;
333    char*               str;
334
335    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
336
337    if ( vobj_index >= MAX_VOBJS )
338    {
339        printf("[XML ERROR] The number of vobjs is larger than %d\n", MAX_VSEGS);
340        exit(1);
341    }
342
343#if XML_PARSER_DEBUG
344printf("      vobj %d\n", vobj_loc_index);
345#endif
346
347    vobj[vobj_index] = (mapping_vobj_t*)malloc(sizeof(mapping_vobj_t));
348
349    ///////// get name attribute
350    str = getStringValue(reader, "name", &ok);
351    if ( ok )
352    {
353#if XML_PARSER_DEBUG
354printf("        name = %s\n", str);
355#endif
356        strncpy( vobj[vobj_index]->name, str, 31);
357    }
358    else
359    {
360        printf("[XML ERROR] illegal or missing <name> attribute for vobj (%d,%d)\n", 
361                vseg_index, vobj_loc_index);
362        exit(1);
363    }
364
365    //////// get type attribute
366    str = getStringValue(reader, "type", &ok);
367#if XML_PARSER_DEBUG
368printf("        type = %s\n", str);
369#endif
370    if (ok && (strcmp(str, "ELF") == 0))
371    {
372        vobj[vobj_index]->type = VOBJ_TYPE_ELF;
373
374        //check that this vobj is the first in vseg
375        if(vobj_count != 0) 
376        {
377            printf("[XML ERROR] an ELF vobj must be alone in a vseg (%d,%d)\n", 
378                    vspace_index, vobj_loc_index);
379            exit(1);
380        }
381    }
382    else if (ok && (strcmp(str, "BLOB")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_BLOB;
383    else if (ok && (strcmp(str, "PTAB")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_PTAB;
384    else if (ok && (strcmp(str, "PERI")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_PERI;
385    else if (ok && (strcmp(str, "MWMR")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_MWMR;
386    else if (ok && (strcmp(str, "LOCK")    == 0)) vobj[vobj_index]->type = VOBJ_TYPE_LOCK;
387    else if (ok && (strcmp(str, "BUFFER")  == 0)) vobj[vobj_index]->type = VOBJ_TYPE_BUFFER;
388    else if (ok && (strcmp(str, "BARRIER") == 0)) vobj[vobj_index]->type = VOBJ_TYPE_BARRIER;
389    else
390    {
391        printf("[XML ERROR] illegal or missing <type> attribute for vobj (%d,%d)\n", 
392                vspace_index, vobj_loc_index);
393        exit(1);
394    }
395
396    ////////// get length attribute
397    value = getIntValue(reader,"length", &ok);
398    if ( ok )
399    {
400#if XML_PARSER_DEBUG
401printf("        length = %d\n", value);
402#endif
403        vobj[vobj_index]->length = value;
404    } 
405    else
406    {
407        printf("[XML ERROR] illegal or missing <length> attribute for vobj (%d,%d)\n", 
408                vspace_index, vobj_loc_index);
409        exit(1);
410    }
411
412    ////////// get align attribute (optional : 0 if missing)
413    value = getIntValue(reader,"align", &ok);
414    if ( ok )
415    {
416#if XML_PARSER_DEBUG
417printf("        align = %d\n", value);
418#endif
419        vobj[vobj_index]->align = value;
420    } 
421    else
422    {
423        vobj[vobj_index]->align = 0;
424    }
425
426    ////////// get binpath attribute (optional : '\0' if missing)
427    str = getStringValue(reader, "binpath", &ok);
428    if ( ok )
429    {
430#if XML_PARSER_DEBUG
431printf("        binpath = %s\n", str);
432#endif
433        strncpy(vobj[vobj_index]->binpath, str, 63);
434    } 
435    else
436    {
437        vobj[vobj_index]->binpath[0] = '\0';
438    }
439   
440    ////////// get init attribute (optional : 0 if missing)
441    value = getIntValue(reader,"init", &ok);
442    if ( ok )
443    {
444#if XML_PARSER_DEBUG
445printf("        init  = %d\n", value);
446#endif
447        vobj[vobj_index]->init = value;
448    } 
449    else
450    {
451        vobj[vobj_index]->init = 0;
452    }
453
454    vobj_index++;
455    vobj_count++;
456    vobj_loc_index++;
457} // end vobjNode()
458
459//////////////////////////////////////////
460void  vsegNode ( xmlTextReaderPtr reader )
461{
462    unsigned int        ok;
463    unsigned int        value;
464    char*               str;
465
466        vobj_count = 0;
467
468    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
469
470    if ( vseg_index >= MAX_VSEGS )
471    {
472        printf("[XML ERROR] The number of vsegs is larger than %d\n", MAX_VSEGS);
473        exit(1);
474    }
475
476#if XML_PARSER_DEBUG
477printf("    vseg %d\n", vseg_loc_index);
478#endif
479
480    vseg[vseg_index] = (mapping_vseg_t*)malloc(sizeof(mapping_vseg_t));
481   
482    ////////// set vobj_offset attributes
483    vseg[vseg_index]->vobj_offset = vobj_index;
484#if XML_PARSER_DEBUG
485printf("      vobj_offset = %d\n", vobj_index);
486#endif
487
488    ///////// get name attribute
489    str = getStringValue(reader, "name", &ok);
490    if ( ok )
491    {
492#if XML_PARSER_DEBUG
493printf("      name = %s\n", str);
494#endif
495        strncpy( vseg[vseg_index]->name, str, 31);
496    }
497    else
498    {
499        printf("[XML ERROR] illegal or missing <name> attribute for vseg (%d,%d)\n", 
500                vspace_index, vseg_loc_index);
501        exit(1);
502    }
503
504    /////////// get vbase attribute
505    value = getIntValue(reader,"vbase", &ok);
506    if ( ok ) 
507    {
508#if XML_PARSER_DEBUG
509printf("      vbase = 0x%x\n", value);
510#endif
511        vseg[vseg_index]->vbase = value;
512    }
513    else
514    {
515        printf("[XML ERROR] illegal or missing <vbase> attribute for vseg (%d,%d)\n", 
516                vspace_index, vseg_loc_index);
517        exit(1);
518    }
519
520    ////////// get ident attribute (optional : 0 if missing)
521    value = getIntValue(reader,"ident", &ok);
522    if ( ok )
523    {
524#if XML_PARSER_DEBUG
525printf("      ident = %d\n", value);
526#endif
527        vseg[vseg_index]->ident = value;
528    } 
529    else
530    {
531        vseg[vseg_index]->ident = 0;
532    }
533
534    ////////// get psegname attribute
535    str = getStringValue(reader,"psegname", &ok);
536    if ( ok )
537    {
538        int index = getPsegId( str );
539        if ( index >= 0 ) 
540        {
541#if XML_PARSER_DEBUG
542printf("      psegname = %s\n", str);
543printf("      psegid   = %d\n", index);
544#endif
545            vseg[vseg_index]->psegid = index;
546        }
547        else             
548        {
549            printf("[XML ERROR] illegal or missing <psegname> for vseg %d\n", 
550                     vseg_loc_index);
551            exit(1);
552        }
553    } 
554    else
555    {
556        printf("[XML ERROR] illegal or missing <psegname> for vseg %d\n", 
557                 vseg_loc_index);
558        exit(1);
559    }
560
561    //////// get mode attribute
562    str = getStringValue(reader,"mode", &ok);
563#if XML_PARSER_DEBUG
564printf("      mode = %s\n", str);
565#endif
566    if      (ok && (strcmp(str, "CXWU") == 0)) vseg[vseg_index]->mode = 0xF;
567    else if (ok && (strcmp(str, "CXW_") == 0)) vseg[vseg_index]->mode = 0xE;
568    else if (ok && (strcmp(str, "CX_U") == 0)) vseg[vseg_index]->mode = 0xD;
569    else if (ok && (strcmp(str, "CX__") == 0)) vseg[vseg_index]->mode = 0xC;
570    else if (ok && (strcmp(str, "C_WU") == 0)) vseg[vseg_index]->mode = 0xB;
571    else if (ok && (strcmp(str, "C_W_") == 0)) vseg[vseg_index]->mode = 0xA;
572    else if (ok && (strcmp(str, "C__U") == 0)) vseg[vseg_index]->mode = 0x9;
573    else if (ok && (strcmp(str, "C___") == 0)) vseg[vseg_index]->mode = 0x8;
574    else if (ok && (strcmp(str, "_XWU") == 0)) vseg[vseg_index]->mode = 0x7;
575    else if (ok && (strcmp(str, "_XW_") == 0)) vseg[vseg_index]->mode = 0x6;
576    else if (ok && (strcmp(str, "_X_U") == 0)) vseg[vseg_index]->mode = 0x5;
577    else if (ok && (strcmp(str, "_X__") == 0)) vseg[vseg_index]->mode = 0x4;
578    else if (ok && (strcmp(str, "__WU") == 0)) vseg[vseg_index]->mode = 0x3;
579    else if (ok && (strcmp(str, "__W_") == 0)) vseg[vseg_index]->mode = 0x2;
580    else if (ok && (strcmp(str, "___U") == 0)) vseg[vseg_index]->mode = 0x1;
581    else if (ok && (strcmp(str, "____") == 0)) vseg[vseg_index]->mode = 0x0;
582    else
583    {
584        printf("[XML ERROR] illegal or missing <mode> attribute for vseg (%d,%d)\n", 
585                vspace_index, vseg_loc_index);
586        exit(1);
587    }
588   
589    ////////// set the length attribute to 0
590    vseg[vseg_index]->length = value;
591
592    ////////// get vobjs
593    int status = xmlTextReaderRead ( reader );
594    while ( status == 1 ) 
595    {
596        const char* tag = (const char*)xmlTextReaderConstName(reader);
597
598        if      ( strcmp(tag,"vobj") == 0    ) vobjNode(reader);
599        else if ( strcmp(tag,"#text"  ) == 0 ) { }
600        else if ( strcmp(tag,"vseg") == 0  ) 
601        {
602            //  checking source file consistency?
603            vseg[vseg_index]->vobjs = vobj_count;
604            vseg_index++;
605            vseg_loc_index++;
606            return;
607        }
608        else 
609        {
610            printf("[XML ERROR] Unknown tag %s",tag);
611            exit(1);
612        }
613        status = xmlTextReaderRead ( reader );
614    }
615} // end vsegNode()
616
617//////////////////////////////////////////
618void vspaceNode( xmlTextReaderPtr reader )
619{
620    char*               str;
621    unsigned int        ok;
622
623    vobj_loc_index = 0;
624        vseg_loc_index = 0;
625        task_loc_index = 0;
626
627    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
628
629    // checking source file consistency
630    if ( vspace_index >= header->vspaces )
631    {
632        printf("[XML ERROR] The vspace index is too large : %d\n", 
633                 vspace_index);
634        exit(1);
635    }
636
637#if XML_PARSER_DEBUG
638printf("\n  vspace %d\n", vspace_index);
639#endif
640
641    vspace[vspace_index] = (mapping_vspace_t*)malloc(sizeof(mapping_vspace_t));
642
643    ////////// get name attribute
644    str = getStringValue(reader, "name", &ok);
645    if ( ok )
646    {
647#if XML_PARSER_DEBUG
648printf("  name = %s\n", str);
649#endif
650        strncpy(vspace[vspace_index]->name, str, 31);
651    }
652    else
653    {
654        printf("[XML ERROR] illegal or missing <name> attribute for vspace %d\n", 
655                 vspace_index);
656        exit(1);
657    }
658
659    ////////// set vseg_offset and task_offset attributes
660    vspace[vspace_index]->vseg_offset = vseg_index;
661    vspace[vspace_index]->vobj_offset = vobj_index;
662    vspace[vspace_index]->task_offset = task_index;
663   
664#if XML_PARSER_DEBUG
665printf("  vseg_offset = %d\n", vseg_index);
666printf("  vobj_offset = %d\n", vobj_index);
667printf("  task_offset = %d\n", task_index);
668#endif
669
670    ////////// get startname attribute
671    str = getStringValue(reader, "startname", &ok);
672    if ( ok )
673    {
674        //used after parsing the vobjs
675    }
676    else
677    {
678        printf("[XML ERROR] illegal or missing <startname> attribute for vspace %d\n", 
679                 vspace_index);
680        exit(1);
681    }
682
683    int status = xmlTextReaderRead ( reader );
684    while ( status == 1 ) 
685    {
686        const char* tag = (const char*)xmlTextReaderConstName(reader);
687
688        if      ( strcmp(tag,"vseg") == 0    ) vsegNode(reader);
689        else if ( strcmp(tag,"task") == 0    ) taskNode(reader);
690        else if ( strcmp(tag,"#text"  ) == 0 ) { }
691        else if ( strcmp(tag,"vspace") == 0  ) 
692        {
693            vspace[vspace_index]->vobjs = vobj_loc_index;
694            vspace[vspace_index]->tasks = task_loc_index ;
695            vspace[vspace_index]->vsegs = vseg_loc_index ;
696
697            // get index of the vobj containing the start vector
698            int index =  getVobjLocId( vspace_index, str );
699            if(index == -1)
700            {
701                printf("[XML ERROR] vobj containing the start vector not found %s\n",str);
702                exit(-1);
703            }
704            else
705            {
706                vspace[vspace_index]->start_offset = index;
707#if XML_PARSER_DEBUG
708printf("  startname = %s\n", str);
709printf("  startid   = %d\n", index);
710#endif
711            }
712
713            // checking startid values for all tasks in vspace
714            int task_id;
715            int task_min = vspace[vspace_index]->task_offset;
716            int task_max = task_min + vspace[vspace_index]->tasks; 
717            for ( task_id = task_min ; task_id < task_max ; task_id++ )
718            {
719                if ( task[task_id]->startid >= vspace[vspace_index]->tasks )
720                {
721                    printf("[XML ERROR] <startid> too large for task (%d,%d)\n", 
722                           vspace_index, task_id );
723                    exit(1);
724                }
725            }
726
727            vspace_index++;
728            return;
729        }
730        else 
731        {
732            printf("[XML ERROR] Unknown tag %s",tag);
733            exit(1);
734        }
735        status = xmlTextReaderRead ( reader );
736    }
737} // end vspaceNode()
738
739//////////////////////////////////////////
740void  psegNode ( xmlTextReaderPtr reader )
741{
742    unsigned int        ok;
743    unsigned int        value;
744    char*               str;
745
746    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
747
748    if ( pseg_index >= MAX_PSEGS )
749    {
750        printf("[XML ERROR] The number of psegs is larger than %d\n", MAX_PSEGS);
751        exit(1);
752    }
753
754#if XML_PARSER_DEBUG
755printf("    pseg %d\n", pseg_index);
756#endif
757
758    pseg[pseg_index] = (mapping_pseg_t*)malloc(sizeof(mapping_pseg_t));
759
760    // get name attribute
761    str = getStringValue( reader, "name", &ok );
762#if XML_PARSER_DEBUG
763printf("    name = %s\n", str);
764#endif
765    if ( ok ) 
766    {
767        strncpy(pseg[pseg_index]->name, str, 31);
768    }
769    else
770    {
771        printf("[XML ERROR] illegal or missing <name> for pseg %d\n", pseg_index);
772        exit(1);
773    }
774
775    // get base attribute
776    value = getIntValue( reader, "base", &ok );
777#if XML_PARSER_DEBUG
778printf("    base = %x\n", value);
779#endif
780    if ( ok ) 
781    {
782        pseg[pseg_index]->base = value;
783    }
784    else
785    {
786        printf("[XML ERROR] illegal or missing <base> for pseg %d\n", pseg_index);
787        exit(1);
788    }
789
790    // get length attribute
791    value = getIntValue( reader, "length", &ok );
792#if XML_PARSER_DEBUG
793printf("    length = %x\n\n", value);
794#endif
795    if ( ok )
796    {
797        pseg[pseg_index]->length = value;
798    } 
799    else
800    {
801        printf("[XML ERROR] illegal or missing <length> for pseg %d\n", pseg_index);
802        exit(1);
803    }
804
805    pseg_index++;
806} // end psegNode()
807
808/////////////////////////////////////////////
809void  clusterNode ( xmlTextReaderPtr reader )
810{
811    unsigned int ok;
812    unsigned int value;
813
814    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
815
816    // checking source file consistency
817    if ( cluster_index >= header->clusters )
818    {
819        printf("[XML ERROR] The cluster index is too large : %d\n", cluster_index);
820        exit(1);
821    }
822
823#if XML_PARSER_DEBUG
824printf("  cluster %d :\n", cluster_index);
825#endif
826
827    cluster[cluster_index] = (mapping_cluster_t*)malloc(sizeof(mapping_cluster_t));
828
829    // get index attribute (optional)
830    value = getIntValue(reader,"index",&ok);
831#if XML_PARSER_DEBUG
832printf("    index = %d\n", value);
833#endif
834    if ( ok && (value != cluster_index) )
835    {
836            printf("[XML ERROR] wrong cluster index / expected value is %d", 
837                cluster_index);
838            exit(1);
839    }
840
841    // get procs attribute
842    value = getIntValue(reader,"procs",&ok);
843#if XML_PARSER_DEBUG
844printf("    procs = %d\n", value);
845#endif
846    if ( ok )
847    {
848        cluster[cluster_index]->procs = value;
849    }
850    else
851    {
852        printf("[XML ERROR] illegal or missing <procs> attribute for cluster %d", 
853                cluster_index);
854        exit(1);
855    }
856
857    cluster_index++;
858} // end clusterNode()
859
860//////////////////////////////////////////////
861void clusterSetNode( xmlTextReaderPtr reader )
862{
863    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
864
865#if XML_PARSER_DEBUG
866printf("\n  clusters set\n");
867#endif
868
869    int status = xmlTextReaderRead ( reader );
870    while ( status == 1 ) 
871    {
872        const char* tag = (const char*)xmlTextReaderConstName(reader);
873
874        if      ( strcmp(tag,"cluster") == 0 ) clusterNode(reader);
875        else if ( strcmp(tag,"#text") == 0 ) { }
876        else if ( strcmp(tag,"clusterset") == 0 ) 
877        {
878            // checking source file consistency
879            if ( cluster_index != header->clusters )
880            {
881                printf("[XML ERROR] Wrong number of clusters\n");
882                exit(1);
883            }
884            else
885            {
886                return;
887            }
888        }
889        else 
890        {
891            printf("[XML ERROR] Unknown tag in clusterset node : %s",tag);
892            exit(1);
893        }
894        status = xmlTextReaderRead ( reader );
895    }
896} // end clusterSetNode()
897
898///////////////////////////////////////////
899void psegSetNode( xmlTextReaderPtr reader )
900{
901    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
902
903#if XML_PARSER_DEBUG
904printf("  psegs set\n");
905#endif
906
907    int status = xmlTextReaderRead ( reader );
908    while ( status == 1 ) 
909    {
910        const char* tag = (const char*)xmlTextReaderConstName(reader);
911
912        if      ( strcmp(tag,"pseg") == 0    ) psegNode(reader);
913        else if ( strcmp(tag,"#text") == 0 ) { }
914        else if ( strcmp(tag,"psegset") == 0  ) 
915        {
916            // checking source file consistency
917            if ( pseg_index != header->psegs )
918            {
919                printf("[XML ERROR] Wrong number of psegs\n");
920                exit(1);
921            }
922            else
923            {
924                return;
925            }
926        }
927        else 
928        {
929            printf("[XML ERROR] Unknown tag in psegset node : %s",tag);
930            exit(1);
931        }
932        status = xmlTextReaderRead ( reader );
933    }
934} // end psegSetNode()
935
936/////////////////////////////////////////////
937void globalSetNode( xmlTextReaderPtr reader )
938{
939    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
940
941#if XML_PARSER_DEBUG
942printf("  globals set\n");
943#endif
944
945    int status = xmlTextReaderRead ( reader );
946    while ( status == 1 ) 
947    {
948        const char* tag = (const char*)xmlTextReaderConstName(reader);
949
950        if      ( strcmp(tag,"vseg") == 0    ) vsegNode(reader);
951        else if ( strcmp(tag,"#text"  ) == 0 ) { }
952        else if ( strcmp(tag,"globalset") == 0  ) 
953        {
954            // checking source file consistency
955            if ( vseg_index != header->globals )
956            {
957                printf("[XML ERROR] Wrong number of global vsegs\n");
958                exit(1);
959            }
960            else
961            {
962                vseg_loc_index = 0;
963                return;
964            }
965        }
966        else 
967        {
968            printf("[XML ERROR] Unknown tag in globalset node : %s",tag);
969            exit(1);
970        }
971        status = xmlTextReaderRead ( reader );
972    }
973} // end globalSetNode()
974
975/////////////////////////////////////////////
976void vspaceSetNode( xmlTextReaderPtr reader )
977{
978    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
979
980#if XML_PARSER_DEBUG
981printf("\n  vspaces set\n");
982#endif
983
984    int status = xmlTextReaderRead ( reader );
985    while ( status == 1 ) 
986    {
987        const char* tag = (const char*)xmlTextReaderConstName(reader);
988
989        if      ( strcmp(tag,"vspace") == 0    ) vspaceNode(reader);
990        else if ( strcmp(tag,"#text"  ) == 0 ) { }
991        else if ( strcmp(tag,"vspaceset") == 0  ) 
992        {
993            // checking source file consistency
994            if ( vspace_index != header->vspaces )
995            {
996                printf("[XML ERROR] Wrong number of vspaces\n");
997                exit(1);
998            }
999            else
1000            {
1001                header->vsegs = vseg_index;
1002                header->vobjs = vobj_index;
1003                header->tasks = task_index;
1004                return;
1005            }
1006        }
1007        else 
1008        {
1009            printf("[XML ERROR] Unknown tag in vspaceset node : %s",tag);
1010            exit(1);
1011        }
1012        status = xmlTextReaderRead ( reader );
1013    }
1014} // end globalSetNode()
1015
1016//////////////////////////////////////////
1017void headerNode(xmlTextReaderPtr reader )
1018{
1019    char*               name;
1020    unsigned int        value;
1021    unsigned int        ok;
1022
1023    if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return;
1024
1025#if XML_PARSER_DEBUG
1026printf("mapping_info\n");
1027#endif
1028
1029    header = (mapping_header_t*)malloc(sizeof(mapping_header_t));
1030
1031    ////////// get name attribute
1032    name = getStringValue(reader, "name", &ok);
1033    if ( ok )
1034    {
1035#if XML_PARSER_DEBUG
1036printf("  name = %s\n", name);
1037#endif
1038        strncpy( header->name, name, 31);
1039    }     
1040    else
1041    {
1042        printf("[XML ERROR] illegal or missing <name> attribute in header\n");
1043        exit(1);
1044    }
1045
1046    /////////// get clusters attribute
1047    value = getIntValue(reader, "clusters", &ok);
1048    if ( ok )
1049    {
1050        if ( value >= MAX_CLUSTERS )
1051        {
1052            printf("[XML ERROR] The number of clusters is larger than %d\n", MAX_CLUSTERS);
1053            exit(1);
1054        }
1055#if XML_PARSER_DEBUG
1056printf("  clusters = %d\n", value);
1057#endif
1058        header->clusters  = value;
1059    }
1060    else
1061    {
1062        printf("[XML ERROR] illegal or missing <clusters> attribute in header\n");
1063        exit(1);
1064    }
1065
1066    ////////// get psegs attribute
1067    value = getIntValue(reader, "psegs", &ok);
1068    if ( ok )
1069    {
1070        if ( value >= MAX_PSEGS )
1071        {
1072            printf("[XML ERROR] The number of psegs is larger than %d\n", MAX_PSEGS);
1073            exit(1);
1074        }
1075#if XML_PARSER_DEBUG
1076printf("  psegs = %d\n", value);
1077#endif
1078        header->psegs = value;
1079    }
1080    else
1081    {
1082        printf("[XML ERROR] illegal or missing <psegs> attribute in header\n");
1083        exit(1);
1084    }
1085
1086    ///////// get ttys attribute
1087    value = getIntValue(reader, "ttys", &ok);
1088    if ( ok )
1089    {
1090#if XML_PARSER_DEBUG
1091printf("  ttys = %d\n", value);
1092#endif
1093        header->ttys  = value;
1094    }
1095    else
1096    {
1097        printf("[XML ERROR] illegal or missing <ttys> attribute in header\n");
1098        exit(1);
1099    }
1100
1101    ///////// get fbs attribute
1102    value = getIntValue(reader, "fbs", &ok);
1103    if ( ok )
1104    {
1105#if XML_PARSER_DEBUG
1106printf("  fbs = %d\n", value);
1107#endif
1108        header->fbs  = value;
1109    }
1110    else
1111    {
1112        printf("[XML ERROR] illegal or missing <fbs> attribute in header\n");
1113        exit(1);
1114    }
1115
1116    ///////// get vspaces attribute
1117    value = getIntValue(reader, "vspaces", &ok);
1118    if ( ok )
1119    {
1120        if ( value >= MAX_VSPACES )
1121        {
1122            printf("[XML ERROR] The number of vspaces is larger than %d\n", MAX_VSPACES);
1123            exit(1);
1124        }
1125#if XML_PARSER_DEBUG
1126printf("  vspaces = %d\n", value);
1127#endif
1128        header->vspaces  = value;
1129    }
1130    else
1131    {
1132        printf("[XML ERROR] illegal or missing <vspaces> attribute in mapping\n");
1133        exit(1);
1134    }
1135
1136    ////////// get globals attribute
1137    value = getIntValue(reader, "globals", &ok);
1138    if ( ok )
1139    {
1140        if ( value >= MAX_VSEGS )
1141        {
1142            printf("[XML ERROR] The number of globals is larger than %d\n", MAX_VSEGS);
1143            exit(1);
1144        }
1145#if XML_PARSER_DEBUG
1146printf("  globals = %d\n", value);
1147#endif
1148        header->globals  = value;
1149    }
1150    else
1151    {
1152        printf("[XML ERROR] illegal or missing <globals> attribute in mapping_info_header\n");
1153        exit(1);
1154    }
1155
1156    header->signature = IN_MAPPING_SIGNATURE;
1157
1158    int status = xmlTextReaderRead ( reader );
1159    while ( status == 1 ) 
1160    {
1161        const char* tag = (const char*)xmlTextReaderConstName(reader);
1162
1163        if      ( strcmp(tag,"clusterset")   == 0 ) clusterSetNode(reader);
1164        else if ( strcmp(tag,"psegset")      == 0 ) psegSetNode(reader);
1165        else if ( strcmp(tag,"globalset")   == 0 ) globalSetNode(reader);
1166        else if ( strcmp(tag,"vspaceset")    == 0 ) vspaceSetNode(reader);
1167        else if ( strcmp(tag,"#text")        == 0 ) { }
1168        else if ( strcmp(tag,"mapping_info") == 0 ) 
1169        {
1170#if XML_PARSER_DEBUG
1171printf("end mapping_info\n");
1172#endif
1173            return;
1174        }
1175        else 
1176        {
1177            printf("[XML ERROR] Unknown tag in header node : %s",tag);
1178            exit(1);
1179        }
1180        status = xmlTextReaderRead ( reader );
1181    }
1182} // end headerNode()
1183
1184///////////////////////////
1185void  buildBin( int fdout )
1186{
1187    unsigned int    cluster_id;
1188    unsigned int    pseg_id;
1189    unsigned int    vspace_id;
1190    unsigned int    vseg_id;
1191    unsigned int    vobj_id;
1192    unsigned int    task_id;
1193
1194    unsigned int    length;
1195
1196    // write header to binary file
1197    length = write(fdout, (char*)header, sizeof(mapping_header_t));
1198   
1199#if XML_PARSER_DEBUG
1200printf("\n*** write header\n");
1201#endif
1202
1203    if ( length != sizeof(mapping_header_t) )
1204    {
1205        perror("write header");
1206        exit(1);
1207    }
1208
1209    // write clusters
1210    for ( cluster_id = 0 ; cluster_id < header->clusters ; cluster_id++ )
1211    {
1212        length = write(fdout, (char*)cluster[cluster_id], sizeof(mapping_cluster_t));
1213   
1214#if XML_PARSER_DEBUG
1215printf("\n*** write cluster %d\n", cluster_id);
1216#endif
1217
1218        if ( length != sizeof(mapping_cluster_t) )
1219        {
1220            perror("write cluster");
1221            exit(1);
1222        }
1223    }
1224
1225    // write psegs
1226    for ( pseg_id = 0 ; pseg_id < header->psegs ; pseg_id++ )
1227    {
1228        length = write(fdout, (char*)pseg[pseg_id], sizeof(mapping_pseg_t));
1229   
1230#if XML_PARSER_DEBUG
1231printf("write pseg %d\n", pseg_id);
1232#endif
1233
1234        if ( length != sizeof(mapping_pseg_t) )
1235        {
1236            perror("write pseg");
1237            exit(1);
1238        }
1239    }
1240
1241    // write vspaces
1242    for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
1243    {
1244        length = write(fdout, (char*)vspace[vspace_id], sizeof(mapping_vspace_t));
1245   
1246#if XML_PARSER_DEBUG
1247printf("write vspace %d\n", vspace_id);
1248printf("vspace->vobj_offset: %d\n", vspace[vspace_id]->vobj_offset);
1249printf("vspace->vobjs: %d\n", vspace[vspace_id]->vobjs);
1250printf("header->vobjs: %d\n", header->vobjs);
1251#endif
1252
1253        if ( length != sizeof(mapping_vspace_t) )
1254        {
1255            perror("write vspace");
1256            exit(1);
1257        }
1258    }
1259
1260    // write vsegs
1261    for ( vseg_id = 0 ; vseg_id < header->vsegs ; vseg_id++ )
1262    {
1263        length = write(fdout, (char*)vseg[vseg_id], sizeof(mapping_vseg_t));
1264   
1265#if XML_PARSER_DEBUG
1266printf("write vseg %d\n", vseg_id);
1267#endif
1268
1269        if ( length != sizeof(mapping_vseg_t) )
1270        {
1271            perror("write vseg");
1272            exit(1);
1273        }
1274    }
1275   
1276    // write vobjs
1277    for ( vobj_id = 0 ; vobj_id < header->vobjs ; vobj_id++ )
1278    {
1279        length = write(fdout, (char*)vobj[vobj_id], sizeof(mapping_vobj_t));
1280   
1281#if XML_PARSER_DEBUG
1282printf("write vobj %d\n", vobj_id);
1283printf("write vobj name %s\n", vobj[vobj_id]->name);
1284printf("write vobj length %x\n", vobj[vobj_id]->length);
1285printf("write vobj type %d\n", vobj[vobj_id]->type);
1286#endif
1287
1288        if ( length != sizeof(mapping_vobj_t) )
1289        {
1290            perror("write vobj");
1291            exit(1);
1292        }
1293    }
1294
1295    // write tasks
1296    for ( task_id = 0 ; task_id < header->tasks ; task_id++ )
1297    {
1298        length = write(fdout, (char*)task[task_id], sizeof(mapping_task_t));
1299   
1300#if XML_PARSER_DEBUG
1301printf("write task %d\n", task_id);
1302#endif
1303
1304        if ( length != sizeof(mapping_task_t) )
1305        {
1306            perror("write task");
1307            exit(1);
1308        }
1309    }
1310} // end buildBin()
1311
1312/////////////////////////////////////
1313int  main ( int argc, char* argv[] )
1314{
1315    if ( argc < 3 ) 
1316    {
1317        printf("Usage: xml2bin <input_file_path> <output_file_path>\n");
1318        return 1;
1319    }
1320
1321    int fdout = open( argv[2], (O_CREAT | O_RDWR), S_IRWXU );
1322    if ( fdout < 0)
1323    {
1324        perror("open");
1325        exit(1);
1326    }
1327   
1328    LIBXML_TEST_VERSION;
1329
1330    int              status;
1331    xmlTextReaderPtr reader = xmlReaderForFile ( argv[1], NULL, 0 );
1332
1333    if ( reader != NULL ) 
1334    {
1335        status = xmlTextReaderRead ( reader );
1336        while ( status == 1 ) 
1337        {
1338            const char* tag = (const char*)xmlTextReaderConstName(reader);
1339            if ( strcmp(tag,"mapping_info") == 0 )
1340            { 
1341                headerNode( reader );
1342                buildBin( fdout );
1343            }
1344            else
1345            {
1346                printf("[XML ERROR] Wrong file type: \"%s\"\n", argv[1]);
1347                return 1;
1348            }
1349            status = xmlTextReaderRead ( reader );
1350        }
1351        xmlFreeTextReader ( reader );
1352
1353        if ( status != 0 ) 
1354        {
1355            printf("[XML ERROR] Wrong Syntax in \"%s\" file\n", argv[1]);
1356            return 1;
1357        }
1358    }
1359    return 0;
1360} // end main()
Note: See TracBrowser for help on using the repository browser.