/////////////////////////////////////////////////////////////////////////////////////// // File : xml_parser.c // Date : 14/04/2012 // Author : alain greiner // Copyright (c) UPMC-LIP6 /////////////////////////////////////////////////////////////////////////////////////// // This program translate an xml file containing a MAPPING_INFO data structure // to a binary file that can be directly loaded in the boot ROM and used by the GIET. // The C strcutures are defined in the mapping_info.h file. /////////////////////////////////////////////////////////////////////////////////////// #include #include #include #include #include #include #include #include #include #include #define MAX_CLUSTERS 1024 #define MAX_PSEGS 4096 #define MAX_VSPACES 1024 #define MAX_TASKS 4096 #define MAX_MWMRS 4096 #define MAX_VSEGS 4096 #define MAX_VOBJS 8192 #define MAX_PROCS 1024 #define MAX_IRQS 8192 #define MAX_COPROCS 4096 #define MAX_CP_PORTS 8192 #define MAX_CP_REGS 8192 #define XML_PARSER_DEBUG 1 /////////////////////////////////////////////////////////////////////////////////// // global variables used to store and index the data structures /////////////////////////////////////////////////////////////////////////////////// mapping_header_t* header; mapping_cluster_t* cluster[MAX_CLUSTERS]; // cluster array mapping_pseg_t* pseg[MAX_PSEGS]; // pseg array mapping_vspace_t* vspace[MAX_VSPACES]; // vspace array mapping_vseg_t* vseg[MAX_VSEGS]; // vseg array mapping_vobj_t* vobj[MAX_VOBJS]; // vobj array mapping_task_t* task[MAX_TASKS]; // task array mapping_proc_t* proc[MAX_PROCS]; // proc array mapping_irq_t* irq[MAX_IRQS]; // irq array mapping_coproc_t* coproc[MAX_COPROCS]; // coproc array mapping_coproc_port_t* cp_port[MAX_CP_PORTS]; // coproc port array mapping_coproc_reg_t* cp_reg[MAX_CP_REGS]; // coproc reg array typedef struct vobj_ref_s { char vspace_name[32]; char vobj_name[32]; }vobj_ref_t; // This arrray is useful to temporary save the a vobj referece // formed by a vspace_name and a vobj_name (struct vobj_ref_s). // This arry will be used to set the attribute vobj_id of coproc_port // once all the vspace have been parsed. vobj_ref_t* cp_port_vobj_ref[MAX_CP_PORTS]; unsigned int cluster_index = 0; unsigned int vspace_index = 0; unsigned int global_index = 0; unsigned int pseg_index = 0; unsigned int proc_index = 0; unsigned int proc_loc_index = 0; unsigned int irq_index = 0; unsigned int irq_loc_index = 0; unsigned int coproc_index = 0; unsigned int coproc_loc_index = 0; unsigned int cp_port_index = 0; unsigned int cp_port_loc_index = 0; unsigned int cp_reg_index = 0; unsigned int cp_reg_loc_index = 0; unsigned int vseg_index = 0; unsigned int vseg_loc_index = 0; unsigned int task_index = 0; unsigned int task_loc_index = 0; unsigned int vobj_index = 0; unsigned int vobj_loc_index = 0; unsigned int vobj_count = 0; unsigned int tty_index = 1; unsigned int fb_index = 0; ////////////////////////////////////////////////// unsigned int getIntValue( xmlTextReaderPtr reader, const char* attributeName, unsigned int* ok ) { unsigned int value = 0; unsigned int i; char c; char* string = (char*)xmlTextReaderGetAttribute(reader, (const xmlChar*)attributeName); if ( string == NULL ) // missing argument { *ok = 0; return 0; } else { if ( (string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X')) ) // Hexa { for ( i = 2 ; (string[i] != 0) && (i < 10) ; i++ ) { c = string[i]; if ((c >= '0') && (c <= '9')) value = (value<<4) + string[i] - 48; else if ((c >= 'a') && (c <= 'f')) value = (value<<4) + string[i] - 87; else if ((c >= 'A') && (c <= 'F')) value = (value<<4) + string[i] - 55; else { *ok = 0; return 0; } } } else // Decimal { for ( i = 0 ; (string[i] != 0) && (i < 9) ; i++ ) { c = string[i]; if ((c >= '0') && (c <= '9')) value = (value*10) + string[i] - 48; else { *ok = 0; return 0; } } } *ok = 1; return value; } } // end getIntValue() /////////////////////////////////////////////// char* getStringValue ( xmlTextReaderPtr reader, const char* attributeName, unsigned int* ok ) { char* string = (char*)xmlTextReaderGetAttribute(reader, (const xmlChar*)attributeName); if ( string == NULL ) // missing argument { *ok = 0; return NULL; } else { *ok = 1; return string; } } // end getStringValue() /////////////////////////////////////// int getPsegId( unsigned int cluster_id, char* pseg_name ) { unsigned int pseg_id; unsigned int pseg_min = cluster[cluster_id]->pseg_offset; unsigned int pseg_max = pseg_min + cluster[cluster_id]->psegs; for ( pseg_id = pseg_min ; pseg_id < pseg_max ; pseg_id++ ) { if ( strcmp(pseg[pseg_id]->name, pseg_name) == 0 ) return pseg_id; } return -1; } //////////////////////////////////////////// int getVspaceId( char* vspace_name) //////////////////////////////////////////// { unsigned int vspace_id; for( vspace_id = 0; vspace_id < vspace_index ; vspace_id++) { if( !strcmp(vspace[vspace_id]->name, vspace_name)) { return vspace_id; } } return -1; } //////////////////////////////////////////// int getVobjLocId( unsigned int vspace_id, char* vobj_name, unsigned int vspace_max) //////////////////////////////////////////// { unsigned int vobj_id; unsigned int vobj_min = vspace[vspace_id]->vobj_offset; unsigned int vobj_max = vobj_min + vspace_max; for ( vobj_id = vobj_min ; vobj_id < vobj_max ; vobj_id++ ) { if ( strcmp(vobj[vobj_id]->name, vobj_name) == 0 ) { return (vobj_id - vobj_min); } } return -1; } /////////////////////////////////////////// void cpPortNode ( xmlTextReaderPtr reader ) /////////////////////////////////////////// { char* str; unsigned int ok; if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; if ( cp_port_index >= MAX_CP_PORTS ) { printf("[XML ERROR] The number of ports (for coprocs) is larger than %d\n", MAX_CP_PORTS); } #if XML_PARSER_DEBUG printf("\n port %d\n", cp_port_index); #endif cp_port[cp_port_index] = (mapping_coproc_port_t*)malloc(sizeof(mapping_coproc_port_t)); cp_port_vobj_ref[cp_port_index] = (vobj_ref_t*)malloc(sizeof(vobj_ref_t)); ///////// get direction attribute str = getStringValue( reader, "direction", &ok ); if ( ok ) { #if XML_PARSER_DEBUG printf(" direction = %s\n", str); #endif if ( strcmp(str, "TO_COPROC") ) cp_port[cp_port_index]->direction = PORT_TO_COPROC; else if ( strcmp(str, "FROM_COPROC") ) cp_port[cp_port_index]->direction = PORT_FROM_COPROC; else { printf("[XML ERROR] illegal for coproc_port %d in cluster %d\n", cp_port_index, cluster_index); exit(1); } } else { printf("[XML ERROR] missing for coproc_port %d in cluster %d\n", cp_port_index, cluster_index); exit(1); } /////////// get vspacename attribute str = getStringValue( reader, "vspacename", &ok ); #if XML_PARSER_DEBUG printf(" vspacename = %s\n", str); #endif if ( ok ) { strncpy(cp_port_vobj_ref[cp_port_index]->vspace_name, str, 31); } else { printf("[XML ERROR] missing for coproc_port %d in cluster %d\n", cp_port_index, cluster_index); exit(1); } /////////// get vobjname attribute str = getStringValue( reader, "vobjname", &ok ); #if XML_PARSER_DEBUG printf(" vobjname = %s\n", str); #endif if ( ok ) { strncpy(cp_port_vobj_ref[cp_port_index]->vobj_name, str, 31); } else { printf("[XML ERROR] missing for coproc_port %d in cluster %d\n", cp_port_index, cluster_index); exit(1); } cp_port_index++; cp_port_loc_index++; } // end cpPortNode() ///////////////////////////////////////// void cpRegNode ( xmlTextReaderPtr reader ) ///////////////////////////////////////// { char* str; unsigned int value; unsigned int ok; if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; /* TWO: check source file consistency if possible */ if ( cp_reg_index >= MAX_CP_REGS ) { printf("[XML ERROR] The number of regs (for coprocs) is larger than %d\n", MAX_CP_REGS); } #if XML_PARSER_DEBUG printf("\n reg %d\n", cp_reg_index); #endif /* THIRD*/ cp_reg[cp_reg_index] = (mapping_coproc_reg_t*)malloc(sizeof(mapping_coproc_reg_t)); /* FOURTH: read all attribute*/ /////////// get name attribute str = getStringValue( reader, "name", &ok ); #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif if ( ok ) { strncpy(cp_reg[cp_reg_index]->name, str, 31); } else { printf("[XML ERROR] illegal or missing for coproc_reg %d in cluster %d\n", cp_reg_index, cluster_index); exit(1); } ///////// get type attribute str = getStringValue( reader, "type", &ok ); if ( ok ) { #if XML_PARSER_DEBUG printf(" type = %s\n", str); #endif if ( strcmp(str, "STATUS") ) cp_reg[cp_reg_index]->type = REG_TYPE_STATUS; else if ( strcmp(str, "CONFIG") ) cp_reg[cp_reg_index]->type = REG_TYPE_CONFIG; else { printf("[XML ERROR] illegal for coproc_reg %d in cluster %d\n", cp_reg_index, cluster_index); exit(1); } } else { printf("[XML ERROR] missing for coproc_reg %d in cluster %d\n", cp_reg_index, cluster_index); exit(1); } ///////// get value attribute value = getIntValue(reader, "value", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" value = %d\n", value); #endif cp_reg[cp_reg_index]->value = value; } else { printf("[XML ERROR] illegal or missing for coproc_reg %d in cluster %d\n", cp_reg_index, cluster_index); exit(1); } ///////// get channel attribute value = getIntValue(reader, "channel", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" channel = %d\n", value); #endif cp_reg[cp_reg_index]->channel_id = value; } else { printf("[XML ERROR] illegal or missing for coproc_reg %d in cluster %d\n", cp_reg_index, cluster_index); exit(1); } ///////// get index attribute value = getIntValue(reader, "index", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" index = %d\n", value); #endif cp_reg[cp_reg_index]->loc_id = value; } else { printf("[XML ERROR] illegal or missing for coproc_reg %d in cluster %d\n", cp_reg_index, cluster_index); exit(1); } cp_reg_index++; cp_reg_loc_index++; } // end cpRegNode() ///////////////////////////////////////// void coprocNode ( xmlTextReaderPtr reader ) ///////////////////////////////////////// { char* str; unsigned int ok; cp_port_loc_index = 0; cp_reg_loc_index = 0; if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; if ( coproc_index >= MAX_COPROCS ) { printf("[XML ERROR] The number of coprocs is larger than %d\n", MAX_COPROCS); } #if XML_PARSER_DEBUG printf("\n coproc %d\n", coproc_index); #endif coproc[coproc_index] = (mapping_coproc_t*)malloc(sizeof(mapping_coproc_t)); /////////// get name attribute str = getStringValue( reader, "name", &ok ); if ( ok ) { #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif strncpy(coproc[coproc_index]->name, str, 31); } else { printf("[XML ERROR] illegal or missing for coproc %d in cluster %d\n", coproc_index, cluster_index); exit(1); } /////////// get psegname attribute str = getStringValue(reader,"psegname", &ok); if ( ok == 0 ) { printf("[XML ERROR] illegal or missing for coproc %d in cluster %d\n", coproc_index, cluster_index); exit(1); } /////////// set psegid attribute int index = getPsegId( cluster_index, str ); if ( index >= 0 ) { #if XML_PARSER_DEBUG printf(" clusterid = %d\n", cluster_index); printf(" psegname = %s\n", str); printf(" psegid = %d\n", index); #endif coproc[coproc_index]->psegid = index; assert(pseg[index]->type == PSEG_TYPE_PERI && "coproc psegname attribute must refer to a pseg of type PERI" ); } else { printf("[XML ERROR] pseg not found for coproc %d / clusterid = %d / psegname = %s\n", coproc_index, cluster_index, str ); exit(1); } ////////// set port_offset and reg_offset attribute coproc[coproc_index]->port_offset = cp_port_index; coproc[coproc_index]->reg_offset = cp_reg_index; #if XML_PARSER_DEBUG printf(" port_offset = %d\n", cp_port_index); printf(" reg_offset = %d\n", cp_reg_index); #endif int status = xmlTextReaderRead(reader); while ( status == 1 ) { const char* tag = (const char*)xmlTextReaderConstName(reader); if ( strcmp(tag,"port") == 0 ) cpPortNode(reader); else if ( strcmp(tag,"reg") == 0 ) cpRegNode(reader); else if ( strcmp(tag,"#text") == 0 ) { } else if ( strcmp(tag,"coproc") == 0 ) { coproc[coproc_index]->ports = cp_port_loc_index; coproc[coproc_index]->regs = cp_reg_loc_index; coproc_loc_index++; coproc_index++; return; } else { printf("[XML ERROR] Unknown tag %s",tag); exit(1); } status = xmlTextReaderRead ( reader ); } } // end coprocNode() /////////////////////////////////////// void irqNode( xmlTextReaderPtr reader ) /////////////////////////////////////// { unsigned int ok; unsigned int value; char* str; if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; if ( irq_index >= MAX_IRQS ) { printf("[XML ERROR] The number of irqs is larger than %d\n", MAX_IRQS); } #if XML_PARSER_DEBUG printf(" irq %d\n", irq_loc_index); #endif irq[irq_index] = (mapping_irq_t*)malloc(sizeof(mapping_irq_t)); ///////// get type attribute str = getStringValue(reader,"type", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" type = %s\n", str); #endif if ( strcmp(str, "HARD") ) irq[irq_index]->type = IRQ_TYPE_HARD; else if ( strcmp(str, "SOFT") ) irq[irq_index]->type = IRQ_TYPE_SOFT; else { printf("[XML ERROR] undefined IRQ for processor %d in cluster %d\n", cluster_index, proc_loc_index ); exit(1); } } else { printf("[XML ERROR] missing IRQ for processor %d in cluster %d\n", cluster_index, proc_loc_index ); exit(1); } ///////// get irqid attribute value = getIntValue(reader, "icuid", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" icuid = %d\n", value); #endif irq[irq_index]->icuid = value; if ( value >= 32 ) { printf("[XML ERROR] IRQ too large for processor %d in cluster %d\n", cluster_index, proc_loc_index ); exit(1); } } else { printf("[XML ERROR] missing IRQ for processor %d in cluster %d\n", cluster_index, proc_loc_index ); exit(1); } ///////// get isr attribute str = getStringValue(reader,"isr", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" isr = %s\n", str); #endif if ( strcmp(str, "ISR_SWITCH") ) irq[irq_index]->isr = ISR_SWITCH; else if ( strcmp(str, "ISR_IOC") ) irq[irq_index]->isr = ISR_IOC; else if ( strcmp(str, "ISR_FBDMA") ) irq[irq_index]->isr = ISR_FBDMA; else if ( strcmp(str, "ISR_TTY") ) irq[irq_index]->isr = ISR_TTY; else { printf("[XML ERROR] illegal IRQ for processor %d in cluster %d\n", cluster_index, proc_loc_index ); exit(1); } } else { printf("[XML ERROR] missing IRQ for processor %d in cluster %d\n", cluster_index, proc_loc_index ); exit(1); } ///////// get channel attribute (optionnal : 0 if missing) value = getIntValue(reader, "channel", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" channel = %d\n", value); #endif irq[irq_index]->channel = value; } else { irq[irq_index]->channel = 0; } irq_index++; irq_loc_index++; } // end irqNode ///////////////////////////////////////// void procNode ( xmlTextReaderPtr reader ) ///////////////////////////////////////// { unsigned int ok; unsigned int value; irq_loc_index = 0; if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; if ( proc_index >= MAX_PROCS ) { printf("[XML ERROR] The number of procs is larger than %d\n", MAX_PROCS); } #if XML_PARSER_DEBUG printf("\n proc %d\n", proc_index); #endif proc[proc_index] = (mapping_proc_t*)malloc(sizeof(mapping_proc_t)); /////////// get index attribute (optional) value = getIntValue(reader,"index",&ok); if ( ok && (value != proc_index) ) { printf("[XML ERROR] wrong proc index / expected value is %d", proc_index); exit(1); } ////////// set irq_offset attribute proc[proc_index]->irq_offset = irq_index; #if XML_PARSER_DEBUG printf(" irq_offset = %d\n", irq_index); #endif int status = xmlTextReaderRead(reader); while ( status == 1 ) { const char* tag = (const char*)xmlTextReaderConstName(reader); if ( strcmp(tag,"irq") == 0 ) irqNode(reader); else if ( strcmp(tag,"#text") == 0 ) { } else if ( strcmp(tag,"proc") == 0 ) { proc[proc_index]->irqs = irq_loc_index; proc_loc_index++; proc_index++; return; } else { printf("[XML ERROR] Unknown tag %s",tag); exit(1); } status = xmlTextReaderRead ( reader ); } } // end procNode() ///////////////////////////////////////// void taskNode ( xmlTextReaderPtr reader ) ///////////////////////////////////////// { unsigned int ok; unsigned int value; char* str; if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; if ( task_index >= MAX_TASKS ) { printf("[XML ERROR] The number of tasks is larger than %d\n", MAX_TASKS); } #if XML_PARSER_DEBUG printf(" task %d\n", task_loc_index); #endif task[task_index] = (mapping_task_t*)malloc(sizeof(mapping_task_t)); ////////// get name attribute str = getStringValue(reader, "name", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif strncpy( task[task_index]->name, str, 31 ); } else { printf("[XML ERROR] illegal or missing attribute for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } ///////// get clusterid attribute value = getIntValue(reader,"clusterid", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" clusterid = %x\n", value); #endif if ( value >= header->clusters ) { printf("[XML ERROR] too large for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } task[task_index]->clusterid = value; } else { printf("[XML ERROR] illegal or missing attribute for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } ////////// get proclocid attribute value = getIntValue(reader,"proclocid", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" proclocid = %x\n", value); #endif if ( value >= cluster[task[task_index]->clusterid]->procs ) { printf("[XML ERROR] too large for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } task[task_index]->proclocid = value; } else { printf("[XML ERROR] illegal or missing attribute for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } ////////// get stackname attribute str = getStringValue(reader, "stackname" , &ok); if ( ok ) { int index = getVobjLocId( vspace_index, str , vobj_loc_index); if ( index >= 0 ) { #if XML_PARSER_DEBUG printf(" stackname = %s\n", str); printf(" stackid = %d\n", index); #endif task[task_index]->vobjlocid = index; } else { printf("[XML ERROR] illegal or missing for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } } else { printf("[XML ERROR] illegal or missing for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } ////////// get startid attribute value = getIntValue(reader,"startid", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" startid = %x\n", value); #endif task[task_index]->startid = value; } else { printf("[XML ERROR] illegal or missing attribute for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } /////////// get use_tty attribute (optionnal : 0 if missing) value = getIntValue(reader,"usetty", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" usetty = %x\n", value); #endif if ( (value != 0) && (tty_index >= header->ttys) ) { printf("[XML ERROR] The tty index is too large for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } task[task_index]->use_tty = value; if (value != 0) tty_index++; } else { task[task_index]->use_tty = 0; } /////////// get use_fb attribute (optionnal : 0 if missing) value = getIntValue(reader,"usefb", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" usefb = %x\n", value); #endif if ( (value != 0) && (fb_index >= header->fbs) ) { printf("[XML ERROR] The fb channel index is too large for task (%d,%d)\n", vspace_index, task_loc_index); exit(1); } task[task_index]->use_fb = value; if (value != 0) fb_index++; } else { task[task_index]->use_fb = 0; } task_index++; task_loc_index++; } // end taskNode() ////////////////////////////////////////// void vobjNode ( xmlTextReaderPtr reader ) { unsigned int ok; unsigned int value; char* str; if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; if ( vobj_index >= MAX_VOBJS ) { printf("[XML ERROR] The number of vobjs is larger than %d\n", MAX_VSEGS); exit(1); } #if XML_PARSER_DEBUG printf(" vobj %d\n", vobj_loc_index); #endif vobj[vobj_index] = (mapping_vobj_t*)malloc(sizeof(mapping_vobj_t)); ///////// get name attribute str = getStringValue(reader, "name", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif strncpy( vobj[vobj_index]->name, str, 31); } else { printf("[XML ERROR] illegal or missing attribute for vobj (%d,%d)\n", vseg_index, vobj_loc_index); exit(1); } //////// get type attribute char *type_str = getStringValue(reader, "type", &ok); #if XML_PARSER_DEBUG printf(" type = %s\n", type_str); #endif if (ok && (strcmp(type_str, "ELF") == 0)) { vobj[vobj_index]->type = VOBJ_TYPE_ELF; //check that this vobj is the first in vseg if(vobj_count != 0) { printf("[XML ERROR] an ELF vobj must be alone in a vseg (%d,%d)\n", vspace_index, vobj_loc_index); exit(1); } } else if (ok && (strcmp(str, "BLOB") == 0)) vobj[vobj_index]->type = VOBJ_TYPE_BLOB; else if (ok && (strcmp(str, "PTAB") == 0)) vobj[vobj_index]->type = VOBJ_TYPE_PTAB; else if (ok && (strcmp(str, "PERI") == 0)) vobj[vobj_index]->type = VOBJ_TYPE_PERI; else if (ok && (strcmp(str, "MWMR") == 0)) vobj[vobj_index]->type = VOBJ_TYPE_MWMR; else if (ok && (strcmp(str, "LOCK") == 0)) vobj[vobj_index]->type = VOBJ_TYPE_LOCK; else if (ok && (strcmp(str, "BUFFER") == 0)) vobj[vobj_index]->type = VOBJ_TYPE_BUFFER; else if (ok && (strcmp(str, "BARRIER") == 0)) vobj[vobj_index]->type = VOBJ_TYPE_BARRIER; else { printf("[XML ERROR] illegal or missing attribute for vobj (%d,%d)\n", vspace_index, vobj_loc_index); exit(1); } ////////// get length attribute value = getIntValue(reader,"length", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" length = %d\n", value); #endif vobj[vobj_index]->length = value; } else { printf("[XML ERROR] illegal or missing attribute for vobj (%d,%d)\n", vspace_index, vobj_loc_index); exit(1); } ////////// get align attribute (optional : 0 if missing) value = getIntValue(reader,"align", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" align = %d\n", value); #endif vobj[vobj_index]->align = value; } else { vobj[vobj_index]->align = 0; } ////////// get binpath attribute (optional : '\0' if missing) str = getStringValue(reader, "binpath", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" binpath = %s\n", str); #endif strncpy(vobj[vobj_index]->binpath, str, 63); } else { vobj[vobj_index]->binpath[0] = '\0'; } ////////// get init attribute (mandatory for mwmr and barrier) value = getIntValue(reader,"init", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" init = %d\n", value); #endif vobj[vobj_index]->init = value; } else { if((vobj[vobj_index]->type == VOBJ_TYPE_MWMR || vobj[vobj_index]->type == VOBJ_TYPE_BARRIER )) { printf("[XML ERROR] illegal or missing attribute for vobj (%d,%d). \ All MWMR or BARRIER vobj must have a init value \n", vspace_index, vobj_loc_index); exit(1); } vobj[vobj_index]->init = 0; } vobj_index++; vobj_count++; vobj_loc_index++; } // end vobjNode() ////////////////////////////////////////// void vsegNode ( xmlTextReaderPtr reader ) { unsigned int ok; unsigned int value; char* str; vobj_count = 0; if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; if ( vseg_index >= MAX_VSEGS ) { printf("[XML ERROR] The number of vsegs is larger than %d\n", MAX_VSEGS); exit(1); } #if XML_PARSER_DEBUG printf(" vseg %d\n", vseg_loc_index); #endif vseg[vseg_index] = (mapping_vseg_t*)malloc(sizeof(mapping_vseg_t)); ////////// set vobj_offset attributes vseg[vseg_index]->vobj_offset = vobj_index; #if XML_PARSER_DEBUG printf(" vobj_offset = %d\n", vobj_index); #endif ///////// get name attribute str = getStringValue(reader, "name", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif strncpy( vseg[vseg_index]->name, str, 31); } else { printf("[XML ERROR] illegal or missing attribute for vseg (%d,%d)\n", vspace_index, vseg_loc_index); exit(1); } /////////// get vbase attribute value = getIntValue(reader,"vbase", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" vbase = 0x%x\n", value); #endif vseg[vseg_index]->vbase = value; } else { printf("[XML ERROR] illegal or missing attribute for vseg (%d,%d)\n", vspace_index, vseg_loc_index); exit(1); } ////////// get clusterid and psegname attributes value = getIntValue(reader,"clusterid", &ok); if ( ok == 0 ) { printf("[XML ERROR] illegal or missing for vseg %d\n", vseg_loc_index); exit(1); } str = getStringValue(reader,"psegname", &ok); if ( ok == 0 ) { printf("[XML ERROR] illegal or missing for vseg %d\n", vseg_loc_index); exit(1); } /////////// set psegid field int index = getPsegId( value, str ); if ( index >= 0 ) { #if XML_PARSER_DEBUG printf(" clusterid = %d\n", value); printf(" psegname = %s\n", str); printf(" psegid = %d\n", index); #endif vseg[vseg_index]->psegid = index; } else { printf("[XML ERROR] pseg not found for vseg %d / clusterid = %d / psegname = %s\n", vseg_loc_index, value, str ); exit(1); } ////////// get ident attribute (optional : 0 if missing) value = getIntValue(reader,"ident", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" ident = %d\n", value); #endif vseg[vseg_index]->ident = value; } else { vseg[vseg_index]->ident = 0; } //////// get mode attribute str = getStringValue(reader,"mode", &ok); #if XML_PARSER_DEBUG printf(" mode = %s\n", str); #endif if (ok && (strcmp(str, "CXWU") == 0)) vseg[vseg_index]->mode = 0xF; else if (ok && (strcmp(str, "CXW_") == 0)) vseg[vseg_index]->mode = 0xE; else if (ok && (strcmp(str, "CX_U") == 0)) vseg[vseg_index]->mode = 0xD; else if (ok && (strcmp(str, "CX__") == 0)) vseg[vseg_index]->mode = 0xC; else if (ok && (strcmp(str, "C_WU") == 0)) vseg[vseg_index]->mode = 0xB; else if (ok && (strcmp(str, "C_W_") == 0)) vseg[vseg_index]->mode = 0xA; else if (ok && (strcmp(str, "C__U") == 0)) vseg[vseg_index]->mode = 0x9; else if (ok && (strcmp(str, "C___") == 0)) vseg[vseg_index]->mode = 0x8; else if (ok && (strcmp(str, "_XWU") == 0)) vseg[vseg_index]->mode = 0x7; else if (ok && (strcmp(str, "_XW_") == 0)) vseg[vseg_index]->mode = 0x6; else if (ok && (strcmp(str, "_X_U") == 0)) vseg[vseg_index]->mode = 0x5; else if (ok && (strcmp(str, "_X__") == 0)) vseg[vseg_index]->mode = 0x4; else if (ok && (strcmp(str, "__WU") == 0)) vseg[vseg_index]->mode = 0x3; else if (ok && (strcmp(str, "__W_") == 0)) vseg[vseg_index]->mode = 0x2; else if (ok && (strcmp(str, "___U") == 0)) vseg[vseg_index]->mode = 0x1; else if (ok && (strcmp(str, "____") == 0)) vseg[vseg_index]->mode = 0x0; else { printf("[XML ERROR] illegal or missing attribute for vseg (%d,%d)\n", vspace_index, vseg_loc_index); exit(1); } ////////// get vobjs in vseg int status = xmlTextReaderRead(reader); while ( status == 1 ) { const char* tag = (const char*)xmlTextReaderConstName(reader); if ( strcmp(tag,"vobj") == 0 ) vobjNode(reader); else if ( strcmp(tag,"#text" ) == 0 ) { } else if ( strcmp(tag,"vseg") == 0 ) { vseg[vseg_index]->vobjs = vobj_count; vseg_index++; vseg_loc_index++; return; } else { printf("[XML ERROR] Unknown tag %s",tag); exit(1); } status = xmlTextReaderRead ( reader ); } } // end vsegNode() ////////////////////////////////////////// void vspaceNode( xmlTextReaderPtr reader ) { char* str; unsigned int ok; vobj_loc_index = 0; vseg_loc_index = 0; task_loc_index = 0; if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; // checking source file consistency if ( vspace_index >= header->vspaces ) { printf("[XML ERROR] The vspace index is too large : %d\n", vspace_index); exit(1); } #if XML_PARSER_DEBUG printf("\n vspace %d\n", vspace_index); #endif vspace[vspace_index] = (mapping_vspace_t*)malloc(sizeof(mapping_vspace_t)); ////////// get name attribute str = getStringValue(reader, "name", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif strncpy(vspace[vspace_index]->name, str, 31); } else { printf("[XML ERROR] illegal or missing attribute for vspace %d\n", vspace_index); exit(1); } ////////// set vseg_offset and task_offset attributes vspace[vspace_index]->vseg_offset = vseg_index; vspace[vspace_index]->vobj_offset = vobj_index; vspace[vspace_index]->task_offset = task_index; #if XML_PARSER_DEBUG printf(" vseg_offset = %d\n", vseg_index); printf(" vobj_offset = %d\n", vobj_index); printf(" task_offset = %d\n", task_index); #endif ////////// get startname attribute str = getStringValue(reader, "startname", &ok); if ( ok ) { //used after parsing the vobjs } else { printf("[XML ERROR] illegal or missing attribute for vspace %d\n", vspace_index); exit(1); } int status = xmlTextReaderRead(reader); while ( status == 1 ) { const char* tag = (const char*)xmlTextReaderConstName(reader); if ( strcmp(tag,"vseg") == 0 ) vsegNode(reader); else if ( strcmp(tag,"task") == 0 ) taskNode(reader); else if ( strcmp(tag,"#text") == 0 ) { } else if ( strcmp(tag,"vspace") == 0 ) { vspace[vspace_index]->vobjs = vobj_loc_index; vspace[vspace_index]->tasks = task_loc_index ; vspace[vspace_index]->vsegs = vseg_loc_index ; // get index of the vobj containing the start vector int index = getVobjLocId( vspace_index, str , vobj_loc_index ); if(index == -1) { printf("[XML ERROR] vobj containing the start vector not found %s\n",str); exit(-1); } else { vspace[vspace_index]->start_offset = index; #if XML_PARSER_DEBUG printf(" startname = %s\n", str); printf(" startid = %d\n", index); printf(" end vspace %d\n\n", vspace_index); #endif } // checking startid values for all tasks in vspace int task_id; int task_min = vspace[vspace_index]->task_offset; int task_max = task_min + vspace[vspace_index]->tasks; for ( task_id = task_min ; task_id < task_max ; task_id++ ) { if ( task[task_id]->startid >= vspace[vspace_index]->tasks ) { printf("[XML ERROR] too large for task (%d,%d)\n", vspace_index, task_id ); exit(1); } } vspace_index++; return; } else { printf("[XML ERROR] Unknown tag %s",tag); exit(1); } status = xmlTextReaderRead ( reader ); } } // end vspaceNode() ////////////////////////////////////////// void psegNode ( xmlTextReaderPtr reader ) { unsigned int ok; unsigned int value; char* str; if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; if ( pseg_index >= MAX_PSEGS ) { printf("[XML ERROR] The number of psegs is larger than %d\n", MAX_PSEGS); exit(1); } #if XML_PARSER_DEBUG printf(" pseg %d\n", pseg_index); #endif pseg[pseg_index] = (mapping_pseg_t*)malloc(sizeof(mapping_pseg_t)); /////// get name attribute str = getStringValue( reader, "name", &ok ); #if XML_PARSER_DEBUG printf(" name = %s\n", str); #endif if ( ok ) { strncpy(pseg[pseg_index]->name, str, 31); } else { printf("[XML ERROR] illegal or missing for pseg %d in cluster %d\n", pseg_index, cluster_index); exit(1); } //////// get type attribute str = getStringValue(reader, "type", &ok); #if XML_PARSER_DEBUG printf(" type = %s\n", str); #endif if (ok && (strcmp(str, "RAM" ) == 0)) pseg[pseg_index]->type = PSEG_TYPE_RAM; else if (ok && (strcmp(str, "ROM" ) == 0)) pseg[pseg_index]->type = PSEG_TYPE_ROM; else if (ok && (strcmp(str, "PERI") == 0)) pseg[pseg_index]->type = PSEG_TYPE_PERI; else { printf("[XML ERROR] illegal or missing for pseg %s in cluster %d\n", pseg[pseg_index]->name, cluster_index); exit(1); } //////// get base attribute value = getIntValue( reader, "base", &ok ); #if XML_PARSER_DEBUG printf(" base = 0x%x\n", value); #endif if ( ok ) { pseg[pseg_index]->base = value; } else { printf("[XML ERROR] illegal or missing for pseg %s in cluster %d\n", pseg[pseg_index]->name, cluster_index); exit(1); } //////// get length attribute value = getIntValue( reader, "length", &ok ); #if XML_PARSER_DEBUG printf(" length = 0x%x\n", value); #endif if ( ok ) { pseg[pseg_index]->length = value; } else { printf("[XML ERROR] illegal or missing for pseg %s in cluster %d\n", pseg[pseg_index]->name, cluster_index); exit(1); } //////// set cluster attribute pseg[pseg_index]->cluster = cluster_index; pseg_index++; cluster[cluster_index]->psegs++; } // end psegNode() ///////////////////////////////////////////// void clusterNode ( xmlTextReaderPtr reader ) { unsigned int ok; unsigned int value; proc_loc_index = 0; coproc_loc_index = 0; cluster[cluster_index] = 0; if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; // checking source file consistency if ( cluster_index >= header->clusters ) { printf("[XML ERROR] The cluster index is too large : %d\n", cluster_index); exit(1); } #if XML_PARSER_DEBUG printf(" cluster %d\n", cluster_index); #endif cluster[cluster_index] = (mapping_cluster_t*)malloc(sizeof(mapping_cluster_t)); /////////// get index attribute (optional) value = getIntValue(reader,"index",&ok); if ( ok && (value != cluster_index) ) { printf("[XML ERROR] wrong cluster index / expected value is %d", cluster_index); exit(1); } ////////// set pseg_offset attribute cluster[cluster_index]->pseg_offset = pseg_index; cluster[cluster_index]->proc_offset = proc_index; cluster[cluster_index]->coproc_offset = coproc_index; #if XML_PARSER_DEBUG printf(" pseg_offset = %d\n", pseg_index); printf(" proc_offset = %d\n", proc_index); printf(" coproc_offset = %d\n", coproc_index); #endif ////////// get psegs, coproc and/or procs int status = xmlTextReaderRead(reader); while ( status == 1 ) { const char* tag = (const char*)xmlTextReaderConstName(reader); if ( strcmp(tag, "pseg") == 0 ) psegNode(reader); else if ( strcmp(tag, "proc") == 0 ) procNode(reader); else if ( strcmp(tag, "coproc") == 0 ) coprocNode(reader); else if ( strcmp(tag, "#text") == 0 ) { } else if ( strcmp(tag, "cluster") == 0 ) { #if XML_PARSER_DEBUG printf(" end cluster %d\n", cluster_index); #endif cluster[cluster_index]->procs = proc_loc_index; cluster[cluster_index]->coprocs = coproc_loc_index; //psegs = pseg_loc_index is done in psegNode(), so coprocNode() call to getPsegId() success cluster_index++; return; } status = xmlTextReaderRead(reader); } } // end clusterNode() ////////////////////////////////////////////// void clusterSetNode( xmlTextReaderPtr reader ) { if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; #if XML_PARSER_DEBUG printf("\n clusters set\n"); #endif int status = xmlTextReaderRead(reader); while ( status == 1 ) { const char* tag = (const char*)xmlTextReaderConstName(reader); if ( strcmp(tag,"cluster") == 0 ) clusterNode(reader); else if ( strcmp(tag,"#text") == 0 ) { } else if ( strcmp(tag,"clusterset") == 0 ) { // checking source file consistency if ( cluster_index != header->clusters ) { printf("[XML ERROR] Wrong number of clusters\n"); exit(1); } else { #if XML_PARSER_DEBUG printf(" end cluster set\n\n"); #endif header->psegs = pseg_index; header->procs = proc_index; header->irqs = irq_index; header->coprocs = coproc_index; header->cp_ports = cp_port_index; header->cp_regs = cp_reg_index; return; } } else { printf("[XML ERROR] Unknown tag in clusterset node : %s",tag); exit(1); } status = xmlTextReaderRead(reader); } } // end clusterSetNode() ///////////////////////////////////////////// void globalSetNode( xmlTextReaderPtr reader ) { if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; #if XML_PARSER_DEBUG printf(" globals set\n"); #endif int status = xmlTextReaderRead(reader); while ( status == 1 ) { const char* tag = (const char*)xmlTextReaderConstName(reader); if ( strcmp(tag,"vseg") == 0 ) vsegNode(reader); else if ( strcmp(tag,"#text" ) == 0 ) { } else if ( strcmp(tag,"globalset") == 0 ) { // checking source file consistency if ( vseg_index != header->globals ) { printf("[XML ERROR] Wrong number of global vsegs\n"); exit(1); } else { #if XML_PARSER_DEBUG printf(" end global set\n\n"); #endif vseg_loc_index = 0; return; } } else { printf("[XML ERROR] Unknown tag in globalset node : %s",tag); exit(1); } status = xmlTextReaderRead ( reader ); } } // end globalSetNode() ///////////////////////////////////////////// void vspaceSetNode( xmlTextReaderPtr reader ) { if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; #if XML_PARSER_DEBUG printf("\n vspaces set\n"); #endif int status = xmlTextReaderRead ( reader ); while ( status == 1 ) { const char* tag = (const char*)xmlTextReaderConstName(reader); if ( strcmp(tag,"vspace") == 0 ) vspaceNode(reader); else if ( strcmp(tag,"#text" ) == 0 ) { } else if ( strcmp(tag,"vspaceset") == 0 ) { // checking source file consistency if ( vspace_index != header->vspaces ) { printf("[XML ERROR] Wrong number of vspaces\n"); exit(1); } else { header->vsegs = vseg_index; header->vobjs = vobj_index; header->tasks = task_index; return; } } else { printf("[XML ERROR] Unknown tag in vspaceset node : %s",tag); exit(1); } status = xmlTextReaderRead ( reader ); } } // end globalSetNode() ////////////////////////////////////////// void headerNode(xmlTextReaderPtr reader ) { char* name; unsigned int value; unsigned int ok; if ( xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT ) return; #if XML_PARSER_DEBUG printf("mapping_info\n"); #endif header = (mapping_header_t*)malloc(sizeof(mapping_header_t)); ////////// get name attribute name = getStringValue(reader, "name", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" name = %s\n", name); #endif strncpy( header->name, name, 31); } else { printf("[XML ERROR] illegal or missing attribute in header\n"); exit(1); } /////////// get clusters attribute value = getIntValue(reader, "clusters", &ok); if ( ok ) { if ( value >= MAX_CLUSTERS ) { printf("[XML ERROR] The number of clusters is larger than %d\n", MAX_CLUSTERS); exit(1); } #if XML_PARSER_DEBUG printf(" clusters = %d\n", value); #endif header->clusters = value; } else { printf("[XML ERROR] illegal or missing attribute in header\n"); exit(1); } ///////// get ttys attribute value = getIntValue(reader, "ttys", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" ttys = %d\n", value); #endif header->ttys = value; } else { printf("[XML ERROR] illegal or missing attribute in header\n"); exit(1); } ///////// get fbs attribute value = getIntValue(reader, "fbs", &ok); if ( ok ) { #if XML_PARSER_DEBUG printf(" fbs = %d\n", value); #endif header->fbs = value; } else { printf("[XML ERROR] illegal or missing attribute in header\n"); exit(1); } ///////// get vspaces attribute value = getIntValue(reader, "vspaces", &ok); if ( ok ) { if ( value >= MAX_VSPACES ) { printf("[XML ERROR] The number of vspaces is larger than %d\n", MAX_VSPACES); exit(1); } #if XML_PARSER_DEBUG printf(" vspaces = %d\n", value); #endif header->vspaces = value; } else { printf("[XML ERROR] illegal or missing attribute in mapping\n"); exit(1); } ////////// get globals attribute value = getIntValue(reader, "globals", &ok); if ( ok ) { if ( value >= MAX_VSEGS ) { printf("[XML ERROR] The number of globals is larger than %d\n", MAX_VSEGS); exit(1); } #if XML_PARSER_DEBUG printf(" globals = %d\n", value); #endif header->globals = value; } else { printf("[XML ERROR] illegal or missing attribute in mapping_info_header\n"); exit(1); } header->signature = IN_MAPPING_SIGNATURE; int status = xmlTextReaderRead(reader); while ( status == 1 ) { const char* tag = (const char*)xmlTextReaderConstName(reader); if ( strcmp(tag,"clusterset") == 0 ) clusterSetNode(reader); else if ( strcmp(tag,"globalset") == 0 ) globalSetNode(reader); else if ( strcmp(tag,"vspaceset") == 0 ) vspaceSetNode(reader); else if ( strcmp(tag,"#text") == 0 ) { } else if ( strcmp(tag,"mapping_info") == 0 ) { #if XML_PARSER_DEBUG printf("end mapping_info\n"); #endif return; } else { printf("[XML ERROR] Unknown tag in header node : %s\n",tag); exit(1); } status = xmlTextReaderRead(reader); } } // end headerNode() void BuildTable( int fdout, const char* type, unsigned int nb_elem, unsigned int elem_size, char** table) { unsigned int i; unsigned int length; // write element for ( i = 0 ; i < nb_elem ; i++ ) { length = write(fdout, table[i], elem_size); #if XML_PARSER_DEBUG printf("Building binary: writing %s %d\n", type, i); #endif if ( length != elem_size ) { printf("type: %s\n", type); perror("error writing"); exit(1); } } } /////////////////////////// void buildBin( int fdout ) { unsigned int vspace_id; unsigned int vobj_id; unsigned int length; // write header to binary file length = write(fdout, (char*)header, sizeof(mapping_header_t)); #if XML_PARSER_DEBUG printf("\n*** write header\n"); #endif if ( length != sizeof(mapping_header_t) ) { printf("write header error : length = %d \n", length); exit(1); } // write clusters BuildTable(fdout, "cluster", cluster_index, sizeof(mapping_cluster_t), (char**) cluster); // write psegs BuildTable(fdout, "pseg", pseg_index, sizeof(mapping_pseg_t), (char**) pseg); // write vspaces for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ ) { length = write(fdout, (char*)vspace[vspace_id], sizeof(mapping_vspace_t)); #if XML_PARSER_DEBUG printf("write vspace %d\n", vspace_id); printf("vspace->vobj_offset: %d\n", vspace[vspace_id]->vobj_offset); printf("vspace->vobjs: %d\n", vspace[vspace_id]->vobjs); printf("header->vobjs: %d\n", header->vobjs); #endif if ( length != sizeof(mapping_vspace_t) ) { perror("write vspace"); exit(1); } } // write vsegs BuildTable(fdout, "vseg", vseg_index, sizeof(mapping_vseg_t), (char**) vseg); // write vobjs for ( vobj_id = 0 ; vobj_id < header->vobjs ; vobj_id++ ) { length = write(fdout, (char*)vobj[vobj_id], sizeof(mapping_vobj_t)); #if XML_PARSER_DEBUG printf("write vobj %d\n", vobj_id); printf("write vobj name %s\n", vobj[vobj_id]->name); printf("write vobj length %x\n", vobj[vobj_id]->length); printf("write vobj type %d\n", vobj[vobj_id]->type); #endif if ( length != sizeof(mapping_vobj_t) ) { perror("write vobj"); exit(1); } } // write tasks BuildTable(fdout, "task", task_index, sizeof(mapping_task_t), (char**) task); //building proc BuildTable(fdout, "proc", proc_index, sizeof(mapping_proc_t), (char**) proc); //building irq BuildTable(fdout, "irq", irq_index, sizeof(mapping_irq_t), (char**)irq); //building coproc BuildTable(fdout, "coproc", coproc_index, sizeof(mapping_coproc_t), (char**)coproc); //building cp_port BuildTable(fdout, "cp_port", cp_port_index, sizeof(mapping_coproc_port_t),(char**) cp_port); //building cp_reg BuildTable(fdout, "cp_reg", cp_reg_index, sizeof(mapping_coproc_reg_t), (char**)cp_reg); } // end buildBin() ///////////////////////////////////////// // this function set the value of vobj_id // of the coproc_ports. /////////////////// void prepareBuild() { unsigned int i; for(i=0; i< cp_port_index; i++) { int vspace_id = getVspaceId( cp_port_vobj_ref[i]->vspace_name ); if ( vspace_id < 0 ) { printf("[XML ERROR] illegal for coproc_port %d,\n", i); exit(1); } cp_port[i]->vspaceid = vspace_id; int vobj_id = getVobjLocId( vspace_id, cp_port_vobj_ref[i]->vobj_name, vspace[vspace_id]->vobjs ); if ( vobj_id >= 0 ) { #if XML_PARSER_DEBUG printf("coproc_port = %d\n", i); printf(" vspace_name = %s\n", cp_port_vobj_ref[i]->vspace_name); printf(" vobj_name = %s\n", cp_port_vobj_ref[i]->vobj_name); printf(" vobj_index = %d\n", vobj_id); #endif cp_port[i]->vobjlocid = vobj_id; assert((vobj[ vspace[vspace_id]->vobj_offset + vobj_id]->type == VOBJ_TYPE_MWMR) && "coproc ports has to refere to a vobj of type MWMR"); } else { printf("[XML ERROR] illegal for coproc_port %d,\n", i); exit(1); } } } ///////////////////////////////////// int main ( int argc, char* argv[] ) { if ( argc < 3 ) { printf("Usage: xml2bin \n"); return 1; } int fdout = open( argv[2], (O_CREAT | O_RDWR), S_IRWXU ); if ( fdout < 0) { perror("open"); exit(1); } LIBXML_TEST_VERSION; int status; xmlTextReaderPtr reader = xmlReaderForFile ( argv[1], NULL, 0 ); if ( reader != NULL ) { status = xmlTextReaderRead ( reader ); while ( status == 1 ) { const char* tag = (const char*)xmlTextReaderConstName(reader); if ( strcmp(tag,"mapping_info") == 0 ) { headerNode( reader ); prepareBuild(); buildBin( fdout ); } else { printf("[XML ERROR] Wrong file type: \"%s\"\n", argv[1]); return 1; } status = xmlTextReaderRead ( reader ); } xmlFreeTextReader ( reader ); if ( status != 0 ) { printf("[XML ERROR] Wrong Syntax in \"%s\" file\n", argv[1]); return 1; } } return 0; } // end main()