static GnomeThemeFileLine *
lookup_line (GnomeThemeFile *df,
GnomeThemeFileSection *section,
const char *keyname,
const char *locale)
{
GnomeThemeFileLine *line;
GQuark key_quark;
int i;
key_quark = g_quark_try_string (keyname);
if (key_quark == 0)
return NULL;
for (i = 0; i < section->n_lines; i++)
{
line = §ion->lines[i];
if (line->key == key_quark &&
((locale == NULL && line->locale == NULL) ||
(locale != NULL && line->locale != NULL && strcmp (locale, line->locale) == 0)))
return line;
}
return NULL;
}
static void
on_ca_certificate_public_key_info (GQuark type, const guchar *data, gsize n_data,
GHashTable *headers, gpointer user_data)
{
GNode *asn1 = NULL;
GkmDataResult res;
gpointer keydata;
gsize n_keydata;
gcry_sexp_t sexp;
g_assert (g_quark_try_string ("CERTIFICATE") == type);
/* Parse the ASN1 data */
res = gkm_data_der_read_certificate (data, n_data, &asn1);
g_assert (res == GKM_DATA_SUCCESS);
/* Generate a raw public key from our certificate */
keydata = egg_asn1x_encode (egg_asn1x_node (asn1, "tbsCertificate", "subjectPublicKeyInfo", NULL), NULL, &n_keydata);
g_assert (keydata);
/* Now create us a nice public key with that identifier */
res = gkm_data_der_read_public_key_info (keydata, n_keydata, &sexp);
g_assert (res == GKM_DATA_SUCCESS || res == GKM_DATA_UNRECOGNIZED);
if (res == GKM_DATA_SUCCESS)
gcry_sexp_release (sexp);
g_free (keydata);
}
static void
get_protocols_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GSimpleAsyncResult *outer_result = user_data;
GList *protocols = NULL;
GList *ret;
GList *l;
GError *error = NULL;
GQuark facebook_quark;
#if GOA_GOOGLE_ENABLED
GQuark google_talk_quark;
#endif
if (!tpaw_protocol_get_all_finish (&protocols, res, &error))
{
g_simple_async_result_take_error (outer_result, error);
g_simple_async_result_complete_in_idle (outer_result);
g_object_unref (outer_result);
return;
}
facebook_quark = g_quark_from_static_string ("facebook");
#if GOA_GOOGLE_ENABLED
google_talk_quark = g_quark_from_static_string ("google-talk");
#endif
ret = NULL;
for (l = protocols; l != NULL; l = l->next)
{
TpawProtocol *protocol = l->data;
const gchar *service_name = tpaw_protocol_get_service_name (protocol);
GQuark service_quark = g_quark_try_string (service_name);
GoaTelepathyProvider *provider;
/* This service does not exist anymore, so skip it. */
if (service_quark == facebook_quark)
continue;
/* If the service is handled natively by GOA, so we don't allow
* the creation of a Telepathy-only account. */
#if GOA_GOOGLE_ENABLED
if (service_quark == google_talk_quark)
continue;
#endif
provider = goa_telepathy_provider_new_from_protocol (protocol);
ret = g_list_prepend (ret, provider);
}
ret = g_list_reverse (ret);
g_list_free_full (protocols, g_object_unref);
g_simple_async_result_set_op_res_gpointer (outer_result, ret, free_list_and_unref);
g_simple_async_result_complete_in_idle (outer_result);
g_object_unref (outer_result);
}
static AnjutaPluginDescriptionLine *
lookup_line (AnjutaPluginDescription *df,
AnjutaPluginDescriptionSection *section,
const char *keyname,
const char *locale)
{
AnjutaPluginDescriptionLine *line;
GQuark key_quark;
int i;
key_quark = g_quark_try_string (keyname);
if (key_quark == 0)
return NULL;
for (i = 0; i < section->n_lines; i++)
{
line = §ion->lines[i];
if (line->key == key_quark &&
((locale == NULL && line->locale == NULL) ||
(locale != NULL && line->locale != NULL && strcmp (locale, line->locale) == 0)))
return line;
}
return NULL;
}
/* Look up a property, take fallback into account. */
static ccss_property_t const *
lookup_property_r (ccss_style_t const *self,
char const *property_name)
{
GQuark property_id;
ccss_property_t const *property = NULL;
property_id = g_quark_try_string (property_name);
if (property_id) {
property = (ccss_property_t const *)
g_hash_table_lookup (self->properties,
(gpointer) property_id);
}
if (property) {
return property;
}
for (unsigned int i = 0; _fallback_map[i].name != NULL; i++) {
if (0 == g_strcmp0 (property_name, _fallback_map[i].name)) {
return lookup_property_r (self, _fallback_map[i].fallback);
}
}
return NULL;
}
struct bt_ctf_field_type *bt_ctf_event_class_get_field_by_name(
struct bt_ctf_event_class *event_class, const char *name)
{
GQuark name_quark;
struct bt_ctf_field_type *field_type = NULL;
if (!event_class || !name) {
goto end;
}
if (bt_ctf_field_type_get_type_id(event_class->fields) !=
CTF_TYPE_STRUCT) {
goto end;
}
name_quark = g_quark_try_string(name);
if (!name_quark) {
goto end;
}
/*
* No need to increment field_type's reference count since getting it
* from the structure already does.
*/
field_type = bt_ctf_field_type_structure_get_field_type_by_name(
event_class->fields, name);
end:
return field_type;
}
gboolean
desktop_entry_has_category (DesktopEntry *entry,
const char *category)
{
GQuark quark;
int i;
DesktopEntryDesktop *desktop_entry;
if (entry->type != DESKTOP_ENTRY_DESKTOP)
return FALSE;
desktop_entry = (DesktopEntryDesktop*) entry;
if (desktop_entry->categories == NULL)
return FALSE;
if (!(quark = g_quark_try_string (category)))
return FALSE;
for (i = 0; desktop_entry->categories[i]; i++)
{
if (quark == desktop_entry->categories[i])
return TRUE;
}
return FALSE;
}
int
egg_openssl_parse_algo (const char *name, int *mode)
{
static GQuark openssl_quarks[G_N_ELEMENTS(openssl_algos)] = { 0, };
static gsize openssl_quarks_inited = 0;
GQuark q;
int i;
if (g_once_init_enter (&openssl_quarks_inited)) {
for (i = 0; i < G_N_ELEMENTS(openssl_algos); ++i)
openssl_quarks[i] = g_quark_from_static_string (openssl_algos[i].desc);
g_once_init_leave (&openssl_quarks_inited, 1);
}
q = g_quark_try_string (name);
if (q) {
for (i = 0; i < G_N_ELEMENTS(openssl_algos); ++i) {
if (q == openssl_quarks[i]) {
*mode = openssl_algos[i].mode;
return openssl_algos[i].algo;
}
}
}
return 0;
}
static void dock_manager_dbus_watcher_name_owner_changed (DockManagerDBusWatcher* self, DBusGProxy* sender, const gchar* name, const gchar* old_owner, const gchar* new_owner) {
gboolean _tmp0_;
g_return_if_fail (self != NULL);
g_return_if_fail (sender != NULL);
g_return_if_fail (name != NULL);
g_return_if_fail (old_owner != NULL);
g_return_if_fail (new_owner != NULL);
_tmp0_ = g_regex_match (self->priv->unnamed_bus_object, name, 0, NULL);
if (_tmp0_ == FALSE) {
if (g_strcmp0 (new_owner, "") == 0) {
gchar* _tmp1_;
GQuark _tmp2_;
_tmp1_ = g_strdup (name);
g_hash_table_replace (self->priv->owned_names, _tmp1_, GINT_TO_POINTER (0));
_tmp2_ = g_quark_try_string (name);
if (_tmp2_ != 0) {
gchar* _tmp3_ = NULL;
gchar* _tmp4_;
_tmp3_ = g_strdup_printf ("name-disappeared::%s", name);
_tmp4_ = _tmp3_;
g_signal_emit_by_name (self, _tmp4_, name, NULL);
_g_free0 (_tmp4_);
} else {
g_signal_emit_by_name (self, "name-disappeared", name);
}
} else {
if (g_strcmp0 (old_owner, "") == 0) {
gchar* _tmp5_;
GQuark _tmp6_;
_tmp5_ = g_strdup (name);
g_hash_table_replace (self->priv->owned_names, _tmp5_, GINT_TO_POINTER (1));
_tmp6_ = g_quark_try_string (name);
if (_tmp6_ != 0) {
gchar* _tmp7_ = NULL;
gchar* _tmp8_;
_tmp7_ = g_strdup_printf ("name-appeared::%s", name);
_tmp8_ = _tmp7_;
g_signal_emit_by_name (self, _tmp8_, name, NULL);
_g_free0 (_tmp8_);
} else {
g_signal_emit_by_name (self, "name-appeared", name);
}
}
}
}
}
/**
* crank_bench_run_get_param_double: (skip)
* @run: A benchmark run.
* @name: A parameter name.
* @defval: Default value if @name is not found.
*
* Gets double benchmark parameter by @name.
*
* Returns: A double benchmark parameter, or @defval if fail.
*/
gdouble
crank_bench_run_get_param_double (CrankBenchRun *run,
const gchar *name,
const gdouble defval)
{
GQuark qname = g_quark_try_string (name);
return crank_value_table_get_double (run->param, GINT_TO_POINTER(qname), defval);
}
/**
* crank_bench_run_get_param: (skip)
* @run: A benchmark run.
* @name: A parameter name.
*
* Gets a benchmark parameter by @name.
*
* Returns: (transfer none) (nullable): A benchmark parameter as #GValue. or
* %NULL if fail.
*/
GValue*
crank_bench_run_get_param (CrankBenchRun *run,
const gchar *name)
{
GQuark qname = g_quark_try_string (name);
return (GValue*) g_hash_table_lookup (run->param, GINT_TO_POINTER(qname));
}
gpointer
modem_request_steal_data (ModemRequest *request,
char const *key)
{
GQuark quark = g_quark_try_string (key);
if (!quark)
return NULL;
return modem_request_steal_qdata (request, quark);
}
guint32 internetwork_resolveName(Internetwork* internet, gchar* name) {
MAGIC_ASSERT(internet);
return g_quark_try_string((const gchar*) name);
// guint32* ip = g_hash_table_lookup(internet->ipByName, name);
// if(ip) {
// return *ip;
// } else {
// return (guint32)INADDR_NONE;
// }
}
BT_HIDDEN
void debug_info_handle_event(FILE *err, struct bt_event *event,
struct debug_info *debug_info)
{
struct bt_event_class *event_class;
const char *event_name;
GQuark q_event_name;
if (!debug_info || !event) {
goto end;
}
event_class = bt_event_get_class(event);
if (!event_class) {
goto end;
}
event_name = bt_event_class_get_name(event_class);
if (!event_name) {
goto end_put_class;
}
q_event_name = g_quark_try_string(event_name);
if (q_event_name == debug_info->q_statedump_bin_info) {
/* State dump */
handle_statedump_bin_info_event(err, debug_info, event);
} else if (q_event_name == debug_info->q_dl_open ||
q_event_name == debug_info->q_lib_load) {
/*
* dl_open and lib_load events are both checked for since
* only dl_open was produced as of lttng-ust 2.8.
*
* lib_load, which is produced from lttng-ust 2.9+, is a lot
* more reliable since it will be emitted when other functions
* of the dlopen family are called (e.g. dlmopen) and when
* library are transitively loaded.
*/
handle_lib_load_event(err, debug_info, event);
} else if (q_event_name == debug_info->q_statedump_start) {
/* Start state dump */
handle_statedump_start(err, debug_info, event);
} else if (q_event_name == debug_info->q_statedump_debug_link) {
/* Debug link info */
handle_statedump_debug_link_event(err, debug_info, event);
} else if (q_event_name == debug_info->q_statedump_build_id) {
/* Build ID info */
handle_statedump_build_id_event(err, debug_info, event);
} else if (q_event_name == debug_info-> q_lib_unload) {
handle_lib_unload_event(err, debug_info, event);
}
end_put_class:
bt_put(event_class);
end:
return;
}
int main(void) {
GQuark quark;
GQuark quarkb;
quark = g_quark_from_string ("orz");
printf ("quark value %d string: %s\n", quark, g_quark_to_string (quark));
if ((quarkb = g_quark_try_string("orz"))) {
printf ("string %s already exist\n", g_quark_to_string(quarkb));
}
return 0;
}
gint
pk_manifest_get_row_id (PkManifest *manifest,
const gchar *name)
{
GQuark quark;
g_return_val_if_fail(manifest != NULL, -1);
g_return_val_if_fail(manifest->rows != NULL, -1);
g_return_val_if_fail(name != NULL, -1);
if (!(quark = g_quark_try_string(name))) {
return -1;
}
return pk_manifest_get_row_id_from_quark(manifest, quark);
}
static void
config_logger (rspamd_mempool_t *pool, gpointer ud)
{
struct rspamd_main *rm = ud;
rm->cfg->log_type = RSPAMD_LOG_CONSOLE;
rm->cfg->log_level = G_LOG_LEVEL_CRITICAL;
rspamd_set_logger (rm->cfg, g_quark_try_string ("main"), rm);
if (rspamd_log_open_priv (rm->logger, rm->workers_uid, rm->workers_gid) ==
-1) {
fprintf (stderr, "Fatal error, cannot open logfile, exiting\n");
exit (EXIT_FAILURE);
}
}
void
gst_sunaudiomixer_ctrl_set_option (GstSunAudioMixerCtrl * mixer,
GstMixerOptions * options, gchar * value)
{
struct audio_info audioinfo;
GstMixerTrack *track;
GstSunAudioMixerOptions *opts;
GQuark q;
int i;
g_return_if_fail (mixer != NULL);
g_return_if_fail (mixer->mixer_fd != -1);
g_return_if_fail (value != NULL);
g_return_if_fail (GST_IS_SUNAUDIO_MIXER_OPTIONS (options));
track = GST_MIXER_TRACK (options);
opts = GST_SUNAUDIO_MIXER_OPTIONS (options);
if (opts->track_num != GST_SUNAUDIO_TRACK_RECSRC) {
g_warning ("set_option not supported on track %s", track->label);
return;
}
q = g_quark_try_string (value);
if (q == 0) {
g_warning ("unknown option '%s'", value);
return;
}
for (i = 0; i < 8; i++) {
if (opts->names[i] == q) {
break;
}
}
if (((1 << (i)) & opts->avail) == 0) {
g_warning ("Record port %s not available", g_quark_to_string (q));
return;
}
AUDIO_INITINFO (&audioinfo);
audioinfo.record.port = (1 << (i));
if (ioctl (mixer->mixer_fd, AUDIO_SETINFO, &audioinfo) < 0) {
g_warning ("Error setting audio record port");
}
}
struct bt_ctf_field_type *
bt_ctf_event_class_get_payload_type_field_type_by_name(
struct bt_ctf_event_class *event_class, const char *name)
{
GQuark name_quark;
struct bt_ctf_field_type *field_type = NULL;
if (!event_class || !name) {
BT_LOGW("Invalid parameter: event class or name is NULL: "
"event-class-addr=%p, name-addr=%p",
event_class, name);
goto end;
}
if (!event_class->common.payload_field_type) {
BT_LOGV("Event class has no payload field type: "
"addr=%p, name=\"%s\", id=%" PRId64,
event_class, bt_ctf_event_class_get_name(event_class),
bt_ctf_event_class_get_id(event_class));
goto end;
}
BT_ASSERT(bt_ctf_field_type_common_get_type_id(
event_class->common.payload_field_type) ==
BT_CTF_FIELD_TYPE_ID_STRUCT);
name_quark = g_quark_try_string(name);
if (!name_quark) {
BT_LOGE("Cannot get GQuark: string=\"%s\"", name);
goto end;
}
/*
* No need to increment field_type's reference count since getting it
* from the structure already does.
*/
field_type = (void *)
bt_ctf_field_type_structure_get_field_type_by_name(
(void *) event_class->common.payload_field_type, name);
end:
return field_type;
}
static gboolean
gtk_css_matcher_node_has_region (const GtkCssMatcher *matcher,
const char *region,
GtkRegionFlags flags)
{
GtkRegionFlags region_flags;
GQuark region_quark;
region_quark = g_quark_try_string (region);
if (!region_quark)
return FALSE;
if (!gtk_css_node_has_region (matcher->node.node, region_quark, ®ion_flags))
return FALSE;
if ((flags & region_flags) != flags)
return FALSE;
return TRUE;
}
gboolean
desktop_entry_has_category (DesktopEntry *entry,
const char *category)
{
GQuark quark;
int i;
if (entry->categories == NULL)
return FALSE;
if (!(quark = g_quark_try_string (category)))
return FALSE;
for (i = 0; entry->categories[i]; i++)
{
if (quark == entry->categories[i])
return TRUE;
}
return FALSE;
}
static AnjutaPluginDescriptionSection *
lookup_section (AnjutaPluginDescription *df,
const char *section_name)
{
AnjutaPluginDescriptionSection *section;
GQuark section_quark;
int i;
section_quark = g_quark_try_string (section_name);
if (section_quark == 0)
return NULL;
for (i = 0; i < df->n_sections; i ++)
{
section = &df->sections[i];
if (section->section_name == section_quark)
return section;
}
return NULL;
}
static GnomeThemeFileSection *
lookup_section (GnomeThemeFile *df,
const char *section_name)
{
GnomeThemeFileSection *section;
GQuark section_quark;
int i;
section_quark = g_quark_try_string (section_name);
if (section_quark == 0)
return NULL;
for (i = 0; i < df->n_sections; i ++)
{
section = &df->sections[i];
if (section->section_name == section_quark)
return section;
}
return NULL;
}
/**
* gimp_tag_try_new:
* @tag_string: a tag name.
*
* Similar to gimp_tag_new(), but returns NULL if tag is surely not equal
* to any of currently created tags. It is useful for tag querying to avoid
* unneeded comparisons. If tag is created, however, it does not mean that
* it would necessarily match with some other tag.
*
* Return value: new #GimpTag object, or NULL if tag will not match with any
* other #GimpTag.
**/
GimpTag *
gimp_tag_try_new (const char *tag_string)
{
GimpTag *tag;
gchar *tag_name;
gchar *case_folded;
gchar *collate_key;
GQuark tag_quark;
GQuark collate_key_quark;
tag_name = gimp_tag_string_make_valid (tag_string);
if (! tag_name)
return NULL;
case_folded = g_utf8_casefold (tag_name, -1);
collate_key = g_utf8_collate_key (case_folded, -1);
collate_key_quark = g_quark_try_string (collate_key);
g_free (collate_key);
g_free (case_folded);
if (! collate_key_quark)
{
g_free (tag_name);
return NULL;
}
tag_quark = g_quark_from_string (tag_name);
g_free (tag_name);
if (! tag_quark)
return NULL;
tag = g_object_new (GIMP_TYPE_TAG, NULL);
tag->tag = tag_quark;
tag->collate_key = collate_key_quark;
return tag;
}
static gboolean
gtk_css_matcher_widget_path_has_region (const GtkCssMatcher *matcher,
const char *region,
GtkRegionFlags flags)
{
const GtkWidgetPath *siblings;
GtkRegionFlags region_flags;
if (matcher->path.decl)
{
GQuark q = g_quark_try_string (region);
if (q && gtk_css_node_declaration_has_region (matcher->path.decl, q, ®ion_flags))
goto found;
}
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
siblings = gtk_widget_path_iter_get_siblings (matcher->path.path, matcher->path.index);
if (siblings && matcher->path.sibling_index != gtk_widget_path_iter_get_sibling_index (matcher->path.path, matcher->path.index))
{
if (!gtk_widget_path_iter_has_region (siblings, matcher->path.sibling_index, region, ®ion_flags))
return FALSE;
}
else
{
if (!gtk_widget_path_iter_has_region (matcher->path.path, matcher->path.index, region, ®ion_flags))
return FALSE;
}
G_GNUC_END_IGNORE_DEPRECATIONS
found:
if ((flags & region_flags) != flags)
return FALSE;
return TRUE;
}
/**
* gst_tracing_register_hook:
* @tracer: the tracer
* @detail: the detailed hook
* @func: (scope async): the callback
*
* Register @func to be called when the trace hook @detail is getting invoked.
*/
void
gst_tracing_register_hook (GstTracer * tracer, const gchar * detail,
GCallback func)
{
gst_tracing_register_hook_id (tracer, g_quark_try_string (detail), func);
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
bool tzn::got(const char* tzcode, TzLocation& locret, TzInfo& nforet, bool exact)
{
DEBUGLOGB;
int fnd = 0;
bool ret = false;
DEBUGLOGP("requested entry tzcode is %s, exact is %s\n", tzcode, exact ? "on" : "off");
GPtrArray* locs = tz_get_locations(tzdb);
if( locs )
{
char* tzn = tz_info_get_clean_name(tzdb, tzcode);
const char* tzs = tzn ? tzn : (!exact ? tzcode : NULL);
if( tzs )
{
DEBUGLOGP("requested entry tzcode (cleaned) is %s\n", tzs);
TzInfo* nfo;
TzLocation* loc;
bool got;
bool cont_ok, city_ok;
const char* cont_db, *city_db;
const char* cont_in = strchr (tzs, '/'); // end of continent string for search string
const char* city_in = strrchr(tzs, '/'); // begin of city string for search string
int cont_il = cont_in ? cont_in-tzs : 0;
int city_il = city_in ? strlen(city_in) : 0;
DEBUGLOGP("cont_in is %s\n", cont_in);
DEBUGLOGP("city_in is %s\n", city_in);
if( !exact || (exact && g_quark_try_string(tzs)) ) // NOTE: according to tz.c comments, this will work
{
for( size_t i = 0; i < locs->len; i++ )
{
if( !(loc = (TzLocation*)locs->pdata[i]) ) continue;
if( !(nfo = tz_info_from_location(loc)) ) continue;
if( !(got = stricmp(loc->zone, tzs) == 0) && !exact )
{
cont_db = strchr (loc->zone, '/'); // end of continent string in db
city_db = strrchr(loc->zone, '/'); // begin of city string in db
if( cont_db != city_db )
{
// just compare the 1st and last partitions, i.e., continent and city,
// disregarding the 'middle' part, i.e., country or state
DEBUGLOGS("tzcode (cleaned) not found and exact is off");
DEBUGLOGS("comparing just the continent and city strings");
DEBUGLOGP("cont_db is %s\n", cont_db);
DEBUGLOGP("city_db is %s\n", city_db);
cont_ok = cont_in && cont_db && cont_il == (cont_db-loc->zone) && strnicmp(tzs, loc->zone, cont_il) == 0;
city_ok = city_in && city_db && city_il == strlen(city_db) && strnicmp(city_in, city_db, city_il) == 0;
got = cont_ok && city_ok;
DEBUGLOGP("cont_ok is %s, city_ok is %s\n", cont_ok ? "on" : "off", city_ok ? "on" : "off");
}
}
if( got )
{
// DEBUGLOGP("%s/%s/%s\n", loc->country, loc->zone, loc->comment);
DEBUGLOGP("%s\n", loc->zone);
locret = *loc;
nforet = *nfo;
ret = true;
fnd++;
}
tz_info_free(nfo);
if( fnd > 1 ) break;
// if( ret ) break;
}
}
#ifdef DEBUGLOG
else
DEBUGLOGS("requested entry tzcode (cleaned) not found");
#endif
}
if( tzn )
g_free(tzn);
}
DEBUGLOGE;
return ret && fnd == 1;
}
static gboolean
cockpit_web_server_default_handle_stream (CockpitWebServer *self,
const gchar *path,
GIOStream *io_stream,
GHashTable *headers,
GByteArray *input,
guint in_length)
{
CockpitWebResponse *response;
gboolean claimed = FALSE;
GQuark detail;
gchar *pos;
gchar bak;
/* Yes, we happen to know that we can modify this string safely. */
pos = strchr (path, '?');
if (pos != NULL)
{
*pos = '\0';
pos++;
}
/* TODO: Correct HTTP version for response */
response = cockpit_web_response_new (io_stream, path, pos, headers);
g_signal_connect_data (response, "done", G_CALLBACK (on_web_response_done),
g_object_ref (self), (GClosureNotify)g_object_unref, 0);
/*
* If the path has more than one component, then we search
* for handlers registered under the detail like this:
*
* /component/
*
* Otherwise we search for handlers registered under detail
* of the entire path:
*
* /component
*/
/* Temporarily null terminate string after first component */
pos = NULL;
if (path[0] != '\0')
{
pos = strchr (path + 1, '/');
if (pos != NULL)
{
pos++;
bak = *pos;
*pos = '\0';
}
}
detail = g_quark_try_string (path);
if (pos != NULL)
*pos = bak;
/* See if we have any takers... */
g_signal_emit (self,
sig_handle_resource, detail,
path,
headers,
response,
&claimed);
/* TODO: Here is where we would plug keep-alive into respnse */
g_object_unref (response);
return claimed;
}
static SfiTokenType
bse_wave_restore_private (BseObject *object,
BseStorage *storage,
GScanner *scanner)
{
BseWave *wave = BSE_WAVE (object);
GTokenType expected_token;
GQuark quark;
/* chain parent class' handler */
if (g_scanner_peek_next_token (scanner) != G_TOKEN_IDENTIFIER)
return BSE_OBJECT_CLASS (parent_class)->restore_private (object, storage, scanner);
/* parse storage commands */
quark = g_quark_try_string (scanner->next_value.v_identifier);
if (quark == quark_xinfos)
{
g_scanner_get_next_token (scanner); /* eat identifier */
gchar **xinfos = NULL;
GTokenType token = bse_storage_parse_xinfos (storage, &xinfos);
if (token != G_TOKEN_NONE)
return token;
guint i = 0;
for (i = 0; xinfos && xinfos[i]; i++)
wave->xinfos = bse_xinfos_parse_assignment (wave->xinfos, xinfos[i]);
g_strfreev (xinfos);
parse_or_return (scanner, ')');
expected_token = G_TOKEN_NONE; /* got ')' */
}
else if (quark == quark_load_wave)
{
BseFreqArray *skip_list, *load_list, *array;
gchar *file_name, *wave_name;
BseErrorType error;
g_scanner_get_next_token (scanner); /* eat quark identifier */
parse_or_return (scanner, G_TOKEN_STRING);
file_name = g_strdup (scanner->value.v_string);
if (g_scanner_get_next_token (scanner) != G_TOKEN_STRING)
{
g_free (file_name);
return G_TOKEN_STRING;
}
wave_name = g_strdup (scanner->value.v_string);
skip_list = bse_freq_array_new (1024);
load_list = bse_freq_array_new (1024);
if (BSE_STORAGE_COMPAT (storage, 0, 6, 4))
while (g_scanner_get_next_token (scanner) != ')')
{
if (scanner->token == G_TOKEN_IDENTIFIER)
{
if (strcmp (scanner->value.v_identifier, "list") == 0)
array = load_list;
else if (strcmp (scanner->value.v_identifier, "skip") == 0)
array = skip_list;
else
{
expected_token = G_TOKEN_IDENTIFIER; /* want _valid_ identifier */
goto out_of_load_wave;
}
g_scanner_peek_next_token (scanner);
if (scanner->next_token != G_TOKEN_INT && scanner->next_token != G_TOKEN_FLOAT)
{
g_scanner_get_next_token (scanner); /* eat invalid token */
expected_token = G_TOKEN_FLOAT;
goto out_of_load_wave;
}
while (g_scanner_peek_next_token (scanner) == G_TOKEN_INT ||
g_scanner_peek_next_token (scanner) == G_TOKEN_FLOAT)
{
g_scanner_get_next_token (scanner); /* int or float */
bse_freq_array_append (array, scanner->token == G_TOKEN_FLOAT ? scanner->value.v_float : scanner->value.v_int64);
}
}
else
{
expected_token = ')';
goto out_of_load_wave;
}
}
else
parse_or_return (scanner, ')');
error = bse_wave_load_wave_file (wave, file_name, wave_name,
bse_freq_array_n_values (load_list) ? load_list : 0, skip_list,
FALSE);
if (error)
bse_storage_warn (storage, "failed to load wave \"%s\" from \"%s\": %s",
wave_name, file_name, bse_error_blurb (error));
expected_token = G_TOKEN_NONE; /* got ')' */
out_of_load_wave:
g_free (file_name);
g_free (wave_name);
bse_freq_array_free (skip_list);
bse_freq_array_free (load_list);
}
else if (BSE_STORAGE_COMPAT (storage, 0, 6, 4) && quark == quark_set_locator)
{
g_scanner_get_next_token (scanner); /* eat quark identifier */
parse_or_return (scanner, G_TOKEN_STRING);
gchar *file_name = g_strdup (scanner->value.v_string);
if (g_scanner_get_next_token (scanner) != G_TOKEN_STRING)
{
g_free (file_name);
return G_TOKEN_STRING;
}
gchar *wave_name = g_strdup (scanner->value.v_string);
if (g_scanner_get_next_token (scanner) != ')')
{
g_free (file_name);
g_free (wave_name);
return ')';
}
// g_print ("set-locator \"%s\" \"%s\"\n", file_name, wave_name);
bse_wave_set_locator (wave, file_name, wave_name);
expected_token = G_TOKEN_NONE; /* got ')' */
}
else if (quark == quark_wave_chunk)
{
ParsedWaveChunk parsed_wchunk = { NULL, NULL, 0, 0, 0 };
g_scanner_get_next_token (scanner); /* eat quark identifier */
g_scanner_peek_next_token (scanner);
bse_storage_compat_dhreset (storage); /* VERSION-FIXME: needed for <= 0.5.1 */
if (scanner->next_token == G_TOKEN_FLOAT || scanner->next_token == G_TOKEN_INT)
{
g_scanner_get_next_token (scanner);
bse_storage_compat_dhoscf (storage, /* VERSION-FIXME: needed for <= 0.5.1 */
(scanner->token == G_TOKEN_INT ?
scanner->value.v_int64 : scanner->value.v_float));
g_scanner_peek_next_token (scanner);
if (scanner->next_token == G_TOKEN_FLOAT || scanner->next_token == G_TOKEN_INT)
{
g_scanner_get_next_token (scanner);
bse_storage_compat_dhmixf (storage, /* VERSION-FIXME: needed for <= 0.5.1 */
(scanner->token == G_TOKEN_INT ?
scanner->value.v_int64 : scanner->value.v_float));
}
}
expected_token = bse_storage_parse_rest (storage, wave,
(BseTryStatement) parse_wave_chunk,
&parsed_wchunk);
bse_storage_compat_dhreset (storage); /* VERSION-FIXME: needed for <= 0.5.1 */
if (expected_token == G_TOKEN_NONE && parsed_wchunk.data_handle)
{
if (0)
g_printerr ("restore-wave-chunk: nch=%u of=%f mf=%f dh=%p\n",
parsed_wchunk.wh_n_channels,
parsed_wchunk.wh_osc_freq, parsed_wchunk.wh_mix_freq,
parsed_wchunk.data_handle);
if (parsed_wchunk.data_handle && parsed_wchunk.xinfos)
{
GslDataHandle *tmp_handle = parsed_wchunk.data_handle;
parsed_wchunk.data_handle = gsl_data_handle_new_add_xinfos (parsed_wchunk.data_handle, parsed_wchunk.xinfos);
gsl_data_handle_unref (tmp_handle);
}
GslDataCache *dcache = gsl_data_cache_from_dhandle (parsed_wchunk.data_handle,
BSE_CONFIG (wave_chunk_padding) * parsed_wchunk.wh_n_channels);
const gchar *ltype = bse_xinfos_get_value (parsed_wchunk.xinfos, "loop-type");
GslWaveLoopType loop_type = ltype ? gsl_wave_loop_type_from_string (ltype) : GSL_WAVE_LOOP_NONE;
SfiNum loop_start = bse_xinfos_get_num (parsed_wchunk.xinfos, "loop-start");
SfiNum loop_end = bse_xinfos_get_num (parsed_wchunk.xinfos, "loop-end");
SfiNum loop_count = bse_xinfos_get_num (parsed_wchunk.xinfos, "loop-count");
if (loop_end <= loop_start)
{
loop_start = loop_end = 0;
loop_type = GSL_WAVE_LOOP_NONE;
loop_count = 0;
}
GslWaveChunk *wchunk = gsl_wave_chunk_new (dcache, parsed_wchunk.wh_mix_freq, parsed_wchunk.wh_osc_freq,
loop_type, loop_start, loop_end, loop_count);
gsl_data_cache_unref (dcache);
/* we need to keep inlined data handles open to protect against storage (.bse file) overwriting */
BseErrorType error = bse_wave_add_inlined_wave_chunk (wave, wchunk);
if (!error)
bse_wave_add_chunk (wave, wchunk);
else
{
bse_storage_error (storage, "failed to reopen inlined data handle (%s): %s",
gsl_data_handle_name (wchunk->dcache->dhandle), bse_error_blurb (error));
gsl_wave_chunk_unref (wchunk);
}
}
if (parsed_wchunk.data_handle)
gsl_data_handle_unref (parsed_wchunk.data_handle);
g_strfreev (parsed_wchunk.xinfos);
}
else /* chain parent class' handler */
expected_token = BSE_OBJECT_CLASS (parent_class)->restore_private (object, storage, scanner);
return expected_token;
}
static SfiTokenType
parse_wave_chunk (BseWave *wave,
BseStorage *storage,
GScanner *scanner,
ParsedWaveChunk *pwchunk)
{
if (g_scanner_peek_next_token (scanner) != G_TOKEN_IDENTIFIER)
return SFI_TOKEN_UNMATCHED;
GQuark quark = g_quark_try_string (scanner->next_value.v_string);
if (quark == quark_xinfos)
{
g_scanner_get_next_token (scanner); /* eat identifier */
g_strfreev (pwchunk->xinfos);
pwchunk->xinfos = NULL;
GTokenType token = bse_storage_parse_xinfos (storage, &pwchunk->xinfos);
if (token != G_TOKEN_NONE)
return token;
}
else if (bse_storage_match_data_handle (storage, quark))
{
guint expected_token;
if (pwchunk->data_handle)
return bse_storage_warn_skip (storage, "duplicate wave data reference");
expected_token = bse_storage_parse_data_handle_rest (storage,
&pwchunk->data_handle,
&pwchunk->wh_n_channels,
&pwchunk->wh_mix_freq,
&pwchunk->wh_osc_freq);
if (expected_token != G_TOKEN_NONE)
return expected_token;
if (!pwchunk->data_handle)
bse_storage_warn (storage, "invalid wave data reference");
/* closing brace already parsed by bse_storage_parse_data_handle_rest() */
return G_TOKEN_NONE;
}
else if (BSE_STORAGE_COMPAT (storage, 0, 5, 1) && quark == quark_wave_handle)
{
guint expected_token;
g_scanner_get_next_token (scanner); /* eat identifier */
if (pwchunk->data_handle)
return bse_storage_warn_skip (storage, "duplicate wave data reference");
expected_token = bse_storage_parse_data_handle (storage,
&pwchunk->data_handle,
&pwchunk->wh_n_channels,
&pwchunk->wh_mix_freq,
&pwchunk->wh_osc_freq);
if (expected_token != G_TOKEN_NONE)
return expected_token;
if (!pwchunk->data_handle)
bse_storage_warn (storage, "invalid wave data reference");
}
else if (BSE_STORAGE_COMPAT (storage, 0, 5, 1) && quark == quark_n_channels)
{
g_scanner_get_next_token (scanner); /* eat quark identifier */
parse_or_return (scanner, G_TOKEN_INT);
bse_storage_compat_dhchannels (storage, scanner->value.v_int64);
}
else if (BSE_STORAGE_COMPAT (storage, 0, 6, 4) && (quark == quark_loop || quark == quark_ping_pong_loop))
{
g_scanner_get_next_token (scanner); /* eat quark identifier */
if (quark == quark_loop)
pwchunk->xinfos = bse_xinfos_add_value (pwchunk->xinfos, "loop-type", gsl_wave_loop_type_to_string (GSL_WAVE_LOOP_JUMP));
if (quark == quark_ping_pong_loop)
pwchunk->xinfos = bse_xinfos_add_value (pwchunk->xinfos, "loop-type", gsl_wave_loop_type_to_string (GSL_WAVE_LOOP_PINGPONG));
parse_or_return (scanner, G_TOKEN_INT);
pwchunk->xinfos = bse_xinfos_add_num (pwchunk->xinfos, "loop-count", scanner->value.v_int64);
parse_or_return (scanner, G_TOKEN_INT);
pwchunk->xinfos = bse_xinfos_add_num (pwchunk->xinfos, "loop-start", scanner->value.v_int64);
parse_or_return (scanner, G_TOKEN_INT);
pwchunk->xinfos = bse_xinfos_add_num (pwchunk->xinfos, "loop-end", scanner->value.v_int64);
}
else
return SFI_TOKEN_UNMATCHED;
return g_scanner_get_next_token (scanner) == ')' ? G_TOKEN_NONE : ')';
}
