static void ide_clang_service__get_build_flags_cb (GObject *object, GAsyncResult *result, gpointer user_data) { IdeBuildSystem *build_system = (IdeBuildSystem *)object; g_autoptr(GTask) task = user_data; ParseRequest *request; gchar **argv; GError *error = NULL; g_assert (IDE_IS_BUILD_SYSTEM (build_system)); g_assert (G_IS_TASK (task)); request = g_task_get_task_data (task); argv = ide_build_system_get_build_flags_finish (build_system, result, &error); if (!argv) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) g_message ("%s", error->message); g_clear_error (&error); argv = g_new0 (gchar*, 1); } request->command_line_args = argv; #ifdef IDE_ENABLE_TRACE { gchar *cflags; cflags = g_strjoinv (" ", argv); IDE_TRACE_MSG ("CFLAGS = %s", cflags); g_free (cflags); } #endif ide_thread_pool_push_task (IDE_THREAD_POOL_COMPILER, task, ide_clang_service_parse_worker); }
static void send_announcements (NMArpingManager *self, const char *mode_arg) { NMArpingManagerPrivate *priv = NM_ARPING_MANAGER_GET_PRIVATE (self); const char *argv[] = { NULL, mode_arg, "-q", "-I", NULL, "-c", "1", NULL, NULL }; int ip_arg = G_N_ELEMENTS (argv) - 2; GError *error = NULL; GHashTableIter iter; AddressInfo *info; argv[4] = nm_platform_link_get_name (NM_PLATFORM_GET, priv->ifindex); g_return_if_fail (argv[4]); argv[0] = nm_utils_find_helper ("arping", NULL, NULL); if (!argv[0]) { _LOGW ("arping could not be found; no ARPs will be sent"); return; } g_hash_table_iter_init (&iter, priv->addresses); while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &info)) { gs_free char *tmp_str = NULL; gboolean success; if (info->duplicate) continue; argv[ip_arg] = nm_utils_inet4_ntop (info->address, NULL); _LOGD ("run %s", (tmp_str = g_strjoinv (" ", (char **) argv))); success = g_spawn_async (NULL, (char **) argv, NULL, G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL, NULL, NULL, NULL, &error); if (!success) { _LOGW ("could not send ARP for address %s: %s", argv[ip_arg], error->message); g_clear_error (&error); } } }
static gboolean run_helper (char **argv, guint which, gpointer user_data, GError **error) { const char *helper_path; int exit_status = 0; gboolean success; char *errmsg = NULL, *outmsg = NULL; char *cmdline; helper_path = nm_utils_find_helper ((which == DCBTOOL) ? "dcbtool" : "fcoeadm", NULL, error); if (!helper_path) return FALSE; argv[0] = (char *) helper_path; cmdline = g_strjoinv (" ", argv); nm_log_dbg (LOGD_DCB, "%s", cmdline); success = g_spawn_sync ("/", argv, NULL, 0 /*G_SPAWN_DEFAULT*/, NULL, NULL, &outmsg, &errmsg, &exit_status, error); /* Log any stderr output */ if (success && WIFEXITED (exit_status) && WEXITSTATUS (exit_status) && (errmsg || outmsg)) { gboolean ignore_error = FALSE; /* Ignore fcoeadm "success" errors like when FCoE is already set up */ if (errmsg && strstr (errmsg, "Connection already created")) ignore_error = TRUE; if (ignore_error == FALSE) { nm_log_warn (LOGD_DCB, "'%s' failed: '%s'", cmdline, (errmsg && strlen (errmsg)) ? errmsg : outmsg); g_set_error (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_FAILED, "Failed to run '%s'", cmdline); success = FALSE; } } g_free (outmsg); g_free (errmsg); g_free (cmdline); return success; }
/** * oil_flags_to_string: * @flags: the flags, see #OilCPUFlagBits * * Get the string description of the @flags * * Returns: a newly created string description of the @flags */ gchar *oil_flags_to_string (guint flags) { gchar *flagv[OIL_FLAGBIT_NR + 1] = {0, }; gchar *content = "no flag"; gchar *ret; guint i, j; for (i = 0, j = 0; i < OIL_FLAGBIT_NR; i++) { if (flags & OIL_FLAG(i)) { flagv[j] = (gchar *) oil_cpu_flag_to_string (OIL_FLAG(i)); j++; } } if (j) content = g_strjoinv (", ", flagv); ret = g_strdup_printf ("[%s]", content); if (j) g_free (content); return ret; }
static gboolean write_config_file (GArray *array, GError **err) { GError *e = NULL; gchar *conf, *contents; g_assert (!err || !*err); if (!err) err = &e; conf = find_config_file (FALSE, err); if (conf == NULL) return FALSE; contents = g_strjoinv ("\n", (gchar**)(array->data)); bastile_util_write_file_private (conf, contents, err); g_free (contents); return *err ? FALSE : TRUE; }
static gchar * lbc_readfile(const gchar * filename) { gchar *buf; gchar **split; if (!g_file_get_contents(filename, &buf, NULL, NULL)) { #if DEBUG g_message("Failed to read \"%s\"\n", filename); #endif /* DEBUG */ return NULL; } split = g_strsplit(buf, "\\\\ ", 0); g_free(buf); buf = g_strjoinv("\\ ", split); g_strfreev(split); return buf; }
static void photos_application_launch_search (PhotosApplication *self, const gchar* const *terms, guint timestamp) { PhotosApplicationPrivate *priv = self->priv; GVariant *state; gchar *str; photos_application_create_window (self); photos_mode_controller_set_window_mode (priv->mode_cntrlr, PHOTOS_WINDOW_MODE_OVERVIEW); str = g_strjoinv (" ", (gchar **) terms); photos_search_controller_set_string (priv->state->srch_cntrlr, str); g_free (str); state = g_variant_new ("b", TRUE); g_action_group_change_action_state (G_ACTION_GROUP (self), "search", state); priv->activation_timestamp = timestamp; g_application_activate (G_APPLICATION (self)); }
int main(int argc, char **argv) { char *message; int result; gtk_init(&argc, &argv); if (argc > 1) { message = g_strjoinv(" ", argv + 1); } else { message = g_strdup("Enter your OpenSSH passphrase:"); } setvbuf(stdout, 0, _IONBF, 0); result = passphrase_dialog(message); g_free(message); return (result); }
static void pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, gpointer user_data) { gchar **vals, *search; gchar *query; sqlite3_stmt *stmt; PkInfoEnum ret; PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job); pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY); pk_backend_job_set_percentage(job, 0); g_variant_get(params, "(t^a&s)", NULL, &vals); search = g_strjoinv("%", vals); query = sqlite3_mprintf("SELECT (p.name || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, " "p.full_name FROM filelist AS f NATURAL JOIN pkglist AS p NATURAL JOIN repos AS r " "WHERE f.filename LIKE '%%%q%%' GROUP BY f.full_name", search); if ((sqlite3_prepare_v2(job_data->db, query, -1, &stmt, NULL) == SQLITE_OK)) { /* Now we're ready to output all packages */ while (sqlite3_step(stmt) == SQLITE_ROW) { ret = katja_pkg_is_installed((gchar *) sqlite3_column_text(stmt, 2)); if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING)) { pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED, (gchar *) sqlite3_column_text(stmt, 0), (gchar *) sqlite3_column_text(stmt, 1)); } else if (ret == PK_INFO_ENUM_INSTALLING) { pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE, (gchar *) sqlite3_column_text(stmt, 0), (gchar *) sqlite3_column_text(stmt, 1)); } } sqlite3_finalize(stmt); } else { pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db)); } sqlite3_free(query); g_free(search); pk_backend_job_set_percentage(job, 100); pk_backend_job_finished (job); }
void server_pool_entry_build_connection_string (ServerPoolEntry* entry, const gchar *username, const gchar *password, gchar **conn_string) { g_return_if_fail (IS_SERVER_POOL_ENTRY (entry)); gchar **conn_keywords, **conn_values; server_pool_entry_build_connection_params (entry, username, password, &conn_keywords, &conn_values); gchar **ptr = conn_keywords; int key_count = 0; while (*ptr++) key_count++; gchar **key_value_arr = (gchar**)g_malloc0 (sizeof (gchar**) * (key_count + 1) ); while (--key_count >= 0) { DEBG_MSG ("Key count is %d", key_count); key_value_arr [key_count] = g_strjoin ("=", conn_keywords[key_count], conn_values[key_count], NULL); } gchar *result = g_strjoinv (" ", key_value_arr); g_strfreev (conn_keywords); g_strfreev (conn_values); g_strfreev (key_value_arr); *conn_string = result; }
static void hilight_print(int index, HILIGHT_REC *rec) { char *chans, *levelstr; GString *options; options = g_string_new(NULL); if (!rec->nick || !rec->word) { if (rec->nick) g_string_append(options, "-nick "); if (rec->word) g_string_append(options, "-word "); } if (rec->nickmask) g_string_append(options, "-nickmask "); if (rec->fullword) g_string_append(options, "-fullword "); if (rec->regexp) { g_string_append(options, "-regexp "); #ifdef HAVE_REGEX_H if (!rec->regexp_compiled) g_string_append(options, "[INVALID!] "); #endif } if (rec->priority != 0) g_string_sprintfa(options, "-priority %d ", rec->priority); if (rec->color != NULL) g_string_sprintfa(options, "-color %s ", rec->color); if (rec->act_color != NULL) g_string_sprintfa(options, "-actcolor %s ", rec->act_color); chans = rec->channels == NULL ? NULL : g_strjoinv(",", rec->channels); levelstr = rec->level == 0 ? NULL : bits2level(rec->level); printformat(NULL, NULL, MSGLEVEL_CLIENTCRAP, TXT_HILIGHT_LINE, index, rec->text, chans != NULL ? chans : "", levelstr != NULL ? levelstr : "", options->str); g_free_not_null(chans); g_free_not_null(levelstr); g_string_free(options, TRUE); }
static GRegex * re_url (void) { static GRegex *url_ret; char *grist; char *scheme; if (url_ret) return url_ret; scheme = g_strjoinv ("|", prefix); grist = g_strdup_printf ( "(" /* URL or HOST */ "(" SCHEME HOST OPT_PORT "(" /* Optional "/path?query_string#fragment_id" */ "/" /* Must start with slash */ "(" "(" LPAR NOPARENS RPAR ")" "|" "(" NOPARENS ")" ")*" /* Zero or more occurrences of either of these */ "(?<![.,?!\\]])" /* Not allowed to end with these */ ")?" /* Zero or one of this /path?query_string#fragment_id thing */ ")|(" HOST OPT_PORT "/" "(" /* Optional "path?query_string#fragment_id" */ "(" "(" LPAR NOPARENS RPAR ")" "|" "(" NOPARENS ")" ")*" /* Zero or more occurrences of either of these */ "(?<![.,?!\\]])" /* Not allowed to end with these */ ")?" /* Zero or one of this /path?query_string#fragment_id thing */ ")" ")" , scheme ); url_ret = make_re (grist, "re_url"); g_free (scheme); return url_ret; }
/* Convert flags to string */ static char * ap_wpa_rsn_flags_to_string (guint32 flags) { char *flags_str[16]; /* Enough space for flags and terminating NULL */ char *ret_str; int i = 0; if (flags & NM_802_11_AP_SEC_PAIR_WEP40) flags_str[i++] = g_strdup ("pair_wpe40"); if (flags & NM_802_11_AP_SEC_PAIR_WEP104) flags_str[i++] = g_strdup ("pair_wpe104"); if (flags & NM_802_11_AP_SEC_PAIR_TKIP) flags_str[i++] = g_strdup ("pair_tkip"); if (flags & NM_802_11_AP_SEC_PAIR_CCMP) flags_str[i++] = g_strdup ("pair_ccmp"); if (flags & NM_802_11_AP_SEC_GROUP_WEP40) flags_str[i++] = g_strdup ("group_wpe40"); if (flags & NM_802_11_AP_SEC_GROUP_WEP104) flags_str[i++] = g_strdup ("group_wpe104"); if (flags & NM_802_11_AP_SEC_GROUP_TKIP) flags_str[i++] = g_strdup ("group_tkip"); if (flags & NM_802_11_AP_SEC_GROUP_CCMP) flags_str[i++] = g_strdup ("group_ccmp"); if (flags & NM_802_11_AP_SEC_KEY_MGMT_PSK) flags_str[i++] = g_strdup ("psk"); if (flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X) flags_str[i++] = g_strdup ("802.1X"); if (i == 0) flags_str[i++] = g_strdup ("none"); flags_str[i] = NULL; ret_str = g_strjoinv (" ", flags_str); i = 0; while (flags_str[i]) g_free (flags_str[i++]); return ret_str; }
static gchar* prefs_schedules_to_csvstr (Prefs *p) { gchar *s, *v[N_GROUPS + 1]; gint i; /* Return a newly allocated string of comma separated schedules. */ for (i = 0; i < N_GROUPS; i++) v[i] = g_strdup_printf ("%d", p->schedule[i]); v[N_GROUPS] = NULL; s = g_strjoinv (",", v); for (i = 0; i < N_GROUPS; i++) g_free (v[i]); return s; }
static gchar * extractable_check_id (GType type, const gchar * id) { gchar *ret, **strv = g_strsplit (id, "!", -1); if (g_strv_length (strv) != 2) { g_strfreev (strv); return NULL; } /* Remove any whitespace */ strv[0] = g_strstrip (strv[0]); strv[1] = g_strstrip (strv[1]); ret = g_strjoinv ("!", strv); g_strfreev (strv); return ret; }
static gboolean asb_package_alpm_ensure_license (AsbPackage *pkg, GError **error) { AsbPackageAlpm *pkg_alpm = ASB_PACKAGE_ALPM (pkg); AsbPackageAlpmPrivate *priv = GET_PRIVATE (pkg_alpm); alpm_list_t *alpm_licenses; GPtrArray *licenses; gchar *license; alpm_licenses = alpm_pkg_get_licenses (priv->package); licenses = asb_package_alpm_list_to_array (alpm_licenses); /* TODO: translate licenses to SPDX licenses (makes licenses clickable * is GNOME Software) */ license = g_strjoinv (" AND ", (gchar **)(licenses->pdata)); asb_package_set_license (pkg, license); g_ptr_array_free (licenses, TRUE); return TRUE; }
gchar* codeslayer_utils_strreplace (const gchar *string, const gchar *search, const gchar *replacement) { gchar *str, **arr; g_return_val_if_fail (string != NULL, NULL); g_return_val_if_fail (search != NULL, NULL); g_return_val_if_fail (replacement != NULL, NULL); arr = g_strsplit (string, search, -1); if (arr != NULL && arr[0] != NULL) str = g_strjoinv (replacement, arr); else str = g_strdup (string); g_strfreev (arr); return str; }
/* Clean up a scheme options string for use in a key/value file. * This function removes all full line comments, removes all blank * lines, and removes all leading/trailing white space. */ gchar *gnc_guile_strip_comments (const gchar *raw_text) { gchar *text, **splits; gint i, j; splits = g_strsplit(raw_text, "\n", -1); for (i = j = 0; splits[i]; i++) { if ((splits[i][0] == ';') || (splits[i][0] == '\0')) { g_free(splits[i]); continue; } splits[j++] = g_strstrip(splits[i]); } splits[j] = NULL; text = g_strjoinv(" ", splits); g_strfreev(splits); return text; }
gchar* dt_util_glist_to_str(const gchar* separator, GList * items, const unsigned int count) { if(count == 0) return NULL; gchar *result = NULL; // add the entries to an char* array items = g_list_first(items); gchar** strings = g_malloc(sizeof(gchar*) * (count+1)); if(items != NULL) { int i = 0; do { strings[i++] = items->data; } while((items=g_list_next(items)) != NULL); strings[i] = NULL; } // join them into a single string result = g_strjoinv(separator, strings); // free the GList and the array items = g_list_first(items); if(items != NULL) { do { g_free(items->data); } while((items=g_list_next(items)) != NULL); } g_list_free(items); if(strings != NULL) g_free(strings); return result; }
GError * oio_sqlx_client__execute_statement (struct oio_sqlx_client_s *self, const char *in_stmt, gchar **in_params, struct oio_sqlx_output_ctx_s *out_ctx, gchar ***out_lines) { GError *err = NULL; struct oio_sqlx_batch_s *batch = NULL; struct oio_sqlx_batch_result_s *result = NULL; GRID_TRACE("%s (%p, %s)", __FUNCTION__, self, in_stmt); (void) oio_sqlx_client_factory__batch (NULL, &batch); oio_sqlx_batch__add (batch, in_stmt, in_params); err = oio_sqlx_client__execute_batch (self, batch, &result); oio_sqlx_batch__destroy (batch); if (err) { g_assert (result == NULL); return err; } g_assert (result != NULL); guint count = oio_sqlx_batch_result__count_statements (result); g_assert (count == 1); guint count_lines = 0; err = oio_sqlx_batch_result__get_statement (result, 0, &count_lines, out_ctx); if (!err && out_lines) { GPtrArray *tmp = g_ptr_array_new (); for (guint i=0; i<count_lines ;++i) { gchar **fields = oio_sqlx_batch_result__get_row (result, 0, i); g_ptr_array_add (tmp, g_strjoinv (",", fields)); g_strfreev (fields); } g_ptr_array_add (tmp, NULL); *out_lines = (gchar**) g_ptr_array_free (tmp, FALSE); } oio_sqlx_batch_result__destroy (result); return err; }
void args_execute(int argc, char* argv[]) { GError* error = NULL; g_option_context_parse(context, &argc, &argv, &error); g_option_context_free(context); if (error != NULL) { g_error("option parsing failed: %s\n", error->message); } /* Change debug level */ if (verbose) { gboolean applied = g_setenv("G_MESSAGES_DEBUG", "all", TRUE); if (!applied) { g_error("Verbosity level could not be changed"); } } /* Use a default PPD file if not specified */ if (!definition) { definition = g_strdup_printf("/usr/share/cups/model/%s.ppd"); } if (!g_file_test(definition, G_FILE_TEST_EXISTS)) { g_error("PPD file could not be located: %s"); } /* Concatenate remaining argument as a single string to feed brprintconfig */ if (remaining != NULL) { commandline = g_strjoinv(" ", remaining); g_strfreev(remaining); } else { commandline = g_strdup("NULL COMMAND LINE"); } g_debug("Using printer model: %s", model); g_debug("Using PPD file: %s", definition); g_debug("Using brprintconf command line: %s", commandline); }
gchar* eh_render_command_str (const int argc, const char* argv[]) { gchar* str = NULL; eh_require( argv!=NULL ); if ( argv ) { gint i; gchar** str_array = NULL; for ( i=0 ; i<argc ; i++ ) eh_strv_append (&str_array, g_strdup (argv[i])); str = g_strjoinv( " " , str_array ); g_strfreev (str_array); } return str; }
static char *qemu_rbd_mon_host(QDict *options, Error **errp) { const char **vals = g_new(const char *, qdict_size(options) + 1); char keybuf[32]; const char *host, *port; char *rados_str; int i; for (i = 0;; i++) { sprintf(keybuf, "server.%d.host", i); host = qdict_get_try_str(options, keybuf); qdict_del(options, keybuf); sprintf(keybuf, "server.%d.port", i); port = qdict_get_try_str(options, keybuf); qdict_del(options, keybuf); if (!host && !port) { break; } if (!host) { error_setg(errp, "Parameter server.%d.host is missing", i); rados_str = NULL; goto out; } if (strchr(host, ':')) { vals[i] = port ? g_strdup_printf("[%s]:%s", host, port) : g_strdup_printf("[%s]", host); } else { vals[i] = port ? g_strdup_printf("%s:%s", host, port) : g_strdup(host); } } vals[i] = NULL; rados_str = i ? g_strjoinv(";", (char **)vals) : NULL; out: g_strfreev((char **)vals); return rados_str; }
// we already have the lock // remove the lock void write_cmdfile( cmddatas_t *cmddatas) { GPtrArray *lines = g_ptr_array_sized_new(100); char *buffer; // generate g_ptr_array_add(lines, g_strdup_printf("VERSION %d\n", cmddatas->version)); g_ptr_array_add(lines, g_strdup_printf("ID %d\n", cmddatas->max_id)); g_hash_table_foreach(cmddatas->cmdfile, &cmdfile_write, lines); g_ptr_array_add(lines, NULL); buffer = g_strjoinv(NULL, (gchar **)lines->pdata); g_ptr_array_free_full(lines); // write file_lock_write(cmddatas->lock, buffer, strlen(buffer)); g_free(buffer); // unlock file_lock_unlock(cmddatas->lock); }
int main(int argc, char **argv) { char *message; int result; gtk_init(&argc, &argv); gtk_window_set_default_icon_from_file ("/usr/share/pixmaps/ssh-askpass-gnome.png", NULL); if (argc > 1) { message = g_strjoinv(" ", argv + 1); } else { message = g_strdup("Enter your OpenSSH passphrase:"); } setvbuf(stdout, 0, _IONBF, 0); result = passphrase_dialog(message); g_free(message); return (result); }
static void irc_cmd_oper_hack( irc_t *irc, char **cmd ) { char *password = g_strjoinv( " ", cmd + 2 ); /* /OPER can now also be used to enter IM/identify passwords without echoing. It's a hack but the extra password security is worth it. */ if( irc->status & OPER_HACK_ACCOUNT_ADD ) { account_t *a; for( a = irc->b->accounts; a; a = a->next ) if( strcmp( a->pass, PASSWORD_PENDING ) == 0 ) { set_setstr( &a->set, "password", password ); irc_usermsg( irc, "Password added to IM account " "%s(%s)", a->prpl->name, a->user ); /* The IRC client may expect this. 491 suggests the OPER password was wrong, so the client won't expect a +o. It may however repeat the password prompt. We'll see. */ irc_send_num( irc, 491, ":Password added to IM account " "%s(%s)", a->prpl->name, a->user ); } } else if( irc->status & OPER_HACK_IDENTIFY ) { char *send_cmd[] = { "identify", password, NULL }; irc_send_num( irc, 491, ":Trying to identify" ); root_command( irc, send_cmd ); } else if( irc->status & OPER_HACK_REGISTER ) { char *send_cmd[] = { "register", password, NULL }; irc_send_num( irc, 491, ":Trying to identify" ); root_command( irc, send_cmd ); } irc->status &= ~OPER_HACK_ANY; g_free( password ); }
static void gst_avdtp_src_start_avrcp (GstAvdtpSrc * src) { gchar *path, **strv; int i; /* Strip out the /fdX in /org/bluez/dev_.../fdX */ strv = g_strsplit (src->conn.transport, "/", -1); for (i = 0; strv[i]; i++); g_return_if_fail (i > 0); g_free (strv[i - 1]); strv[i - 1] = NULL; path = g_strjoinv ("/", strv); g_strfreev (strv); src->avrcp = gst_avrcp_connection_new (path, avrcp_metadata_cb, src, NULL); g_free (path); }
/** Returns the gconf schema config source path, usually * "$prefix/etc/gconf/gconf.xml.defaults". * * @returns A newly allocated string. */ gchar *gnc_path_get_gconfdir(gboolean force_slashes) { gchar *sysconfdir = gnc_gbr_find_etc_dir (SYSCONFDIR); gchar *separator = G_DIR_SEPARATOR_S; gchar *result; if (force_slashes) { gchar **splitted; splitted = g_strsplit (sysconfdir, "\\", -1); g_free (sysconfdir); sysconfdir = g_strjoinv ("/", splitted); g_strfreev (splitted); separator = "/"; } result = g_build_path (separator, sysconfdir, "gconf", "gconf.xml.defaults", (gchar*)NULL); g_free (sysconfdir); //printf("Returning gconfdir %s\n", result); return result; }
static gchar * ui_manager_filter_ui (EUIManager *ui_manager, const gchar *ui_definition) { gchar **lines; gchar *filtered; gboolean express_mode; gboolean include = TRUE; gint ii; express_mode = e_ui_manager_get_express_mode (ui_manager); /* * Very simple C style pre-processing in-line in the XML: * #if [!]EXPRESS\n ... \n#endif\n */ lines = g_strsplit (ui_definition, "\n", -1); for (ii = 0; lines[ii] != NULL; ii++) { if (lines[ii][0] == '#') { if (!strncmp (lines[ii], "#if ", 4)) { gboolean not_express = lines[ii][4] == '!'; include = express_mode ^ not_express; lines[ii][0] = '\0'; } else if (!strncmp (lines[ii], "#endif", 6)) { lines[ii][0] = '\0'; include = TRUE; } } if (!include) lines[ii][0] = '\0'; } filtered = g_strjoinv ("\n", lines); g_strfreev (lines); return filtered; }
gint gmpv_mpv_obj_command(GmpvMpvObj *mpv, const gchar **cmd) { gint rc = MPV_ERROR_UNINITIALIZED; if(mpv->mpv_ctx) { rc = mpv_command(mpv->mpv_ctx, cmd); } if(rc < 0) { gchar *cmd_str = g_strjoinv(" ", (gchar **)cmd); g_warning( "Failed to run mpv command \"%s\". Reason: %s.", cmd_str, mpv_error_string(rc) ); g_free(cmd_str); } return rc; }