static void wordnet2result(const gchar *Word, gchar *WordData, std::string &type, std::list<std::string> &wordlist, std::string &gloss) { guint32 data_size = *reinterpret_cast<guint32 *>(WordData); type.clear(); wordlist.clear(); gloss.clear(); WnUserData Data(Word, type, wordlist, gloss); GMarkupParser parser; parser.start_element = NULL; parser.end_element = NULL; parser.text = func_parse_text; parser.passthrough = NULL; parser.error = NULL; GMarkupParseContext* context = g_markup_parse_context_new(&parser, (GMarkupParseFlags)0, &Data, NULL); g_markup_parse_context_parse(context, WordData + sizeof(guint32) + sizeof(char), data_size - 2, NULL); g_markup_parse_context_end_parse(context, NULL); g_markup_parse_context_free(context); }
static void pull_vcard_listing_callback(struct obc_session *session, GError *err, void *user_data) { struct obc_transfer *transfer = obc_session_get_transfer(session); struct pbap_data *pbap = user_data; GMarkupParseContext *ctxt; DBusMessage *reply; DBusMessageIter iter, array; const char *buf; int size; if (pbap->msg == NULL) goto complete; if (err) { reply = g_dbus_create_error(pbap->msg, "org.openobex.Error.Failed", "%s", err->message); goto send; } reply = dbus_message_new_method_return(pbap->msg); buf = obc_transfer_get_buffer(transfer, &size); if (size == 0) buf = ""; dbus_message_iter_init_append(reply, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_STRUCT_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_STRUCT_END_CHAR_AS_STRING, &array); ctxt = g_markup_parse_context_new(&listing_parser, 0, &array, NULL); g_markup_parse_context_parse(ctxt, buf, strlen(buf) - 1, NULL); g_markup_parse_context_free(ctxt); dbus_message_iter_close_container(&iter, &array); obc_transfer_clear_buffer(transfer); send: g_dbus_send_message(conn, reply); dbus_message_unref(pbap->msg); pbap->msg = NULL; complete: obc_transfer_unregister(transfer); }
static void parser_callback(const char *str, gpointer user_data) { struct wispr_session *wispr = user_data; GMarkupParseContext *context; gboolean result; //printf("%s\n", str); context = g_markup_parse_context_new(&wispr_parser, G_MARKUP_TREAT_CDATA_AS_TEXT, &wispr->msg, NULL); result = g_markup_parse_context_parse(context, str, strlen(str), NULL); if (result == TRUE) result = g_markup_parse_context_end_parse(context, NULL); g_markup_parse_context_free(context); }
void DictConfigXmlToInfo(const char *configxml, DictManageInfo &info) { info.groups.clear(); config_ParseUserData Data; Data.info = &info; Data.in_querydict = false; Data.in_scandict = false; GMarkupParser parser; parser.start_element = config_parse_start_element; parser.end_element = config_parse_end_element; parser.text = NULL; parser.passthrough = NULL; parser.error = NULL; GMarkupParseContext* context = g_markup_parse_context_new(&parser, (GMarkupParseFlags)0, &Data, NULL); g_markup_parse_context_parse(context, configxml, -1, NULL); g_markup_parse_context_end_parse(context, NULL); g_markup_parse_context_free(context); }
void xml_loadsave_jobs_read(const gchar *dirname, const gchar *basename) { #ifdef DEBUG printf("xml_loadsave_jobs_read\n"); #endif GMarkupParser parser = {xml_loadsave_jobs_start_element, xml_loadsave_jobs_end_element, xml_loadsave_jobs_text, NULL, NULL}; GMarkupParseContext *context; gchar *file_contents; gsize length; GError *error = NULL; gchar file[SMALL]; free_jobs(TRUE); sprintf(file, "%s%s%s___job_teams.xml", dirname, G_DIR_SEPARATOR_S, basename); xml_loadsave_teams_read(file, job_teams); sprintf(file, "%s%s%s___jobs.xml", dirname, G_DIR_SEPARATOR_S, basename); context = g_markup_parse_context_new(&parser, 0, NULL, NULL); if(!g_file_get_contents(file, &file_contents, &length, &error)) { debug_print_message("xml_loadsave_jobs_read: error reading file %s\n", file); misc_print_error(&error, TRUE); } if(g_markup_parse_context_parse(context, file_contents, length, &error)) { g_markup_parse_context_end_parse(context, NULL); g_markup_parse_context_free(context); g_free(file_contents); } else { debug_print_message("xml_loadsave_jobs_read: error parsing file %s\n", file); misc_print_error(&error, TRUE); } }
gboolean cdk_style_scheme_reload (CdkStyleScheme *self) { g_return_val_if_fail (CDK_IS_STYLE_SCHEME (self), FALSE); g_hash_table_remove_all (self->priv->style_map); gchar *contents = NULL; gsize length = 0; GError *error = NULL; if (! g_file_get_contents (self->priv->filename, &contents, &length, &error)) { g_warning ("failed to read style scheme file '%s': %s", self->priv->filename, error->message); g_error_free (error); return FALSE; } GMarkupParser parser; memset (&parser, 0, sizeof (GMarkupParser)); parser.start_element = on_start_element; parser.end_element = on_end_element; GMarkupParseContext *ctx = g_markup_parse_context_new (&parser, 0, self, NULL); error = NULL; if (! g_markup_parse_context_parse (ctx, contents, length, &error)) { g_warning ("error parsing XML style scheme file '%s': %s", self->priv->filename, error->message); g_error_free (error); g_free (contents); g_markup_parse_context_free (ctx); return FALSE; } g_free (contents); g_markup_parse_context_free (ctx); //g_debug ("loaded style scheme from XML file '%s'", self->priv->filename); g_signal_emit_by_name (self, "reloaded"); return TRUE; }
void ghb_appcast_parse(gchar *buf, gchar **desc, gchar **build, gchar **version) { GMarkupParseContext *ctx; GMarkupParser parser; parse_data_t pd; GError *err = NULL; gint len; gchar *start; //gchar tmp[4096] // Skip junk at beginning of buffer start = strstr(buf, "<?xml "); pd.description = g_string_new(""); pd.item = FALSE; pd.build = NULL; pd.version = NULL; len = strlen(start); pd.tag_stack = g_queue_new(); pd.key = NULL; pd.value = NULL; parser.start_element = start_element; parser.end_element = end_element; parser.text = text_data; parser.passthrough = passthrough; parser.error = parse_error; ctx = g_markup_parse_context_new( &parser, G_MARKUP_TREAT_CDATA_AS_TEXT, &pd, destroy_notify); g_markup_parse_context_parse(ctx, start, len, &err); g_markup_parse_context_end_parse(ctx, &err); g_markup_parse_context_free(ctx); g_queue_free(pd.tag_stack); *desc = g_string_free(pd.description, FALSE); // work around a bug to leaves the CDATA closing brakets on the string gchar *glitch; glitch = g_strrstr(*desc, "]]>"); if (glitch) *glitch = 0; *build = pd.build; *version = pd.version; }
static void xml_wispr_parser_callback(const char *str, gpointer user_data) { struct connman_wispr_portal_context *wp_context = user_data; GMarkupParseContext *parser_context = NULL; bool result; DBG(""); parser_context = g_markup_parse_context_new(&xml_wispr_parser_handlers, G_MARKUP_TREAT_CDATA_AS_TEXT, &(wp_context->wispr_msg), NULL); result = g_markup_parse_context_parse(parser_context, str, strlen(str), NULL); if (result) g_markup_parse_context_end_parse(parser_context, NULL); g_markup_parse_context_free(parser_context); }
/** Parse a team definition file and write the team accordingly. */ void xml_team_read(Team *tm, const gchar *def_file) { #ifdef DEBUG printf("xml_team_read\n"); #endif GMarkupParser parser = {xml_team_read_start_element, xml_team_read_end_element, xml_team_read_text, NULL, NULL}; GMarkupParseContext *context; gchar *file_contents; gsize length; GError *error = NULL; team = tm; d_file = def_file; context = g_markup_parse_context_new(&parser, 0, NULL, NULL); if(!g_file_get_contents(def_file, &file_contents, &length, &error)) { debug_print_message("xml_team_read: error reading file %s\n", def_file); misc_print_error(&error, FALSE); return; } if(g_markup_parse_context_parse(context, file_contents, length, &error)) { g_markup_parse_context_end_parse(context, NULL); g_markup_parse_context_free(context); g_free(file_contents); } else { g_critical("xml_team_read: error parsing file %s\n", def_file); misc_print_error(&error, TRUE); } team_complete_def(team); }
gboolean migrate_46 (const gchar *filename, GError **error) { gsize length; gchar *contents; GMarkupParseContext *context; ConfigParser *parser; gboolean succeed = FALSE; g_return_val_if_fail (filename != NULL, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); if (!g_file_get_contents (filename, &contents, &length, error)) return FALSE; parser = g_slice_new0 (ConfigParser); parser->state = START; parser->plugin_id_counter = 0; parser->panel_id_counter = 0; parser->channel = xfconf_channel_new (XFCE_PANEL_CHANNEL_NAME); context = g_markup_parse_context_new (&markup_parser, 0, parser, NULL); if (g_markup_parse_context_parse (context, contents, length, error)) { /* check if the entire file is parsed */ if (g_markup_parse_context_end_parse (context, error)) succeed = TRUE; } /* if parsing failed somehow, empty the channel so no broken config is left */ if (!succeed) xfconf_channel_reset_property (parser->channel, "/", TRUE); g_free (contents); g_markup_parse_context_free (context); g_object_unref (G_OBJECT (parser->channel)); g_slice_free (ConfigParser, parser); return succeed; }
static void powerword2link(const char *p, guint32 sec_size, const gchar *oword, std::string *pango, LinksPosList *links_list) { PwUserData Data; Data.pango = pango; Data.links_list = links_list; Data.cur_pos = 0; Data.oword = oword; Data.first_jbcy = true; GMarkupParser parser; parser.start_element = func_parse_start_element; parser.end_element = NULL; parser.text = NULL; parser.passthrough = func_parse_passthrough; parser.error = NULL; GMarkupParseContext* context = g_markup_parse_context_new(&parser, (GMarkupParseFlags)0, &Data, NULL); g_markup_parse_context_parse(context, p, sec_size, NULL); g_markup_parse_context_end_parse(context, NULL); g_markup_parse_context_free(context); }
int main ( int argc, char **argv ) { GError *error = NULL; char *buffer = NULL; size_t buffer_length = 0; GMarkupParseContext *pc = pango_markup_parser_new ( 0 ); while ( error == NULL && getline ( &buffer, &buffer_length, stdin) > 0 ) { g_markup_parse_context_parse(pc, buffer, buffer_length, &error); } free(buffer); buffer = NULL; if ( error == NULL && pango_markup_parser_finish ( pc, NULL, &buffer, NULL, &error)) { fputs(buffer, stdout); } else { fprintf(stderr, "Failed to parse input: '%s'\n",error->message); g_error_free(error); } g_free(buffer); g_markup_parse_context_free(pc); }
static gboolean _set_content (GstMediaDescriptorParser * parser, const gchar * content, gsize size, GError ** error) { GError *err = NULL; GstMediaDescriptorParserPrivate *priv = parser->priv; priv->parsecontext = g_markup_parse_context_new (&content_parser, G_MARKUP_TREAT_CDATA_AS_TEXT, parser, NULL); if (g_markup_parse_context_parse (priv->parsecontext, content, size, &err) == FALSE) goto failed; return TRUE; failed: g_propagate_error (error, err); return FALSE; }
gint read_xml_frame(FILE *fp, struct model_pak *model) { gchar *line; GMarkupParser xml_parser; GMarkupParseContext *xml_context; GError *error; xml_system_table = g_hash_table_new_full(&g_str_hash, &hash_strcmp, &g_free, NULL); /* TODO - think more about this... */ xml_model = model; /* setup context parse (ie callbacks) */ xml_parser.start_element = &xml_start_element; xml_parser.end_element = &xml_end_element; xml_parser.text = &xml_parse_text; xml_parser.passthrough = NULL; xml_parser.error = NULL; xml_context = g_markup_parse_context_new(&xml_parser, 0, model, NULL); /* read in blocks (lines) of text */ line = file_read_line(fp); while (line) { /* parse the line */ if (!g_markup_parse_context_parse(xml_context, line, strlen(line), &error)) printf("read_xml() : parsing error.\n"); g_free(line); line = file_read_line(fp); } /* cleanup */ if (!g_markup_parse_context_end_parse(xml_context, &error)) printf("read_xml() : errors occurred reading file.\n"); g_markup_parse_context_free(xml_context); g_hash_table_destroy(xml_system_table); return(0); }
static void territories_init (void) { gboolean res; gsize buf_len; g_autofree char *buf = NULL; g_autoptr (GError) error = NULL; if (gnome_territories_map) return; bindtextdomain ("iso_3166", ISO_CODES_LOCALESDIR); bind_textdomain_codeset ("iso_3166", "UTF-8"); gnome_territories_map = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); error = NULL; res = g_file_get_contents (ISO_CODES_DATADIR "/iso_3166.xml", &buf, &buf_len, &error); if (res) { g_autoptr (GMarkupParseContext) ctx = NULL; GMarkupParser parser = { territories_parse_start_tag, NULL, NULL, NULL, NULL }; ctx = g_markup_parse_context_new (&parser, 0, NULL, NULL); error = NULL; res = g_markup_parse_context_parse (ctx, buf, buf_len, &error); if (! res) { g_warning ("Failed to parse '%s': %s\n", ISO_CODES_DATADIR "/iso_3166.xml", error->message); } } else { g_warning ("Failed to load '%s': %s\n", ISO_CODES_DATADIR "/iso_3166.xml", error->message); } }
static char *sdp_xml_parse_record(const char *data) { GMarkupParseContext *ctx; struct context_data ctx_data; int size; size = strlen(data); ctx_data.found = FALSE; ctx_data.id = NULL; ctx = g_markup_parse_context_new(&parser, 0, &ctx_data, NULL); if (g_markup_parse_context_parse(ctx, data, size, NULL) == FALSE) { g_markup_parse_context_free(ctx); g_free(ctx_data.id); return NULL; } g_markup_parse_context_free(ctx); return ctx_data.id; }
static gboolean parse_file_gmarkup (const gchar *filename, const GMarkupParser *parser, gpointer data, GError **err) { GMarkupParseContext *context = NULL; gchar *contents = NULL; gboolean result = TRUE; gsize len; if (!g_file_get_contents (filename, &contents, &len, err)) { result = FALSE; goto out; } context = g_markup_parse_context_new (parser, 0, data, NULL); if (!g_markup_parse_context_parse (context, contents, len, err)) { result = FALSE; goto out; } if (!g_markup_parse_context_end_parse (context, err)) { result = FALSE; goto out; } out: if (contents) g_free (contents); if (context) g_markup_parse_context_free (context); return result; }
static void list_folder_callback(struct session_data *session, GError *err, void *user_data) { struct transfer_data *transfer = session->pending->data; GMarkupParseContext *ctxt; DBusMessage *reply; DBusMessageIter iter, array; int i; reply = dbus_message_new_method_return(session->msg); if (transfer->filled == 0) goto done; for (i = transfer->filled - 1; i > 0; i--) { if (transfer->buffer[i] != '\0') break; transfer->filled--; } dbus_message_iter_init_append(reply, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array); ctxt = g_markup_parse_context_new(&parser, 0, &array, NULL); g_markup_parse_context_parse(ctxt, transfer->buffer, transfer->filled, NULL); g_markup_parse_context_free(ctxt); dbus_message_iter_close_container(&iter, &array); transfer->filled = 0; done: g_dbus_send_message(session->conn, reply); dbus_message_unref(session->msg); session->msg = NULL; }
void xml_loadsave_live_game_read(const gchar *filename, LiveGame *live_game) { #ifdef DEBUG printf("xml_loadsave_live_game_read\n"); #endif GMarkupParser parser = {xml_loadsave_live_game_start_element, xml_loadsave_live_game_end_element, xml_loadsave_live_game_text, NULL, NULL}; GMarkupParseContext *context; gchar *file_contents; gsize length; GError *error = NULL; context = g_markup_parse_context_new(&parser, 0, NULL, NULL); if(!g_file_get_contents(filename, &file_contents, &length, &error)) { debug_print_message("xml_loadsave_live_game_read: error reading file %s\n", filename); misc_print_error(&error, TRUE); } lgame = live_game; lgame->team_names[0] = lgame->team_names[1] = NULL; if(g_markup_parse_context_parse(context, file_contents, length, &error)) { g_markup_parse_context_end_parse(context, NULL); g_markup_parse_context_free(context); g_free(file_contents); } else { debug_print_message("xml_loadsave_live_game_read: error parsing file %s\n", filename); misc_print_error(&error, TRUE); } }
static void get_saved_plugin_data (void) { gchar *pspirc_name = gimp_personal_rc_file (PSPIRC); gchar *contents; gsize length; GMarkupParseContext *context; static GMarkupParser parser = { start_element_handler, end_element_handler, NULL, NULL, NULL }; UserData user_data; plug_in_hash = g_hash_table_new (g_str_hash, g_str_equal); entry_hash = g_hash_table_new (g_str_hash, g_str_equal); /* Read data for the PS plug-ins found last time */ if (!g_file_get_contents (pspirc_name, &contents, &length, NULL)) { g_free (pspirc_name); return; } user_data.pspi = NULL; context = g_markup_parse_context_new (&parser, 0, &user_data, NULL); if (!g_markup_parse_context_parse (context, contents, length, NULL)) { g_markup_parse_context_free (context); g_free (pspirc_name); return; } g_free (contents); g_markup_parse_context_end_parse (context, NULL); g_markup_parse_context_free (context); }
bool SettingsLoad (SettingsPersist * psSettingsData) { bool boSuccess = FALSE; GMarkupParseContext * psParseContext; GMarkupParser * psParser; FILE * fhFile; gchar szFileBuffer[FILE_BUFFER_SIZE]; int nRead; psSettingsData->nLevel = 0; psParser = g_new0 (GMarkupParser, 1); psParser->start_element = StartElement; psParser->end_element = EndElement; psParser->text = Text; psParser->passthrough = NULL; psParser->error = NULL; fhFile = fopen (psSettingsData->szFilename->str, "rb"); if (fhFile) { boSuccess = TRUE; psParseContext = g_markup_parse_context_new (psParser, 0, (gpointer)psSettingsData, DestroyUserData); nRead = fread (szFileBuffer, sizeof (char), FILE_BUFFER_SIZE, fhFile); while (boSuccess && (nRead > 0)) { boSuccess = g_markup_parse_context_parse (psParseContext, szFileBuffer, nRead, NULL); nRead = fread (szFileBuffer, sizeof (char), FILE_BUFFER_SIZE, fhFile); } if (boSuccess) { g_markup_parse_context_end_parse (psParseContext, NULL); } g_markup_parse_context_free (psParseContext); fclose (fhFile); } g_free (psParser); // The context is destroyed automatically by the parser return boSuccess; }
xmlnode *xmlnode_from_str(const char *str, size_t size) { struct _xmlnode_parser_data *xpd = g_new0(struct _xmlnode_parser_data, 1); xmlnode *ret; GMarkupParseContext *context; size_t real_size = size == -1 ? strlen(str) : size; context = g_markup_parse_context_new(&xmlnode_parser, 0, xpd, NULL); if(!g_markup_parse_context_parse(context, str, real_size, NULL)) { while(xpd->current && xpd->current->parent) xpd->current = xpd->current->parent; if(xpd->current) xmlnode_free(xpd->current); xpd->current = NULL; } g_markup_parse_context_free(context); ret = xpd->current; g_free(xpd); return ret; }
gboolean parser_parseContents(Parser* parser, gchar* contents, gsize length, GQueue* actions) { /* parse the contents, collecting actions. we store a pointer * to it in parser so we have access while parsing elements. */ parser->actions = actions; GError *error = NULL; gboolean success = g_markup_parse_context_parse(parser->context, contents, (gssize) length, &error); parser->actions = NULL; /* check for success in parsing and validating the XML */ if(success && !error) { return TRUE; } else { /* some kind of error occurred, check the parser */ g_assert(error); error("g_markup_parse_context_parse: Shadow XML parsing error %i: %s", error->code, error->message); g_error_free(error); return FALSE; } }
static int event_report_close(void *obj) { struct mns_session *mns = obj; GMarkupParseContext *ctxt; struct map_event *event; DBG(""); event = g_new0(struct map_event, 1); ctxt = g_markup_parse_context_new(&event_report_parser, 0, event, NULL); g_markup_parse_context_parse(ctxt, mns->buffer->str, mns->buffer->len, NULL); g_markup_parse_context_free(ctxt); map_dispatch_event(mns->mas_instance_id, mns->remote_address, event); map_event_free(event); reset_request(mns); return 0; }
static char * markup_test (const char *s) { GMarkupParser *parser = g_new0 (GMarkupParser, 1); GMarkupParseContext *context; GError *error = NULL; context = g_markup_parse_context_new (parser, 0, 0, 0); g_markup_parse_context_parse (context, s, strlen (s), &error); g_markup_parse_context_free (context); if (error != NULL){ char *msg = g_strdup (error->message); g_error_free (error); g_free (parser); return msg; } g_free (parser); return NULL; }
/** * Parse config file * * @retval TRUE if file is parsed * @retval FALSE if failed to parse file */ gboolean conf_parse_file (ConfData *conf, const gchar *filename) { gchar *contents; gsize length; GError *error; GMarkupParseContext *context; const GMarkupParser parser = { start_element_handler, end_element_handler, text_handler, NULL, error_handler }; error = NULL; if (!g_file_get_contents (filename, &contents, &length, &error)) { LOG_err (CONF, "%s", error->message); g_error_free (error); return FALSE; } context = g_markup_parse_context_new (&parser, G_MARKUP_TREAT_CDATA_AS_TEXT, conf, NULL); if (!g_markup_parse_context_parse (context, contents, (gssize)length, NULL)) { g_markup_parse_context_free (context); return FALSE; } if (!g_markup_parse_context_end_parse (context, NULL)) { g_markup_parse_context_free (context); return FALSE; } g_markup_parse_context_free (context); g_free (contents); return TRUE; }
static GHashTable * read_country_codes (const gchar *country_codes_file, GCancellable *cancellable, GError **error) { GHashTable *table = NULL; GMarkupParseContext *ctx; char *buf; gsize buf_len; /* Set domain to iso_3166 for country name translation */ bindtextdomain ("iso_3166", ISO_CODES_LOCALESDIR); bind_textdomain_codeset ("iso_3166", "UTF-8"); if (!g_file_get_contents (country_codes_file, &buf, &buf_len, error)) { g_prefix_error (error, "Failed to load '%s' from 'iso-codes': ", country_codes_file); return NULL; } table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify)nma_country_info_unref); ctx = g_markup_parse_context_new (&iso_3166_parser, 0, table, NULL); if (!g_markup_parse_context_parse (ctx, buf, buf_len, error)) { g_prefix_error (error, "Failed to parse '%s' from 'iso-codes': ", country_codes_file); g_hash_table_destroy (table); return NULL; } g_markup_parse_context_free (ctx); g_free (buf); return table; }
int dmtxplugin_xml_parse_len(const char *data) { GMarkupParseContext *ctx; struct context_len_data ctx_data; int size, ret; GError *error; size = strlen(data); //printf("XML parser: start parsing with data size %d\n", size); ctx_data.found = FALSE; ctx_data.len = 0; ctx = g_markup_parse_context_new(&len_parser, 0, &ctx_data, NULL); ret = g_markup_parse_context_parse(ctx, data, size, &error); if ( ret == FALSE) printf("parser returned %d error : %s \n", ret, error->message ); g_markup_parse_context_free(ctx); return ctx_data.len; }
static GHashTable * parse_gschema_files (gchar **files, gboolean byteswap, GError **error) { GMarkupParser parser = { start_element, end_element, text }; GMarkupParseContext *context; ParseState state = { byteswap, }; const gchar *filename; context = g_markup_parse_context_new (&parser, G_MARKUP_PREFIX_ERROR_POSITION, &state, NULL); state.schemas = gvdb_hash_table_new (NULL, NULL); while ((filename = *files++) != NULL) { gchar *contents; gsize size; if (!g_file_get_contents (filename, &contents, &size, error)) return FALSE; if (!g_markup_parse_context_parse (context, contents, size, error)) { g_prefix_error (error, "%s: ", filename); return FALSE; } if (!g_markup_parse_context_end_parse (context, error)) { g_prefix_error (error, "%s: ", filename); return FALSE; } } return state.schemas; }
static void languages_variant_init (const char *variant) { gboolean res; gsize buf_len; g_autofree char *buf = NULL; g_autofree char *filename = NULL; g_autoptr (GError) error = NULL; bindtextdomain (variant, ISO_CODES_LOCALESDIR); bind_textdomain_codeset (variant, "UTF-8"); error = NULL; filename = g_strdup_printf (ISO_CODES_DATADIR "/%s.xml", variant); res = g_file_get_contents (filename, &buf, &buf_len, &error); if (res) { g_autoptr (GMarkupParseContext) ctx = NULL; GMarkupParser parser = { languages_parse_start_tag, NULL, NULL, NULL, NULL }; ctx = g_markup_parse_context_new (&parser, 0, NULL, NULL); error = NULL; res = g_markup_parse_context_parse (ctx, buf, buf_len, &error); if (! res) { g_warning ("Failed to parse '%s': %s\n", filename, error->message); } } else { g_warning ("Failed to load '%s': %s\n", filename, error->message); } }