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

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

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