Пример #1
0
void litehtml::el_td::parse_styles(bool is_reparse)
{
	const wchar_t* str = get_attr(L"width");
	if(str)
	{
		m_style.add_property(L"width", str, 0);
	}
	str = get_attr(L"background");
	if(str)
	{
		std::wstring url = L"url('";
		url += str;
		url += L"')";
		m_style.add_property(L"background-image", url.c_str(), 0);
	}
	str = get_attr(L"align");
	if(str)
	{
		m_style.add_property(L"text-align", str, 0);
	}

	str = get_attr(L"valign");
	if(str)
	{
		m_style.add_property(L"vertical-align", str, 0);
	}

	element::parse_styles(is_reparse);
}
Пример #2
0
void litehtml::el_td::parse_attributes()
{
	const tchar_t* str = get_attr(_t("width"));
	if(str)
	{
		m_style.add_property(_t("width"), str, 0, false);
	}
	str = get_attr(_t("background"));
	if(str)
	{
		tstring url = _t("url('");
		url += str;
		url += _t("')");
		m_style.add_property(_t("background-image"), url.c_str(), 0, false);
	}
	str = get_attr(_t("align"));
	if(str)
	{
		m_style.add_property(_t("text-align"), str, 0, false);
	}

	str = get_attr(_t("bgcolor"));
	if (str)
	{
		m_style.add_property(_t("background-color"), str, 0, false);
	}

	str = get_attr(_t("valign"));
	if(str)
	{
		m_style.add_property(_t("vertical-align"), str, 0, false);
	}
	html_tag::parse_attributes();
}
Пример #3
0
void litehtml::el_link::parse_attributes()
{
	bool processed = false;

	const tchar_t* rel = get_attr(_t("rel"));
	if(rel && !t_strcmp(rel, _t("stylesheet")))
	{
		const tchar_t* media	= get_attr(_t("media"));
		const tchar_t* href		= get_attr(_t("href"));
		if(href && href[0])
		{
			tstring css_text;
			tstring css_baseurl;
			m_doc->container()->import_css(css_text, href, css_baseurl);
			if(!css_text.empty())
			{
				m_doc->add_stylesheet(css_text.c_str(), css_baseurl.c_str(), media);
				processed = true;
			}
		}
	}

	if(!processed)
	{
		m_doc->container()->link(m_doc, this);
	}
}
Пример #4
0
static gboolean set_c_ll ( const char **attr )
{
  if ( (c_slat = get_attr ( attr, "lat" )) && (c_slon = get_attr ( attr, "lon" )) ) {
    c_ll.lat = g_ascii_strtod(c_slat, NULL);
    c_ll.lon = g_ascii_strtod(c_slon, NULL);
    return TRUE;
  }
  return FALSE;
}
Пример #5
0
/*-----------------------------------------------------------------------------------------------------------------------*/
static int32_t load_transport_protocol(FIXProtocolDescr* prot, xmlNode* parentRoot, char const* parentFile, FIXError** error)
{
   int32_t res = FIX_SUCCESS;
   xmlDoc* doc = NULL;
   char const* transpFile = get_attr(parentRoot, "transport", parentFile);
   if(!strcmp(transpFile, parentFile)) // transport is the same as protocol
   {
      prot->transportVersion = _strdup(prot->version);
      goto ok;
   }
   char path[PATH_MAX] = {};
   if (FIX_FAILED == fix_utils_make_path(parentFile, transpFile, path, PATH_MAX))
   {
      goto err;
   }
   doc = xmlParseFile(path);
   if (!doc)
   {
      *error = fix_error_create(FIX_ERROR_PROTOCOL_XML_LOAD_FAILED, xmlGetLastError()->message);
      goto err;
   }
   if (xml_validate(doc, error) == FIX_FAILED)
   {
      goto err;
   }
   xmlNode* root = xmlDocGetRootElement(doc);
   prot->transportVersion = _strdup(get_attr(root, "version", NULL));
   if (!strcmp(prot->version, prot->transportVersion)) // versions are the same, no need to process transport protocol
   {
      goto ok;
   }
   if (!root)
   {
      *error = fix_error_create(FIX_ERROR_PROTOCOL_XML_LOAD_FAILED, xmlGetLastError()->message);
      goto err;
   }
   if (load_field_types(&prot->transport_field_types, root, error) == FIX_FAILED)
   {
      goto err;
   }
   if (load_messages(prot, &prot->transport_field_types, root, error) == FIX_FAILED)
   {
      goto err;
   }
   goto ok;
err:
   res = FIX_FAILED;
ok:
   if (doc)
   {
      xmlFreeDoc(doc);
   }
   return res;
}
Пример #6
0
static void parse_obj_node_param(ContentItem *item, ContentItem *hhc_root, const char *text, UINT code_page)
{
    const char *ptr;
    LPWSTR *param, merge;
    int len;

    ptr = get_attr(text, "name", &len);
    if(!ptr) {
        WARN("name attr not found\n");
        return;
    }

    if(!strncasecmp("name", ptr, len)) {
        param = &item->name;
    }else if(!strncasecmp("merge", ptr, len)) {
        param = &merge;
    }else if(!strncasecmp("local", ptr, len)) {
        param = &item->local;
    }else {
        WARN("unhandled param %s\n", debugstr_an(ptr, len));
        return;
    }

    ptr = get_attr(text, "value", &len);
    if(!ptr) {
        WARN("value attr not found\n");
        return;
    }

    /*
     * "merge" parameter data (referencing another CHM file) can be incorporated into the "local" parameter
     * by specifying the filename in the format:
     *  MS-ITS:file.chm::/local_path.htm
     */
    if(param == &item->local && strstr(ptr, "::"))
    {
        const char *local = strstr(ptr, "::")+2;
        int local_len = len-(local-ptr);

        item->local = decode_html(local, local_len, code_page);
        param = &merge;
    }

    *param = decode_html(ptr, len, code_page);

    if(param == &merge) {
        SetChmPath(&item->merge, hhc_root->merge.chm_file, merge);
        heap_free(merge);
    }
}
Пример #7
0
void litehtml::el_image::parse_attributes()
{
	m_src = get_attr(_t("src"), _t(""));

	const tchar_t* attr_height = get_attr(_t("height"));
	if(attr_height)
	{
		m_style.add_property(_t("height"), attr_height, 0, false);
	}
	const tchar_t* attr_width = get_attr(_t("width"));
	if(attr_width)
	{
		m_style.add_property(_t("width"), attr_width, 0, false);
	}
}
Пример #8
0
void litehtml::el_table::parse_attributes()
{
	const tchar_t* str = get_attr(_t("width"));
	if(str)
	{
		m_style.add_property(_t("width"), str, 0, false);
	}

	str = get_attr(_t("align"));
	if(str)
	{
		int align = value_index(str, _t("left;center;right"));
		switch(align)
		{
		case 1:
			m_style.add_property(_t("margin-left"), _t("auto"), 0, false);
			m_style.add_property(_t("margin-right"), _t("auto"), 0, false);
			break;
		case 2:
			m_style.add_property(_t("margin-left"), _t("auto"), 0, false);
			m_style.add_property(_t("margin-right"), _t("0"), 0, false);
			break;
		}
	}

	str = get_attr(_t("cellspacing"));
	if(str)
	{
		tstring val = str;
		val += _t(" ");
		val += str;
		m_style.add_property(_t("border-spacing"), val.c_str(), 0, false);
	}
	
	str = get_attr(_t("border"));
	if(str)
	{
		m_style.add_property(_t("border-width"), str, 0, false);
	}

	str = get_attr(_t("bgcolor"));
	if (str)
	{
		m_style.add_property(_t("background-color"), str, 0, false);
	}

	html_tag::parse_attributes();
}
Пример #9
0
bool DieHolder::get_operand(int const attr, ea_t const rel_addr, Dwarf_Small const atom,
                            Dwarf_Unsigned *operand, bool only_locblock)
{
  Dwarf_Attribute attrib = get_attr(attr);
  Dwarf_Locdesc **llbuf = NULL;
  Dwarf_Locdesc *locdesc = NULL;
  Dwarf_Signed count = 0;
  Dwarf_Error err = NULL;
  DwarfDealloc dealloc(m_dbg);
  bool found = false;
  bool ret = false;

  CHECK_DWERR2(attrib == NULL, NULL,
               "retrieving an operand implies finding the attribute...");

  CHECK_DWERR(dwarf_loclist_n(attrib, &llbuf, &count, &err), err,
              "cannot get location descriptions");

  dealloc.add(llbuf, DW_DLA_LIST);
  for(Dwarf_Signed idx = 0; idx < count; ++idx)
  {
    locdesc = llbuf[idx];
    // handle deallocation too
    dealloc.add(llbuf[idx], DW_DLA_LOCDESC);
    dealloc.add(llbuf[idx]->ld_s, DW_DLA_LOC_BLOCK);

    if(!found)
    {
      // from a location block?
      if(!locdesc->ld_from_loclist)
      {
        // no need to check the address
        found = true;
      }
      // this loc desc is from a location list
      else if(!only_locblock &&
              (locdesc->ld_lopc <= rel_addr &&
               locdesc->ld_hipc > rel_addr))
      {
        found = true;
      }
    }
  }

  if(found)
  {
    CHECK_DWERR2(locdesc->ld_cents != 1, NULL,
                 "only 1 location in a location description is supported");

    Dwarf_Loc *loc = &locdesc->ld_s[0];

    if(loc->lr_atom == atom)
    {
      *operand = loc->lr_number;
      ret = true;
    }
  }

  return ret;
}
Пример #10
0
char __xmlcontext::get_char(const char *name, char def) const
{
	const char *val = get_attr(name);
	if (val == NULL)
		return def;
	return *val;
}
Пример #11
0
PUBLIC
L4_msg_tag
Vlog::kinvoke(L4_obj_ref ref, Mword rights, Syscall_frame *f,
              Utcb const *r_msg, Utcb *s_msg)
{
  L4_msg_tag const t = f->tag();

  if (t.proto() == L4_msg_tag::Label_irq)
    return Icu_h<Vlog>::icu_invoke(ref, rights, f, r_msg, s_msg);
  else if (t.proto() != L4_msg_tag::Label_log)
    return commit_result(-L4_err::EBadproto);

  switch (r_msg->values[0])
    {
    case 0:
      log_string(f, r_msg);
      return no_reply();

    case 2: // set attr
      return set_attr(rights, f, r_msg);

    case 3: // get attr
      return get_attr(rights, f, s_msg);

    default:
      return get_input(rights, f, s_msg);
    }
}
Пример #12
0
t_scene	*get_scene(int fd, char *buffer)
{
  t_scene	*scene;
  int	error;

  if ((error = check_balise(buffer, "scene")) < 0)
    return (NULL);
  scene = malloc(sizeof(*scene));
  scene->attr = get_attr(buffer, scene);
  buffer = get_cam(fd, &(scene->cam), scene);
  if (scene->cam == NULL)
    return (NULL);
  if ((error = check_balise(buffer, "object")) == ERROR_NO_DEF_NAME
      && check_balise(buffer, "light") == ERROR_NO_DEF_NAME)
    return (NULL);
  buffer = get_object(fd, &(scene->obj), scene);
  if (scene->obj == NULL)
    return (NULL);
  buffer = get_next_line(fd);
  if ((error = check_balise(buffer, "light")) == ERROR_NO_DEF_NAME)
    return (NULL);
  buffer = get_light(fd, &(scene->light), scene);
  if (scene->light == NULL)
    return (NULL);
  return (scene);
}
Пример #13
0
std::string __xmlcontext::get_string(const char *name, const char *def) const
{
	const char *val = get_attr(name);
	if (val == NULL)
		return def == NULL ? std::string() : std::string(def);
	return std::string(val);
}
Пример #14
0
void litehtml::el_para::parse_styles(bool is_reparse /*= false*/) {
     const wchar_t* str = get_attr(L"align");
     if (str) {
	  m_style.add_property(L"text-align", str, 0);
     }

     element::parse_styles(is_reparse);
}
Пример #15
0
double __xmlcontext::get_double(const char *name, double def) const
{
	const char *val = get_attr(name);
	if (val == NULL)
		return def;
	double d = strtod(val, NULL);
	return d;
}
Пример #16
0
long long __xmlcontext::get_llong(const char *name, long long def) const
{
	const char *val = get_attr(name);
	if (val == NULL)
		return def;
	long long d = strtoll(val, NULL, 0);
	return d;
}
Пример #17
0
int __xmlcontext::get_int(const char *name, int def) const
{
	const char *val = get_attr(name);
	if (val == NULL)
		return def;
	long d = strtol(val, NULL, 0);
	return d;
}
Пример #18
0
		bool copy(const wchar_t* path, const wchar_t* dest) noexcept
		{
			auto attr = get_attr(path);

			if (fsys::is_valid(attr) && fsys::is_link(attr))
				return fsys::is_dir(attr) ? pvt::copy_dir_link(path, dest) : pvt::copy_file_link(path, dest);
			return false;
		}
Пример #19
0
int main(int argc, char **argv)
{
	int input=-1;

	printf("\n===============WELCOME TO THE TEST INTERFACE TO VERIFY THE IPC================\n");
	//list_receiver(1);

	while(1)
	{
		printf("\n			-----Available Operations---	\n");
		printf("\n 1. MESSAGE QUEUE Creation \n");	//this calls to the mq_open
		printf(" 2. Register Sender in the queue \n");   //this calls the  msender system call
		printf(" 3. Register Receiver in the queue \n"); //this call the mreceiver system call
		printf(" 4. Send a message using the system call mq_send \n");  // This calls the mq_send system call
		printf(" 5. Clear and Close Message Queue\n"); //This calls the mq_close system call
		printf(" 6. Get Attributes of the message queue  \n");
		printf(" 7. Set Attributes of the message queue  \n");//this calls to the mq_getattr system call
		printf(" 8. Notify system call \n");
        printf(" 0. Exit the Program \n");
		printf("Choose the operation you want to perform \t ");
		scanf(" %d",&input);
        switch(input)
        {
        	case 1:
        			list_queue();
        			break;
        	case 2:
        			list_sender();
        			break;
        	case 3:
        			list_receiver(0);
		            break;
		    case 4:
		    		mess_send();	//sender can be created dynamically also.
		            break;
		    case 5:
		    		message_clean();
		    		break;
		    case 6:

		    		get_attr();

		    		break;
		    case 7:
		    		set_attr();
		    		break;
		    case 8 :
		    		reqnotify();
		    		break;
		    case 0:
		            exit(0);
		            break;
		    default :
		            printf("\nIncorrect input. Try again. \n");
		            break;
	    }
	}
}
Пример #20
0
static void _startElement(void *ctx, const xmlChar *name, const xmlChar **attrs)
{
  dprintf("START ELEMENT name='%s'\n", name);

  if ( strcmp((char *) name, "document") == 0 ) {
    CTX(ctx)->state = OCR_STATE_READ;
    CTX(ctx)->addr = strtoul(get_attr((xmlChar **) attrs, "id"), NULL, 16);
    CTX(ctx)->box = frame_geometry_null;
    CTX(ctx)->text.len = 0;
  }
  else if ( CTX(ctx)->state == OCR_STATE_READ ) {
    char *geometry = get_attr((xmlChar **) attrs, "geometry");
    frame_geometry_t g = frame_geometry_null;

    /* Get element geometry attribute (if any) */
    if ( (geometry != NULL) && (*geometry != '\0') ) {
      frame_geometry_parse(geometry, &g);
      dprintf("     geometry=\"%s\"=%ux%u+%d+%d\n", geometry, g.width, g.height, g.x, g.y);
    }

    if ( strcmp((char *) name, "line") == 0 ) {
      CTX(ctx)->box = g;
      CTX(ctx)->text.len = 0;
    }
    else {
      /* Ignore delirious line boundaries */
      if ( (CTX(ctx)->box.width > 0) && (CTX(ctx)->box.height > 0) ) {
	if ( strcmp((char *) name, "box") == 0 ) {
	  char *value = get_attr((xmlChar **) attrs, "value");
	  if ( strlen(value) == 1 ) {
	    /* Ignore leading unknown characters */
	    if ( (CTX(ctx)->text.len > 0) || (*value != '_' ) )
	      ocr_text_append(CTX(ctx), *value, &g);
	  }
	}
	else if ( strcmp((char *) name, "space") == 0 ) {
	  /* Ignore leading space characters */
	  if ( CTX(ctx)->text.len > 0 ) {
	    ocr_text_append(CTX(ctx), ' ', &g);
	  }
	}
      }
    }
  }
}
Пример #21
0
/*
 * def m(self): return self.f + 1
 */
pyobj D_m(pyobj self) {
  pyobj f = get_attr(self, "f");
  int i = project_int(f);
#ifdef TAGGING
  return inject_int(i+1);
#else
  return create_int(i+1);
#endif
}
Пример #22
0
void litehtml::el_div::parse_attributes()
{
	const tchar_t* str = get_attr(_t("align"));
	if(str)
	{
		m_style.add_property(_t("text-align"), str, 0, false);
	}
	html_tag::parse_attributes();
}
Пример #23
0
/*-----------------------------------------------------------------------------------------------------------------------*/
static FIXMsgDescr* load_message(xmlNode const* msg_node, xmlNode const* root,
      FIXFieldType* (*ftypes)[FIELD_TYPE_CNT], FIXError** error)
{
   FIXMsgDescr* msg = (FIXMsgDescr*)calloc(1, sizeof(FIXMsgDescr));
   msg->name = _strdup(get_attr(msg_node, "name", NULL));
   msg->type = _strdup(get_attr(msg_node, "type", NULL));
   msg->field_count = count_msg_fields(msg_node, get_first(root, "components"));
   msg->fields = (FIXFieldDescr*)calloc(msg->field_count, sizeof(FIXFieldDescr));
   uint32_t count = 0;
   if (FIX_FAILED == load_fields(msg->fields, &count, msg_node, get_first(root, "components"), ftypes, error))
   {
      return NULL;
   }
   assert(count == msg->field_count);
   msg->field_index = (FIXFieldDescr**)calloc(FIELD_DESCR_CNT, sizeof(FIXFieldDescr*));
   build_index(msg->fields, msg->field_count, msg->field_index);
   return msg;
}
Пример #24
0
static void
xmpp_failure_text(proto_tree *tree, tvbuff_t *tvb, element_t *element)
{
    attr_t *lang = get_attr(element,"xml:lang");
    
    proto_tree_add_text(tree, tvb, element->offset, element->length, "TEXT%s: %s",
            lang?ep_strdup_printf("(%s)",lang->value):"",
            element->data?element->data->value:"");
}
Пример #25
0
/* Parse the attributes correspond to a list item, including sub-topics.
 *
 * Each list item has, at minimum, a param of type "keyword" and two
 * parameters corresponding to a "sub-topic."  For each sub-topic there
 * must be a "name" param and a "local" param, if there is only one
 * sub-topic then there isn't really a sub-topic, the index will jump
 * directly to the requested item.
 */
static void parse_index_obj_node_param(IndexItem *item, const char *text, UINT code_page)
{
    const char *ptr;
    LPWSTR *param;
    int len;

    ptr = get_attr(text, "name", &len);
    if(!ptr) {
        WARN("name attr not found\n");
        return;
    }

    /* Allocate a new sub-item, either on the first run or whenever a
     * sub-topic has filled out both the "name" and "local" params.
     */
    if(item->itemFlags == 0x11 && (!strncasecmp("name", ptr, len) || !strncasecmp("local", ptr, len)))
        item_realloc(item, item->nItems+1);
    if(!strncasecmp("keyword", ptr, len)) {
        param = &item->keyword;
    }else if(!item->keyword && !strncasecmp("name", ptr, len)) {
        /* Some HTML Help index files use an additional "name" parameter
         * rather than the "keyword" parameter.  In this case, the first
         * occurrence of the "name" parameter is the keyword.
         */
        param = &item->keyword;
    }else if(!strncasecmp("name", ptr, len)) {
        item->itemFlags |= 0x01;
        param = &item->items[item->nItems-1].name;
    }else if(!strncasecmp("local", ptr, len)) {
        item->itemFlags |= 0x10;
        param = &item->items[item->nItems-1].local;
    }else {
        WARN("unhandled param %s\n", debugstr_an(ptr, len));
        return;
    }

    ptr = get_attr(text, "value", &len);
    if(!ptr) {
        WARN("value attr not found\n");
        return;
    }

    *param = decode_html(ptr, len, code_page);
}
Пример #26
0
void DieHolder::get_frame_base_offsets(OffsetAreas &offset_areas)
{
  Dwarf_Attribute attrib = get_attr(DW_AT_frame_base);
  Dwarf_Locdesc **llbuf = NULL;
  Dwarf_Locdesc *locdesc = NULL;
  Dwarf_Signed count = 0;
  Dwarf_Error err = NULL;
  DwarfDealloc dealloc(m_dbg);

  CHECK_DWERR2(attrib == NULL, NULL,
               "retrieving an operand implies finding the attribute...");

  CHECK_DWERR(dwarf_loclist_n(attrib, &llbuf, &count, &err), err,
              "cannot get location descriptions");

  dealloc.add(llbuf, DW_DLA_LIST);
  for(Dwarf_Signed idx = 0; idx < count; ++idx)
  {
    ea_t low_pc = 0;
    ea_t high_pc = 0;

    locdesc = llbuf[idx];
    // handle deallocation too
    dealloc.add(llbuf[idx], DW_DLA_LOCDESC);
    dealloc.add(llbuf[idx]->ld_s, DW_DLA_LOC_BLOCK);

    // only 1 location in a location description is supported
    if(locdesc->ld_cents == 1)
    {
      Dwarf_Loc *loc = &locdesc->ld_s[0];
      Dwarf_Small const atom = loc->lr_atom;

      // from a location block?
      if(!locdesc->ld_from_loclist)
      {
        low_pc = BADADDR;
        high_pc = BADADDR;
      }
      // this loc desc is from a location list
      else
      {
        low_pc = static_cast<ea_t>(locdesc->ld_lopc);
        high_pc = static_cast<ea_t>(locdesc->ld_hipc);
      }

      // is it the right atom to get the offset from?
      if(atom == DW_OP_breg4 || atom == DW_OP_breg5)
      {
        offset_areas.push_back(OffsetArea(low_pc, high_pc,
                                          // operand is unsigned, but should be signed...
                                          static_cast<sval_t>(loc->lr_number),
                                          (atom == DW_OP_breg5)));
      }
    }
  }
}
Пример #27
0
void litehtml::el_break::parse_attributes()
{
	const tchar_t* attr_clear = get_attr(_t("clear"));
	if(attr_clear)
	{
		m_style.add_property(_t("clear"), attr_clear, 0, false);
	}

	html_tag::parse_attributes();
}
Пример #28
0
void litehtml::el_tr::parse_attributes()
{
	const tchar_t* str = get_attr(_t("align"));
	if(str)
	{
		m_style.add_property(_t("text-align"), str, 0, false);
	}
	str = get_attr(_t("valign"));
	if(str)
	{
		m_style.add_property(_t("vertical-align"), str, 0, false);
	}
	str = get_attr(_t("bgcolor"));
	if (str)
	{
		m_style.add_property(_t("background-color"), str, 0, false);
	}
	html_tag::parse_attributes();
}
Пример #29
0
bool __xmlcontext::get_bool(const char *name, bool def) const
{
	const char *val = get_attr(name);
	if (val == NULL)
		return def;
	if (isdigit(*val))
		return strtol(val, NULL, 0) != 0;
	if (*val == 't' || *val == 'T' || *val == 'y' || *val == 'Y')
		return true;
	return false;
}
Пример #30
0
/*-----------------------------------------------------------------------------------------------------------------------*/
static FIXErrCode load_field_types(FIXFieldType* (*ftypes)[FIELD_TYPE_CNT], xmlNode const* root, FIXError** error)
{
   xmlNode const* field = get_first(get_first(root, "fields"), "field");
   while(field)
   {
      if (field->type == XML_ELEMENT_NODE && !strcmp((char const*)field->name, "field"))
      {
         if (fix_protocol_get_field_type(ftypes, get_attr(field, "name", NULL)))
         {
            *error = fix_error_create(FIX_ERROR_FIELD_TYPE_EXISTS, "FIXFieldType '%s' already exists", (char const*)field->name);
            return FIX_FAILED;
         }
         FIXFieldType* fld = (FIXFieldType*)calloc(1, sizeof(FIXFieldType));
         fld->tag = atoi(get_attr(field, "number", NULL));
         fld->name = _strdup(get_attr(field, "name", NULL));
         fld->valueType = str2FIXFieldValueType(get_attr(field, "type", NULL));
         xmlNode const* value = get_first(field, "value");
         if (value)
         {
            fld->values = (FIXFieldValue**)calloc(FIELD_VALUE_CNT, sizeof(FIXFieldValue*));
            while(value)
            {
               if (value->type == XML_ELEMENT_NODE && !strcmp((char const*)value->name, "value"))
               {
                  FIXFieldValue* val = (FIXFieldValue*)calloc(1, sizeof(FIXFieldValue));
                  val->value = strdup(get_attr(value, "enum", NULL));
                  uint32_t idx = fix_utils_hash_string(val->value, strlen(val->value)) % FIELD_VALUE_CNT;
                  val->next = fld->values[idx];
                  fld->values[idx] = val;
               }
               value = value->next;
            }
         }
         uint32_t idx = fix_utils_hash_string(fld->name, strlen(fld->name)) % FIELD_TYPE_CNT;
         fld->next = (*ftypes)[idx];
         (*ftypes)[idx] = fld;
      }
      field = field->next;
   }
   return FIX_SUCCESS;
}