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

Last change on this file since 174 was 174, checked in by leroy, 12 years ago

Fixing minor mssing newline on debug printf
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\n",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.