if (flags & G_APPLICATION_IS_SERVICE)
{
g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
- "Unable to acquire bus name `%s'", appid);
+ "Unable to acquire bus name '%s'", appid);
g_application_impl_destroy (impl);
return NULL;
' error = NULL;\n'
' if (!g_dbus_proxy_call_finish (proxy, res, &error))\n'
' {\n'
- ' g_warning ("Error setting property `%%s\' on interface %s: %%s (%%s, %%d)",\n'
+ ' g_warning ("Error setting property \'%%s\' on interface %s: %%s (%%s, %%d)",\n'
' info->parent_struct.name, \n'
' error->message, g_quark_to_string (error->domain), error->code);\n'
' g_error_free (error);\n'
}
g_variant_get (result, "(&s)", &xml_data);
- //g_printerr ("xml=`%s'", xml_data);
+ //g_printerr ("xml='%s'", xml_data);
error = NULL;
node = g_dbus_node_info_new_for_xml (xml_data, &error);
goto out;
}
- //g_printerr ("bar `%s'\n", path);
+ //g_printerr ("bar '%s'\n", path);
if (node->interfaces != NULL)
g_print ("%s \n", path);
{
gchar *s;
- //g_printerr ("foo `%s'\n", node->nodes[n].path);
+ //g_printerr ("foo '%s'\n", node->nodes[n].path);
if (g_strcmp0 (path, "/") == 0)
s = g_strdup_printf ("/%s", node->nodes[n]->path);
if (interface_info == NULL)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
- _("Warning: According to introspection data, interface `%s' does not exist\n"),
+ _("Warning: According to introspection data, interface '%s' does not exist\n"),
interface_name);
goto out;
}
if (method_info == NULL)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
- _("Warning: According to introspection data, method `%s' does not exist on interface `%s'\n"),
+ _("Warning: According to introspection data, method '%s' does not exist on interface '%s'\n"),
method_name,
interface_name);
goto out;
s = strrchr (opt_call_method, '.');
if (!request_completion && s == NULL)
{
- g_printerr (_("Error: Method name `%s' is invalid\n"), opt_call_method);
+ g_printerr (_("Error: Method name '%s' is invalid\n"), opt_call_method);
goto out;
}
method_name = g_strdup (s + 1);
if (type != NULL)
{
s = g_variant_type_dup_string (type);
- g_printerr (_("Error parsing parameter %d of type `%s': %s\n"),
+ g_printerr (_("Error parsing parameter %d of type '%s': %s\n"),
n,
s,
error->message);
g_variant_type_peek_string (type),
g_variant_type_get_string_length (type));
}
- g_printerr ("(According to introspection data, you need to pass `%s')\n", s->str);
+ g_printerr ("(According to introspection data, you need to pass '%s')\n", s->str);
g_string_free (s, TRUE);
}
goto out;
completion_debug ("completion_point=%d", completion_point);
completion_debug ("----");
completion_debug (" 0123456789012345678901234567890123456789012345678901234567890123456789");
- completion_debug ("`%s'", completion_line);
+ completion_debug ("'%s'", completion_line);
completion_debug (" %*s^",
completion_point, "");
completion_debug ("----");
}
}
#if 0
- completion_debug (" cur=`%s'", completion_cur);
- completion_debug ("prev=`%s'", completion_prev);
+ completion_debug (" cur='%s'", completion_cur);
+ completion_debug ("prev='%s'", completion_prev);
#endif
argc = completion_argc;
}
else
{
- g_printerr ("Unknown command `%s'\n", command);
+ g_printerr ("Unknown command '%s'\n", command);
usage (&argc, &argv, FALSE);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Unsupported key `%s' in address entry `%s'"),
+ _("Unsupported key '%s' in address entry '%s'"),
key,
address_entry);
goto out;
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Address `%s' is invalid (need exactly one of path, tmpdir or abstract keys)"),
+ _("Address '%s' is invalid (need exactly one of path, tmpdir or abstract keys)"),
address_entry);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Meaningless key/value pair combination in address entry `%s'"),
+ _("Meaningless key/value pair combination in address entry '%s'"),
address_entry);
out:
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Unsupported key `%s' in address entry `%s'"),
+ _("Unsupported key '%s' in address entry '%s'"),
key,
address_entry);
goto out;
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error in address `%s' - the port attribute is malformed"),
+ _("Error in address '%s' - the port attribute is malformed"),
address_entry);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error in address `%s' - the family attribute is malformed"),
+ _("Error in address '%s' - the family attribute is malformed"),
address_entry);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Unsupported key `%s' in address entry `%s'"),
+ _("Unsupported key '%s' in address entry '%s'"),
key,
address_entry);
goto out;
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error in address `%s' - the port attribute is malformed"),
+ _("Error in address '%s' - the port attribute is malformed"),
address_entry);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error in address `%s' - the family attribute is malformed"),
+ _("Error in address '%s' - the family attribute is malformed"),
address_entry);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Address element `%s' does not contain a colon (:)"),
+ _("Address element '%s' does not contain a colon (:)"),
address_entry);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Key/Value pair %d, `%s', in address element `%s' does not contain an equal sign"),
+ _("Key/Value pair %d, '%s', in address element '%s' does not contain an equal sign"),
n,
kv_pair,
address_entry);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error unescaping key or value in Key/Value pair %d, `%s', in address element `%s'"),
+ _("Error unescaping key or value in Key/Value pair %d, '%s', in address element '%s'"),
n,
kv_pair,
address_entry);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error in address `%s' - the unix transport requires exactly one of the "
- "keys `path' or `abstract' to be set"),
+ _("Error in address '%s' - the unix transport requires exactly one of the "
+ "keys 'path' or 'abstract' to be set"),
address_entry);
}
else if (path != NULL)
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error in address `%s' - the host attribute is missing or malformed"),
+ _("Error in address '%s' - the host attribute is missing or malformed"),
address_entry);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error in address `%s' - the port attribute is missing or malformed"),
+ _("Error in address '%s' - the port attribute is missing or malformed"),
address_entry);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error in address `%s' - the noncefile attribute is missing or malformed"),
+ _("Error in address '%s' - the noncefile attribute is missing or malformed"),
address_entry);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Unknown or unsupported transport `%s' for address `%s'"),
+ _("Unknown or unsupported transport '%s' for address '%s'"),
transport_name,
address_entry);
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error opening nonce file `%s': %s"),
+ _("Error opening nonce file '%s': %s"),
nonce_file,
g_strerror (errno));
g_object_unref (ret);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error reading from nonce file `%s': %s"),
+ _("Error reading from nonce file '%s': %s"),
nonce_file,
g_strerror (errno));
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error reading from nonce file `%s', expected 16 bytes, got %d"),
+ _("Error reading from nonce file '%s', expected 16 bytes, got %d"),
nonce_file,
(gint) num_bytes_read);
}
cancellable,
error))
{
- g_prefix_error (error, _("Error writing contents of nonce file `%s' to stream:"), nonce_file);
+ g_prefix_error (error, _("Error writing contents of nonce file '%s' to stream:"), nonce_file);
g_object_unref (ret);
ret = NULL;
goto out;
if (G_UNLIKELY (_g_dbus_debug_address ()))
{
_g_dbus_debug_print_lock ();
- g_print ("GDBus-debug:Address: Running `%s' to get bus address (possibly autolaunching)\n", command_line);
+ g_print ("GDBus-debug:Address: Running '%s' to get bus address (possibly autolaunching)\n", command_line);
old_dbus_verbose = g_strdup (g_getenv ("DBUS_VERBOSE"));
restore_dbus_verbose = TRUE;
g_setenv ("DBUS_VERBOSE", "1", TRUE);
if (!g_spawn_check_exit_status (exit_status, error))
{
- g_prefix_error (error, _("Error spawning command line `%s': "), command_line);
+ g_prefix_error (error, _("Error spawning command line '%s': "), command_line);
goto out;
}
{
gchar *ret;
#if defined (G_OS_UNIX) || defined(G_OS_WIN32)
- /* need to handle OS X in a different way since `dbus-launch --autolaunch' probably won't work there */
+ /* need to handle OS X in a different way since 'dbus-launch --autolaunch' probably won't work there */
ret = get_session_address_dbus_launch (error);
#else
/* TODO: implement for OS X */
{
guint n;
_g_dbus_debug_print_lock ();
- g_print ("GDBus-debug:Address: In g_dbus_address_get_for_bus_sync() for bus type `%s'\n",
+ g_print ("GDBus-debug:Address: In g_dbus_address_get_for_bus_sync() for bus type '%s'\n",
_g_dbus_enum_to_string (G_TYPE_BUS_TYPE, bus_type));
for (n = 0; n < 3; n++)
{
v = g_getenv (k);
g_print ("GDBus-debug:Address: env var %s", k);
if (v != NULL)
- g_print ("=`%s'\n", v);
+ g_print ("='%s'\n", v);
else
g_print (" is not set\n");
}
G_IO_ERROR,
G_IO_ERROR_FAILED,
_("Cannot determine bus address from DBUS_STARTER_BUS_TYPE environment variable"
- " - unknown value `%s'"),
+ " - unknown value '%s'"),
starter_bus);
}
else
_g_dbus_debug_print_lock ();
if (ret != NULL)
{
- g_print ("GDBus-debug:Address: Returning address `%s' for bus type `%s'\n",
+ g_print ("GDBus-debug:Address: Returning address '%s' for bus type '%s'\n",
ret,
_g_dbus_enum_to_string (G_TYPE_BUS_TYPE, bus_type));
}
else
{
- g_print ("GDBus-debug:Address: Cannot look-up address bus type `%s': %s\n",
+ g_print ("GDBus-debug:Address: Cannot look-up address bus type '%s': %s\n",
_g_dbus_enum_to_string (G_TYPE_BUS_TYPE, bus_type),
local_error ? local_error->message : "");
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- "Error hexdecoding string `%s' around position %d",
+ "Error hexdecoding string '%s' around position %d",
str, n);
goto out;
}
"stream", auth->priv->stream,
"credentials", credentials_that_were_sent,
NULL);
- debug_print ("CLIENT: Trying mechanism `%s'", _g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype));
+ debug_print ("CLIENT: Trying mechanism '%s'", _g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype));
g_ptr_array_add (attempted_auth_mechs, (gpointer) _g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype));
/* the auth mechanism may not be supported
*/
if (!_g_dbus_auth_mechanism_is_supported (mech))
{
- debug_print ("CLIENT: Mechanism `%s' says it is not supported", _g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype));
+ debug_print ("CLIENT: Mechanism '%s' says it is not supported", _g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype));
g_object_unref (mech);
mech = NULL;
goto again;
initial_response = _g_dbus_auth_mechanism_client_initiate (mech,
&initial_response_len);
#if 0
- g_printerr ("using auth mechanism with name `%s' of type `%s' with initial response `%s'\n",
+ g_printerr ("using auth mechanism with name '%s' of type '%s' with initial response '%s'\n",
_g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype),
g_type_name (G_TYPE_FROM_INSTANCE (mech)),
initial_response);
#endif
if (initial_response != NULL)
{
- //g_printerr ("initial_response = `%s'\n", initial_response);
+ //g_printerr ("initial_response = '%s'\n", initial_response);
encoded = hexencode (initial_response);
s = g_strdup_printf ("AUTH %s %s\r\n",
_g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype),
{
s = g_strdup_printf ("AUTH %s\r\n", _g_dbus_auth_mechanism_get_name (auth_mech_to_use_gtype));
}
- debug_print ("CLIENT: writing `%s'", s);
+ debug_print ("CLIENT: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_object_unref (mech);
if (G_UNLIKELY (_g_dbus_debug_authentication ()))
{
s = g_credentials_to_string (credentials);
- debug_print ("CLIENT: sent credentials `%s'", s);
+ debug_print ("CLIENT: sent credentials '%s'", s);
g_free (s);
}
}
/* Get list of supported authentication mechanisms */
s = "AUTH\r\n";
- debug_print ("CLIENT: writing `%s'", s);
+ debug_print ("CLIENT: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
state = CLIENT_STATE_WAITING_FOR_REJECT;
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- "In WaitingForReject: Expected `REJECTED am1 am2 ... amN', got `%s'",
+ "In WaitingForReject: Expected 'REJECTED am1 am2 ... amN', got '%s'",
line);
g_free (line);
goto out;
supported_auth_mechs = g_strsplit (line + sizeof ("REJECTED ") - 1, " ", 0);
#if 0
for (n = 0; supported_auth_mechs != NULL && supported_auth_mechs[n] != NULL; n++)
- g_printerr ("supported_auth_mechs[%d] = `%s'\n", n, supported_auth_mechs[n]);
+ g_printerr ("supported_auth_mechs[%d] = '%s'\n", n, supported_auth_mechs[n]);
#endif
}
g_free (line);
line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
if (line == NULL)
goto out;
- debug_print ("CLIENT: WaitingForOK, read `%s'", line);
+ debug_print ("CLIENT: WaitingForOK, read '%s'", line);
if (g_str_has_prefix (line, "OK "))
{
if (!g_dbus_is_guid (line + 3))
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- "Invalid OK response `%s'",
+ "Invalid OK response '%s'",
line);
g_free (line);
goto out;
if (offered_capabilities & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING)
{
s = "NEGOTIATE_UNIX_FD\r\n";
- debug_print ("CLIENT: writing `%s'", s);
+ debug_print ("CLIENT: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
state = CLIENT_STATE_WAITING_FOR_AGREE_UNIX_FD;
else
{
s = "BEGIN\r\n";
- debug_print ("CLIENT: writing `%s'", s);
+ debug_print ("CLIENT: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
/* and we're done! */
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- "In WaitingForOk: unexpected response `%s'",
+ "In WaitingForOk: unexpected response '%s'",
line);
g_free (line);
goto out;
line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
if (line == NULL)
goto out;
- debug_print ("CLIENT: WaitingForAgreeUnixFD, read=`%s'", line);
+ debug_print ("CLIENT: WaitingForAgreeUnixFD, read='%s'", line);
if (g_strcmp0 (line, "AGREE_UNIX_FD") == 0)
{
g_free (line);
negotiated_capabilities |= G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING;
s = "BEGIN\r\n";
- debug_print ("CLIENT: writing `%s'", s);
+ debug_print ("CLIENT: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
/* and we're done! */
}
else if (g_str_has_prefix (line, "ERROR") && (line[5] == 0 || g_ascii_isspace (line[5])))
{
- //g_strstrip (line + 5); g_debug ("bah, no unix_fd: `%s'", line + 5);
+ //g_strstrip (line + 5); g_debug ("bah, no unix_fd: '%s'", line + 5);
g_free (line);
s = "BEGIN\r\n";
- debug_print ("CLIENT: writing `%s'", s);
+ debug_print ("CLIENT: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
/* and we're done! */
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- "In WaitingForAgreeUnixFd: unexpected response `%s'",
+ "In WaitingForAgreeUnixFd: unexpected response '%s'",
line);
g_free (line);
goto out;
line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
if (line == NULL)
goto out;
- debug_print ("CLIENT: WaitingForData, read=`%s'", line);
+ debug_print ("CLIENT: WaitingForData, read='%s'", line);
if (g_str_has_prefix (line, "DATA "))
{
gchar *encoded;
s = g_strdup_printf ("DATA %s\r\n", encoded_data);
g_free (encoded_data);
g_free (data);
- debug_print ("CLIENT: writing `%s'", s);
+ debug_print ("CLIENT: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_free (s);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- "In WaitingForData: unexpected response `%s'",
+ "In WaitingForData: unexpected response '%s'",
line);
g_free (line);
goto out;
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- "The given guid `%s' is not valid",
+ "The given guid '%s' is not valid",
guid);
goto out;
}
if (G_UNLIKELY (_g_dbus_debug_authentication ()))
{
s = g_credentials_to_string (credentials);
- debug_print ("SERVER: received credentials `%s'", s);
+ debug_print ("SERVER: received credentials '%s'", s);
g_free (s);
}
}
case SERVER_STATE_WAITING_FOR_AUTH:
debug_print ("SERVER: WaitingForAuth");
line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
- debug_print ("SERVER: WaitingForAuth, read `%s'", line);
+ debug_print ("SERVER: WaitingForAuth, read '%s'", line);
if (line == NULL)
goto out;
if (g_strcmp0 (line, "AUTH") == 0)
{
s = get_auth_mechanisms (auth, allow_anonymous, "REJECTED ", "\r\n", " ");
- debug_print ("SERVER: writing `%s'", s);
+ debug_print ("SERVER: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_free (s);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- "Unexpected line `%s' while in WaitingForAuth state",
+ "Unexpected line '%s' while in WaitingForAuth state",
line);
g_strfreev (tokens);
goto out;
}
/* TODO: record that the client has attempted to use this mechanism */
- //g_debug ("client is trying `%s'", mech_name);
+ //g_debug ("client is trying '%s'", mech_name);
auth_mech_to_use_gtype = find_mech_by_name (auth, mech_name);
if ((auth_mech_to_use_gtype == (GType) 0) ||
/* We don't support this auth mechanism */
g_strfreev (tokens);
s = get_auth_mechanisms (auth, allow_anonymous, "REJECTED ", "\r\n", " ");
- debug_print ("SERVER: writing `%s'", s);
+ debug_print ("SERVER: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_free (s);
else
{
s = g_strdup_printf ("OK %s\r\n", guid);
- debug_print ("SERVER: writing `%s'", s);
+ debug_print ("SERVER: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_free (s);
case G_DBUS_AUTH_MECHANISM_STATE_REJECTED:
s = get_auth_mechanisms (auth, allow_anonymous, "REJECTED ", "\r\n", " ");
- debug_print ("SERVER: writing `%s'", s);
+ debug_print ("SERVER: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_free (s);
s = g_strdup_printf ("DATA %s\r\n", encoded_data);
g_free (encoded_data);
g_free (data);
- debug_print ("SERVER: writing `%s'", s);
+ debug_print ("SERVER: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
{
g_free (s);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- "Unexpected line `%s' while in WaitingForAuth state",
+ "Unexpected line '%s' while in WaitingForAuth state",
line);
g_free (line);
goto out;
case SERVER_STATE_WAITING_FOR_DATA:
debug_print ("SERVER: WaitingForData");
line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error);
- debug_print ("SERVER: WaitingForData, read `%s'", line);
+ debug_print ("SERVER: WaitingForData, read '%s'", line);
if (line == NULL)
goto out;
if (g_str_has_prefix (line, "DATA "))
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- "Unexpected line `%s' while in WaitingForData state",
+ "Unexpected line '%s' while in WaitingForData state",
line);
g_free (line);
}
&line_length,
cancellable,
error);
- debug_print ("SERVER: WaitingForBegin, read `%s'", line);
+ debug_print ("SERVER: WaitingForBegin, read '%s'", line);
if (line == NULL)
goto out;
if (g_strcmp0 (line, "BEGIN") == 0)
{
negotiated_capabilities |= G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING;
s = "AGREE_UNIX_FD\r\n";
- debug_print ("SERVER: writing `%s'", s);
+ debug_print ("SERVER: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
}
else
{
s = "ERROR \"fd passing not offered\"\r\n";
- debug_print ("SERVER: writing `%s'", s);
+ debug_print ("SERVER: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
}
}
else
{
- g_debug ("Unexpected line `%s' while in WaitingForBegin state", line);
+ g_debug ("Unexpected line '%s' while in WaitingForBegin state", line);
g_free (line);
s = "ERROR \"Unknown Command\"\r\n";
- debug_print ("SERVER: writing `%s'", s);
+ debug_print ("SERVER: writing '%s'", s);
if (!g_data_output_stream_put_string (dos, s, cancellable, error))
goto out;
}
g_return_if_fail (G_IS_DBUS_AUTH_MECHANISM_ANON (mechanism));
g_return_if_fail (!m->priv->is_server && !m->priv->is_client);
- //g_debug ("ANONYMOUS: initial_response was `%s'", initial_response);
+ //g_debug ("ANONYMOUS: initial_response was '%s'", initial_response);
m->priv->is_server = TRUE;
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_ACCEPTED;
g_set_error (error,
G_IO_ERROR,
g_io_error_from_errno (errno),
- _("Error when getting information for directory `%s': %s"),
+ _("Error when getting information for directory '%s': %s"),
path,
strerror (errno));
g_free (path);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- _("Permissions on directory `%s' are malformed. Expected mode 0700, got 0%o"),
+ _("Permissions on directory '%s' are malformed. Expected mode 0700, got 0%o"),
path,
statbuf.st_mode & 0777);
g_free (path);
g_set_error (error,
G_IO_ERROR,
g_io_error_from_errno (errno),
- _("Error creating directory `%s': %s"),
+ _("Error creating directory '%s': %s"),
path,
strerror (errno));
g_free (path);
error))
{
g_prefix_error (error,
- _("Error opening keyring `%s' for reading: "),
+ _("Error opening keyring '%s' for reading: "),
path);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- _("Line %d of the keyring at `%s' with content `%s' is malformed"),
+ _("Line %d of the keyring at '%s' with content '%s' is malformed"),
n + 1,
path,
line);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- _("First token of line %d of the keyring at `%s' with content `%s' is malformed"),
+ _("First token of line %d of the keyring at '%s' with content '%s' is malformed"),
n + 1,
path,
line);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- _("Second token of line %d of the keyring at `%s' with content `%s' is malformed"),
+ _("Second token of line %d of the keyring at '%s' with content '%s' is malformed"),
n + 1,
path,
line);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- _("Didn't find cookie with id %d in the keyring at `%s'"),
+ _("Didn't find cookie with id %d in the keyring at '%s'"),
cookie_id,
path);
g_set_error (error,
G_IO_ERROR,
g_io_error_from_errno (errno),
- _("Error deleting stale lock file `%s': %s"),
+ _("Error deleting stale lock file '%s': %s"),
lock,
strerror (errno));
goto out;
}
- _log ("Deleted stale lock file `%s'", lock);
+ _log ("Deleted stale lock file '%s'", lock);
break;
}
}
g_set_error (error,
G_IO_ERROR,
g_io_error_from_errno (errno),
- _("Error creating lock file `%s': %s"),
+ _("Error creating lock file '%s': %s"),
lock,
strerror (errno));
goto out;
g_set_error (error,
G_IO_ERROR,
g_io_error_from_errno (errno),
- _("Error closing (unlinked) lock file `%s': %s"),
+ _("Error closing (unlinked) lock file '%s': %s"),
lock,
strerror (errno));
goto out;
g_set_error (error,
G_IO_ERROR,
g_io_error_from_errno (errno),
- _("Error unlinking lock file `%s': %s"),
+ _("Error unlinking lock file '%s': %s"),
lock,
strerror (errno));
goto out;
{
g_propagate_prefixed_error (error,
local_error,
- _("Error opening keyring `%s' for writing: "),
+ _("Error opening keyring '%s' for writing: "),
path);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- _("Line %d of the keyring at `%s' with content `%s' is malformed"),
+ _("Line %d of the keyring at '%s' with content '%s' is malformed"),
n + 1,
path,
line);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- _("First token of line %d of the keyring at `%s' with content `%s' is malformed"),
+ _("First token of line %d of the keyring at '%s' with content '%s' is malformed"),
n + 1,
path,
line);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
- _("Second token of line %d of the keyring at `%s' with content `%s' is malformed"),
+ _("Second token of line %d of the keyring at '%s' with content '%s' is malformed"),
n + 1,
path,
line);
else
{
g_prefix_error (error,
- _("(Additionally, releasing the lock for `%s' also failed: %s) "),
+ _("(Additionally, releasing the lock for '%s' also failed: %s) "),
path,
local_error->message);
}
tokens = g_strsplit (data, " ", 0);
if (g_strv_length (tokens) != 2)
{
- g_warning ("Malformed data `%s'", data);
+ g_warning ("Malformed data '%s'", data);
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_REJECTED;
goto out;
}
tokens = g_strsplit (data, " ", 0);
if (g_strv_length (tokens) != 3)
{
- g_warning ("Malformed data `%s'", data);
+ g_warning ("Malformed data '%s'", data);
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_REJECTED;
goto out;
}
cookie_id = g_ascii_strtoll (tokens[1], &endp, 10);
if (*endp != '\0')
{
- g_warning ("Malformed cookie_id `%s'", tokens[1]);
+ g_warning ("Malformed cookie_id '%s'", tokens[1]);
m->priv->state = G_DBUS_AUTH_MECHANISM_STATE_REJECTED;
goto out;
}
if (G_UNLIKELY (G_TRYLOCK(name))) \
{ \
g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
- "_G_ENSURE_LOCK: Lock `" #name "' is not locked"); \
+ "_G_ENSURE_LOCK: Lock '" #name "' is not locked"); \
} \
} while (FALSE) \
g_variant_get (hello_result, "(s)", &connection->bus_unique_name);
g_variant_unref (hello_result);
- //g_debug ("unique name is `%s'", connection->bus_unique_name);
+ //g_debug ("unique name is '%s'", connection->bus_unique_name);
}
ret = TRUE;
#if 0
g_print ("In schedule_callbacks:\n"
- " sender = `%s'\n"
- " interface = `%s'\n"
- " member = `%s'\n"
- " path = `%s'\n"
- " arg0 = `%s'\n",
+ " sender = '%s'\n"
+ " interface = '%s'\n"
+ " member = '%s'\n"
+ " path = '%s'\n"
+ " arg0 = '%s'\n",
sender,
interface,
member,
{
reply = g_dbus_message_new_method_error (data->message,
"org.freedesktop.DBus.Error.UnknownMethod",
- _("No such interface `org.freedesktop.DBus.Properties' on object at path %s"),
+ _("No such interface 'org.freedesktop.DBus.Properties' on object at path %s"),
g_dbus_message_get_path (data->message));
g_dbus_connection_send_message (data->connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
g_object_unref (reply);
{
reply = g_dbus_message_new_method_error (data->message,
"org.freedesktop.DBus.Error.InvalidArgs",
- _("Error setting property `%s': Expected type `%s' but got `%s'"),
+ _("Error setting property '%s': Expected type '%s' but got '%s'"),
data->property_info->name,
data->property_info->signature,
g_variant_get_type_string (value));
{
reply = g_dbus_message_new_method_error (message,
"org.freedesktop.DBus.Error.InvalidArgs",
- _("No such property `%s'"),
+ _("No such property '%s'"),
property_name);
g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
g_object_unref (reply);
{
reply = g_dbus_message_new_method_error (message,
"org.freedesktop.DBus.Error.InvalidArgs",
- _("Property `%s' is not readable"),
+ _("Property '%s' is not readable"),
property_name);
g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
g_object_unref (reply);
{
reply = g_dbus_message_new_method_error (message,
"org.freedesktop.DBus.Error.InvalidArgs",
- _("Property `%s' is not writable"),
+ _("Property '%s' is not writable"),
property_name);
g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
g_object_unref (reply);
GDBusMessage *reply;
reply = g_dbus_message_new_method_error (message,
"org.freedesktop.DBus.Error.InvalidArgs",
- _("No such interface `%s'"),
+ _("No such interface '%s'"),
interface_name);
g_dbus_connection_send_message_unlocked (eo->connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
g_object_unref (reply);
{
reply = g_dbus_message_new_method_error (data->message,
"org.freedesktop.DBus.Error.UnknownMethod",
- _("No such interface `org.freedesktop.DBus.Properties' on object at path %s"),
+ _("No such interface 'org.freedesktop.DBus.Properties' on object at path %s"),
g_dbus_message_get_path (data->message));
g_dbus_connection_send_message (data->connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
g_object_unref (reply);
GDBusMessage *reply;
reply = g_dbus_message_new_method_error (g_dbus_method_invocation_get_message (invocation),
"org.freedesktop.DBus.Error.UnknownMethod",
- _("No such interface `%s' on object at path %s"),
+ _("No such interface '%s' on object at path %s"),
g_dbus_method_invocation_get_interface_name (invocation),
g_dbus_method_invocation_get_object_path (invocation));
g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
{
reply = g_dbus_message_new_method_error (message,
"org.freedesktop.DBus.Error.UnknownMethod",
- _("No such method `%s'"),
+ _("No such method '%s'"),
g_dbus_message_get_member (message));
g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
g_object_unref (reply);
reply = g_dbus_message_new_method_error (message,
"org.freedesktop.DBus.Error.InvalidArgs",
- _("Type of message, `%s', does not match expected type `%s'"),
+ _("Type of message, '%s', does not match expected type '%s'"),
g_variant_get_type_string (parameters),
type_string);
g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Method `%s' returned type `%s', but expected `%s'"),
+ _("Method '%s' returned type '%s', but expected '%s'"),
method_name, g_variant_get_type_string (result), type_string);
g_variant_unref (result);
GDBusMessage *reply;
reply = g_dbus_message_new_method_error (message,
"org.freedesktop.DBus.Error.InvalidArgs",
- _("No such interface `%s'"),
+ _("No such interface '%s'"),
interface_name);
g_dbus_connection_send_message (es->connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
g_object_unref (reply);
GDBusMessage *reply;
reply = g_dbus_message_new_method_error (data->message,
"org.freedesktop.DBus.Error.UnknownMethod",
- _("Method `%s' on interface `%s' with signature `%s' does not exist"),
+ _("Method '%s' on interface '%s' with signature '%s' does not exist"),
g_dbus_message_get_member (data->message),
g_dbus_message_get_interface (data->message),
g_dbus_message_get_signature (data->message));
/* if we end up here, the message has not been not handled - so return an error saying this */
reply = g_dbus_message_new_method_error (message,
"org.freedesktop.DBus.Error.UnknownMethod",
- _("No such interface `%s' on object at path %s"),
+ _("No such interface '%s' on object at path %s"),
interface_name,
object_path);
g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Cannot determine bus address from DBUS_STARTER_BUS_TYPE environment variable"
- " - unknown value `%s'"),
+ " - unknown value '%s'"),
starter_bus);
}
else
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Expected NUL byte after the string `%s' but found byte %d"),
+ _("Expected NUL byte after the string '%s' but found byte %d"),
str, mbuf->data[mbuf->pos + len]);
g_free (str);
mbuf->pos += len + 1;
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Expected valid UTF-8 string but found invalid bytes at byte offset %d (length of string is %d). "
- "The valid UTF-8 string up until that point was `%s'"),
+ "The valid UTF-8 string up until that point was '%s'"),
offset,
(gint) len,
valid_str);
g_set_error (&local_error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Parsed value `%s' is not a valid D-Bus object path"),
+ _("Parsed value '%s' is not a valid D-Bus object path"),
v);
goto fail;
}
g_set_error (&local_error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Parsed value `%s' is not a valid D-Bus signature"),
+ _("Parsed value '%s' is not a valid D-Bus signature"),
v);
goto fail;
}
g_set_error (&local_error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Parsed value `%s' for variant is not a valid D-Bus signature"),
+ _("Parsed value '%s' for variant is not a valid D-Bus signature"),
sig);
goto fail;
}
g_set_error (&local_error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error deserializing GVariant with type string `%s' from the D-Bus wire format"),
+ _("Error deserializing GVariant with type string '%s' from the D-Bus wire format"),
s);
g_free (s);
goto fail;
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Signature header with signature `%s' found but message body is empty"),
+ _("Signature header with signature '%s' found but message body is empty"),
signature_str);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Parsed value `%s' is not a valid D-Bus signature (for body)"),
+ _("Parsed value '%s' is not a valid D-Bus signature (for body)"),
signature_str);
goto out;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Error serializing GVariant with type string `%s' to the D-Bus wire format"),
+ _("Error serializing GVariant with type string '%s' to the D-Bus wire format"),
g_variant_get_type_string (value));
goto fail;
}
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Message body has signature `%s' but there is no signature header"),
+ _("Message body has signature '%s' but there is no signature header"),
signature_str);
g_free (tupled_signature_str);
goto out;
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Message body has type signature `%s' but signature in the header field is `%s'"),
+ _("Message body has type signature '%s' but signature in the header field is '%s'"),
tupled_signature_str, g_variant_get_type_string (message->body));
g_free (tupled_signature_str);
goto out;
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Message body is empty but signature in the header field is `(%s)'"),
+ _("Message body is empty but signature in the header field is '(%s)'"),
signature_str);
goto out;
}
g_dbus_error_set_dbus_error (error,
error_name,
"",
- _("Error return with body of type `%s'"),
+ _("Error return with body of type '%s'"),
g_variant_get_type_string (body));
}
else
{
gchar *type_string = g_variant_type_dup_string (type);
- g_warning ("Type of return value is incorrect: expected `%s', got `%s''",
+ g_warning ("Type of return value is incorrect: expected '%s', got '%s''",
type_string, g_variant_get_type_string (parameters));
g_variant_type_free (type);
g_free (type_string);
g_print ("========================================================================\n"
"GDBus-debug:Return:\n"
" >>>> METHOD ERROR %s\n"
- " message `%s'\n"
+ " message '%s'\n"
" in response to %s.%s()\n"
" on object %s\n"
" to name %s\n"
if (!g_variant_is_of_type (value, G_VARIANT_TYPE ("(v)")))
{
- g_warning ("Expected type `(v)' for Get() reply, got `%s'", g_variant_get_type_string (value));
+ g_warning ("Expected type '(v)' for Get() reply, got '%s'", g_variant_get_type_string (value));
goto out;
}
if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(sa{sv}as)")))
{
- g_warning ("Value for PropertiesChanged signal with type `%s' does not match `(sa{sv}as)'",
+ g_warning ("Value for PropertiesChanged signal with type '%s' does not match '(sa{sv}as)'",
g_variant_get_type_string (parameters));
G_UNLOCK (properties_lock);
goto out;
if (!g_variant_is_of_type (result, G_VARIANT_TYPE ("(a{sv})")))
{
- g_warning ("Value for GetAll reply with type `%s' does not match `(a{sv})'",
+ g_warning ("Value for GetAll reply with type '%s' does not match '(a{sv})'",
g_variant_get_type_string (result));
goto out;
}
g_set_error (error,
G_IO_ERROR,
g_io_error_from_errno (errno),
- _("Error writing nonce file at `%s': %s"),
+ _("Error writing nonce file at '%s': %s"),
server->nonce_file,
strerror (errno));
goto out;
g_set_error (&last_error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("The string `%s' is not a valid D-Bus GUID"),
+ _("The string '%s' is not a valid D-Bus GUID"),
server->guid);
goto out;
}
g_set_error (&this_error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- _("Cannot listen on unsupported transport `%s'"),
+ _("Cannot listen on unsupported transport '%s'"),
transport_name);
g_free (transport_name);
if (!iface->serialize)
{
- g_critical ("g_icon_serialize() on icon type `%s' is not implemented", G_OBJECT_TYPE_NAME (icon));
+ g_critical ("g_icon_serialize() on icon type '%s' is not implemented", G_OBJECT_TYPE_NAME (icon));
return NULL;
}
if (!g_variant_is_of_type (result, G_VARIANT_TYPE ("(sv)")))
{
- g_critical ("g_icon_serialize() on icon type `%s' returned GVariant of type `%s' but it must return "
- "one with type `(sv)'", G_OBJECT_TYPE_NAME (icon), g_variant_get_type_string (result));
+ g_critical ("g_icon_serialize() on icon type '%s' returned GVariant of type '%s' but it must return "
+ "one with type '(sv)'", G_OBJECT_TYPE_NAME (icon), g_variant_get_type_string (result));
g_variant_unref (result);
result = NULL;
}
if (state == NULL)
{
- fprintf (stderr, _("No such key `%s' in schema `%s' as "
- "specified in override file `%s'"),
+ fprintf (stderr, _("No such key '%s' in schema '%s' as "
+ "specified in override file '%s'"),
key, group, filename);
if (!strict)
if (value == NULL)
{
- fprintf (stderr, _("error parsing key `%s' in schema `%s' "
- "as specified in override file `%s': "
+ fprintf (stderr, _("error parsing key '%s' in schema '%s' "
+ "as specified in override file '%s': "
"%s."),
key, group, filename, error->message);
g_variant_compare (value, state->maximum) > 0)
{
fprintf (stderr,
- _("override for key `%s' in schema `%s' in "
- "override file `%s' is outside the range "
+ _("override for key '%s' in schema '%s' in "
+ "override file '%s' is outside the range "
"given in the schema"),
key, group, filename);
if (!is_valid_choices (value, state->strinfo))
{
fprintf (stderr,
- _("override for key `%s' in schema `%s' in "
- "override file `%s' is not in the list "
+ _("override for key '%s' in schema '%s' in "
+ "override file '%s' is not in the list "
"of valid choices"),
key, group, filename);
if (!skey.is_enum)
{
- g_critical ("g_settings_get_enum() called on key `%s' which is not "
+ g_critical ("g_settings_get_enum() called on key '%s' which is not "
"associated with an enumerated type", skey.name);
g_settings_schema_key_clear (&skey);
return -1;
if (!skey.is_enum)
{
- g_critical ("g_settings_set_enum() called on key `%s' which is not "
+ g_critical ("g_settings_set_enum() called on key '%s' which is not "
"associated with an enumerated type", skey.name);
return FALSE;
}
if (!(variant = g_settings_schema_key_from_enum (&skey, value)))
{
- g_critical ("g_settings_set_enum(): invalid enum value %d for key `%s' "
- "in schema `%s'. Doing nothing.", value, skey.name,
+ g_critical ("g_settings_set_enum(): invalid enum value %d for key '%s' "
+ "in schema '%s'. Doing nothing.", value, skey.name,
g_settings_schema_get_id (skey.schema));
g_settings_schema_key_clear (&skey);
return FALSE;
if (!skey.is_flags)
{
- g_critical ("g_settings_get_flags() called on key `%s' which is not "
+ g_critical ("g_settings_get_flags() called on key '%s' which is not "
"associated with a flags type", skey.name);
g_settings_schema_key_clear (&skey);
return -1;
if (!skey.is_flags)
{
- g_critical ("g_settings_set_flags() called on key `%s' which is not "
+ g_critical ("g_settings_set_flags() called on key '%s' which is not "
"associated with a flags type", skey.name);
return FALSE;
}
if (!(variant = g_settings_schema_key_from_flags (&skey, value)))
{
g_critical ("g_settings_set_flags(): invalid flags value 0x%08x "
- "for key `%s' in schema `%s'. Doing nothing.",
+ "for key '%s' in schema '%s'. Doing nothing.",
value, skey.name, g_settings_schema_get_id (skey.schema));
g_settings_schema_key_clear (&skey);
return FALSE;
if (!mapping (NULL, &result, user_data))
g_error ("The mapping function given to g_settings_get_mapped() for key "
- "`%s' in schema `%s' returned FALSE when given a NULL value.",
+ "'%s' in schema '%s' returned FALSE when given a NULL value.",
key, g_settings_schema_get_id (settings->priv->schema));
okay:
!binding->get_mapping (&value, variant, binding->user_data))
{
/* flag translation errors with a warning */
- g_warning ("Translated default `%s' for key `%s' in schema `%s' "
+ g_warning ("Translated default '%s' for key '%s' in schema '%s' "
"was rejected by the binding mapping function",
binding->key.unparsed, binding->key.name,
g_settings_schema_get_id (binding->key.schema));
{
variant = g_variant_ref (binding->key.default_value);
if (!binding->get_mapping (&value, variant, binding->user_data))
- g_error ("The schema default value for key `%s' in schema `%s' "
+ g_error ("The schema default value for key '%s' in schema '%s' "
"was rejected by the binding mapping function.",
binding->key.name, g_settings_schema_get_id (binding->key.schema));
}
if (!g_settings_schema_key_type_check (&binding->key, variant))
{
- g_critical ("binding mapping function for key `%s' returned "
- "GVariant of type `%s' when type `%s' was requested",
+ g_critical ("binding mapping function for key '%s' returned "
+ "GVariant of type '%s' when type '%s' was requested",
binding->key.name, g_variant_get_type_string (variant),
g_variant_type_dup_string (binding->key.type));
return;
if (!g_settings_schema_key_range_check (&binding->key, variant))
{
- g_critical ("GObject property `%s' on a `%s' object is out of "
- "schema-specified range for key `%s' of `%s': %s",
+ g_critical ("GObject property '%s' on a '%s' object is out of "
+ "schema-specified range for key '%s' of '%s': %s",
binding->property->name, g_type_name (binding->property->owner_type),
binding->key.name, g_settings_schema_get_id (binding->key.schema),
g_variant_print (variant, TRUE));
if (binding->property->value_type != G_TYPE_BOOLEAN)
{
g_critical ("g_settings_bind: G_SETTINGS_BIND_INVERT_BOOLEAN "
- "was specified, but property `%s' on type `%s' has "
- "type `%s'", binding->property->name, G_OBJECT_TYPE_NAME (object),
+ "was specified, but property '%s' on type '%s' has "
+ "type '%s'", binding->property->name, G_OBJECT_TYPE_NAME (object),
g_type_name ((binding->property->value_type)));
return;
}
if (!g_variant_type_equal (binding->key.type, G_VARIANT_TYPE_BOOLEAN))
{
g_critical ("g_settings_bind: G_SETTINGS_BIND_INVERT_BOOLEAN "
- "was specified, but key `%s' on schema `%s' has "
- "type `%s'", key, g_settings_schema_get_id (settings->priv->schema),
+ "was specified, but key '%s' on schema '%s' has "
+ "type '%s'", key, g_settings_schema_get_id (settings->priv->schema),
g_variant_type_dup_string (binding->key.type));
return;
}
if (value == NULL)
{
- g_warning ("Failed to parse translated string `%s' for "
- "key `%s' in schema `%s': %s", key->unparsed, key->name,
+ g_warning ("Failed to parse translated string '%s' for "
+ "key '%s' in schema '%s': %s", key->unparsed, key->name,
g_settings_schema_get_id (key->schema), error->message);
g_warning ("Using untranslated default instead.");
g_error_free (error);
else if (!g_settings_schema_key_range_check (key, value))
{
- g_warning ("Translated default `%s' for key `%s' in schema `%s' "
+ g_warning ("Translated default '%s' for key '%s' in schema '%s' "
"is outside of valid range", key->unparsed, key->name,
g_settings_schema_get_id (key->schema));
g_variant_unref (value);
* Create a shallow copy of a list.
*
* A shallow copy is a copy of a structure, but not the copy of the
- * contents. All data pointers (`path' in our case) of a list and its
+ * contents. All data pointers ('path' in our case) of a list and its
* shallow copy will point to the same memory.
*
* @param[in] dl A pointer to list to make a copy. May be NULL.
* will be removed from the both lists. Items are comapred by a filename.
*
* @param[in,out] before A pointer to a pointer to a list. Will contain items
- * which were not found in the `after' list.
+ * which were not found in the 'after' list.
* @param[in,out] after A pointer to a pointer to a list. Will containt items
- * which were not found in the `before' list.
+ * which were not found in the 'before' list.
**/
void
dl_diff (dep_list **before, dep_list **after)
for (;;)
{
- /* TODO: Provide more items in the `eventlist' to kqueue(2).
+ /* TODO: Provide more items in the 'eventlist' to kqueue(2).
* Currently the backend takes notifications from the kernel one
* by one, i.e. there will be a lot of system calls and context
* switches when the application will monitor a lot of files with
g_variant_get (parameters, "(&s)", &greeting);
- response = g_strdup_printf ("Method %s.%s with user_data `%s' on object path %s called with arg '%s'",
+ response = g_strdup_printf ("Method %s.%s with user_data '%s' on object path %s called with arg '%s'",
interface_name,
method_name,
(const gchar *) user_data,
g_variant_get (parameters, "(&s)", &greeting);
- response = g_strdup_printf ("Method %s.%s with user_data `%s' on object path %s called with arg '%s'",
+ response = g_strdup_printf ("Method %s.%s with user_data '%s' on object path %s called with arg '%s'",
interface_name,
method_name,
(const gchar *) user_data,
g_variant_get (parameters, "(&s)", &greeting);
- response = g_strdup_printf ("Method %s.%s with user_data `%s' on object path %s called with arg '%s'",
+ response = g_strdup_printf ("Method %s.%s with user_data '%s' on object path %s called with arg '%s'",
interface_name,
method_name,
(const gchar *) user_data,
const gchar *input;
gchar *output;
g_variant_get (parameters, "(&s)", &input);
- output = g_strdup_printf ("You passed the string `%s'. Jolly good!", input);
+ output = g_strdup_printf ("You passed the string '%s'. Jolly good!", input);
g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", output));
g_free (output);
}
{
GVariant *ret;
gchar *s;
- s = g_strdup_printf ("Property `%s' Is What It Is!", property_name);
+ s = g_strdup_printf ("Property '%s' Is What It Is!", property_name);
ret = g_variant_new_string (s);
g_free (s);
return ret;
g_set_error (error,
G_DBUS_ERROR,
G_DBUS_ERROR_SPAWN_FILE_INVALID,
- "Returning some error instead of writing the value `%s' to the property `%s'",
+ "Returning some error instead of writing the value '%s' to the property '%s'",
property_name, s);
g_free (s);
return FALSE;
g_assert (value != NULL);
g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE ("(s)")));
g_variant_get (value, "(&s)", &value_str);
- g_assert_cmpstr (value_str, ==, "You passed the string `winwinwin'. Jolly good!");
+ g_assert_cmpstr (value_str, ==, "You passed the string 'winwinwin'. Jolly good!");
g_variant_unref (value);
error = NULL;
NULL,
&error);
g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS);
- g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.InvalidArgs: Type of message, `(s)', does not match expected type `()'");
+ g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.InvalidArgs: Type of message, '(s)', does not match expected type '()'");
g_error_free (error);
g_assert (value == NULL);
NULL,
&error);
g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD);
- g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.UnknownMethod: No such method `NonExistantMethod'");
+ g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.UnknownMethod: No such method 'NonExistantMethod'");
g_error_free (error);
g_assert (value == NULL);
g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE ("(v)")));
g_variant_get (value, "(v)", &inner);
g_assert (g_variant_is_of_type (inner, G_VARIANT_TYPE_STRING));
- g_assert_cmpstr (g_variant_get_string (inner, NULL), ==, "Property `PropertyUno' Is What It Is!");
+ g_assert_cmpstr (g_variant_get_string (inner, NULL), ==, "Property 'PropertyUno' Is What It Is!");
g_variant_unref (value);
g_variant_unref (inner);
&error);
g_assert (value == NULL);
g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS);
- g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.InvalidArgs: No such property `ThisDoesntExist'");
+ g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.InvalidArgs: No such property 'ThisDoesntExist'");
g_error_free (error);
error = NULL;
&error);
g_assert (value == NULL);
g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS);
- g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.InvalidArgs: Property `NotReadable' is not readable");
+ g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.InvalidArgs: Property 'NotReadable' is not readable");
g_error_free (error);
error = NULL;
&error);
g_assert (value == NULL);
g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_SPAWN_FILE_INVALID);
- g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.Spawn.FileInvalid: Returning some error instead of writing the value `NotReadable' to the property `'But Writable you are!''");
+ g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.Spawn.FileInvalid: Returning some error instead of writing the value 'NotReadable' to the property ''But Writable you are!''");
g_error_free (error);
error = NULL;
&error);
g_assert (value == NULL);
g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS);
- g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.InvalidArgs: Property `NotWritable' is not writable");
+ g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.InvalidArgs: Property 'NotWritable' is not writable");
g_error_free (error);
error = NULL;
g_assert (value != NULL);
g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE ("(a{sv})")));
s = g_variant_print (value, TRUE);
- g_assert_cmpstr (s, ==, "({'PropertyUno': <\"Property `PropertyUno' Is What It Is!\">, 'NotWritable': <\"Property `NotWritable' Is What It Is!\">},)");
+ g_assert_cmpstr (s, ==, "({'PropertyUno': <\"Property 'PropertyUno' Is What It Is!\">, 'NotWritable': <\"Property 'NotWritable' Is What It Is!\">},)");
g_free (s);
g_variant_unref (value);
g_assert_cmpstr (method_name, ==, "Poke");
g_variant_get (parameters, "(&s)", &str);
- ret = g_strdup_printf ("You poked me with: `%s'", str);
+ ret = g_strdup_printf ("You poked me with: '%s'", str);
g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", ret));
g_free (ret);
}
&error);
g_assert_no_error (error);
g_variant_get (ret, "(&s)", &str);
- g_assert_cmpstr (str, ==, "You poked me with: `I am the POKER!'");
+ g_assert_cmpstr (str, ==, "You poked me with: 'I am the POKER!'");
g_variant_unref (ret);
g_object_unref (connection);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
- "Error serializing GVariant with type-string `%s' to a D-Bus message",
+ "Error serializing GVariant with type-string '%s' to a D-Bus message",
g_variant_get_type_string (value));
goto fail;
}
{
const gchar *value;
dbus_message_iter_get_basic (iter, &value);
- g_string_append_printf (s, "string: `%s'\n", value);
+ g_string_append_printf (s, "string: '%s'\n", value);
break;
}
{
const gchar *value;
dbus_message_iter_get_basic (iter, &value);
- g_string_append_printf (s, "object_path: `%s'\n", value);
+ g_string_append_printf (s, "object_path: '%s'\n", value);
break;
}
{
const gchar *value;
dbus_message_iter_get_basic (iter, &value);
- g_string_append_printf (s, "signature: `%s'\n", value);
+ g_string_append_printf (s, "signature: '%s'\n", value);
break;
}
break;
default:
- g_printerr ("Error serializing D-Bus message to GVariant. Unsupported arg type `%c' (%d)",
+ g_printerr ("Error serializing D-Bus message to GVariant. Unsupported arg type '%c' (%d)",
arg_type,
arg_type);
g_assert_not_reached ();
-G_GINT64_CONSTANT(2)<<34,
G_GUINT64_CONSTANT(0xffffffffffffffff),
42.5),
- "value 0: string: `this is a string'\n"
- "value 1: object_path: `/this/is/a/path'\n"
- "value 2: signature: `sad'\n"
+ "value 0: string: 'this is a string'\n"
+ "value 1: object_path: '/this/is/a/path'\n"
+ "value 2: signature: 'sad'\n"
"value 3: byte: 0x2a\n"
"value 4: bool: true\n"
"value 5: int16: -42\n"
" int32: 3\n"
"value 1: array:\n"
" dict_entry:\n"
- " string: `one'\n"
- " string: `white'\n"
+ " string: 'one'\n"
+ " string: 'white'\n"
" dict_entry:\n"
- " string: `two'\n"
- " string: `black'\n");
+ " string: 'two'\n"
+ " string: 'black'\n");
value = g_variant_parse (G_VARIANT_TYPE ("(sa{sv}as)"),
"('01234567890123456', {}, ['Something'])",
g_assert_no_error (error);
g_assert (value != NULL);
check_serialization (value,
- "value 0: string: `01234567890123456'\n"
+ "value 0: string: '01234567890123456'\n"
"value 1: array:\n"
"value 2: array:\n"
- " string: `Something'\n");
+ " string: 'Something'\n");
/* https://bugzilla.gnome.org/show_bug.cgi?id=621838 */
check_serialization (g_variant_new_parsed ("(@aay [], {'cwd': <'/home/davidz/Hacking/glib/gio/tests'>})"),
"value 0: array:\n"
"value 1: array:\n"
" dict_entry:\n"
- " string: `cwd'\n"
+ " string: 'cwd'\n"
" variant:\n"
- " string: `/home/davidz/Hacking/glib/gio/tests'\n");
+ " string: '/home/davidz/Hacking/glib/gio/tests'\n");
#ifdef DBUS_TYPE_UNIX_FD
value = g_variant_parse (G_VARIANT_TYPE ("(hah)"),
gpointer user_data)
{
gchar *response;
- response = g_strdup_printf ("Word! You said `%s'. I'm Skeleton, btw!", greeting);
+ response = g_strdup_printf ("Word! You said '%s'. I'm Skeleton, btw!", greeting);
foo_igen_bar_complete_hello_world (object, invocation, response);
g_free (response);
return TRUE;
gchar *s1;
gchar *s2;
gchar *s3;
- s1 = g_strdup_printf ("Word! You said `%s'. Rock'n'roll!", val_string);
+ s1 = g_strdup_printf ("Word! You said '%s'. Rock'n'roll!", val_string);
s2 = g_strdup_printf ("/modified%s", val_objpath);
s3 = g_strdup_printf ("assgit%s", val_signature);
foo_igen_bar_complete_test_primitive_types (object,
__FILE__, \
__LINE__, \
G_STRFUNC, \
- "Signal `" signal_name "' does not " \
+ "Signal '" signal_name "' does not " \
"exist on object"); \
} \
if (_g_assert_signal_received_run (object, signal_name)) \
__FILE__, \
__LINE__, \
G_STRFUNC, \
- "Timed out waiting for signal `" \
+ "Timed out waiting for signal '" \
signal_name "'"); \
} \
} \
{
const gchar *retval;
- /* The highest priority value is the `LANGUAGE' environment
+ /* The highest priority value is the 'LANGUAGE' environment
variable. This is a GNU extension. */
retval = g_getenv ("LANGUAGE");
if ((retval != NULL) && (retval[0] != '\0'))
return retval;
- /* `LANGUAGE' is not set. So we have to proceed with the POSIX
- methods of looking to `LC_ALL', `LC_xxx', and `LANG'. On some
- systems this can be done by the `setlocale' function itself. */
+ /* 'LANGUAGE' is not set. So we have to proceed with the POSIX
+ methods of looking to 'LC_ALL', 'LC_xxx', and 'LANG'. On some
+ systems this can be done by the 'setlocale' function itself. */
/* Setting of LC_ALL overwrites all other. */
retval = g_getenv ("LC_ALL");
if (checksum->digest_str)
{
- g_warning ("The checksum `%s' has been closed and cannot be updated "
+ g_warning ("The checksum '%s' has been closed and cannot be updated "
"anymore.",
checksum->digest_str);
return;
++i;
}
DEBUG_MSG (("**Order: %s, %s, %s", strings[0], strings[1], strings[2]));
- DEBUG_MSG (("**Sample date in this locale: `%s'", buf));
+ DEBUG_MSG (("**Sample date in this locale: '%s'", buf));
}
#endif
}
g_date_prepare_to_parse (str, &pt);
- DEBUG_MSG (("Found %d ints, `%d' `%d' `%d' and written out month %d",
+ DEBUG_MSG (("Found %d ints, '%d' '%d' '%d' and written out month %d",
pt.num_ints, pt.n[0], pt.n[1], pt.n[2], pt.month));
* library function.
* @G_FILE_ERROR_PIPE: Broken pipe; there is no process reading from the
* other end of a pipe. Every library function that returns this
- * error code also generates a `SIGPIPE' signal; this signal
+ * error code also generates a 'SIGPIPE' signal; this signal
* terminates the program if not handled or blocked. Thus, your
* program will never actually see this code unless it has handled
- * or blocked `SIGPIPE'.
+ * or blocked 'SIGPIPE'.
* @G_FILE_ERROR_AGAIN: Resource temporarily unavailable; the call might
* work if you try again later.
* @G_FILE_ERROR_INTR: Interrupted function call; an asynchronous signal
{
FILE *f;
- fprintf (stderr, "Reading `%s'\n", data_file_name);
+ fprintf (stderr, "Reading '%s'\n", data_file_name);
if (!(f = fopen (data_file_name, "rt")))
- die2 ("error: cannot open `%s' for reading", data_file_name);
+ die2 ("error: cannot open '%s' for reading", data_file_name);
if (!strcmp (data_file_type, "BidiMirroring.txt"))
read_bidi_mirroring_txt (f);
const char *key_type;
fprintf (stderr,
- "Generating `" outputname "', it may take up to a few minutes\n");
+ "Generating '" outputname "', it may take up to a few minutes\n");
printf ("/* " outputname "\n * generated by " appname " "
"\n" " * from the file %s of */\n\n", data_file_type);
}
}
g_mutex_unlock (&g_messages_lock);
- g_warning ("%s: could not find handler with id `%d' for domain \"%s\"",
+ g_warning ("%s: could not find handler with id '%d' for domain \"%s\"",
G_STRLOC, handler_id, log_domain);
}
{
g_log (log_domain,
G_LOG_LEVEL_CRITICAL,
- "%s: assertion `%s' failed",
+ "%s: assertion '%s' failed",
pretty_function,
expression);
}
{ \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_CRITICAL, \
- "file %s: line %d: assertion `%s' failed", \
+ "file %s: line %d: assertion '%s' failed", \
__FILE__, \
__LINE__, \
#expr); \
{ \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_CRITICAL, \
- "file %s: line %d: assertion `%s' failed", \
+ "file %s: line %d: assertion '%s' failed", \
__FILE__, \
__LINE__, \
#expr); \
#define g_node_append_data(parent, data) \
g_node_insert_before ((parent), NULL, g_node_new (data))
-/* traversal function, assumes that `node' is root
- * (only traverses `node' and its subtree).
+/* traversal function, assumes that 'node' is root
+ * (only traverses 'node' and its subtree).
* this function is just a high level interface to
* low level traversal functions, optimized for speed.
*/
GNodeTraverseFunc func,
gpointer data);
-/* return the maximum tree height starting with `node', this is an expensive
+/* return the maximum tree height starting with 'node', this is an expensive
* operation, since we need to visit all nodes. this could be shortened by
- * adding `guint height' to struct _GNode, but then again, this is not very
+ * adding 'guint height' to struct _GNode, but then again, this is not very
* often needed, and would make g_node_insert() more time consuming.
*/
GLIB_AVAILABLE_IN_ALL
if ((scanner->token >= ' ' && scanner->token <= '~') ||
strchr (scanner->config->cset_identifier_first, scanner->token) ||
strchr (scanner->config->cset_identifier_nth, scanner->token))
- _g_snprintf (token_string, token_string_len, "character `%c'", scanner->token);
+ _g_snprintf (token_string, token_string_len, "character '%c'", scanner->token);
else
- _g_snprintf (token_string, token_string_len, "character `\\%o'", scanner->token);
+ _g_snprintf (token_string, token_string_len, "character '\\%o'", scanner->token);
break;
}
else if (!scanner->config->symbol_2_token)
if (symbol_name)
_g_snprintf (token_string,
token_string_len,
- "%s%s `%s'",
+ "%s%s '%s'",
print_unexp ? "" : "invalid ",
symbol_spec,
symbol_name);
break;
case G_TOKEN_CHAR:
- _g_snprintf (token_string, token_string_len, "character `%c'", scanner->value.v_char);
+ _g_snprintf (token_string, token_string_len, "character '%c'", scanner->value.v_char);
break;
case G_TOKEN_IDENTIFIER:
print_unexp = FALSE;
_g_snprintf (token_string,
token_string_len,
- "%s%s `%s'",
+ "%s%s '%s'",
print_unexp ? "" : "invalid ",
identifier_spec,
scanner->token == G_TOKEN_IDENTIFIER ? scanner->value.v_string : "null");
case G_TOKEN_INT:
case G_TOKEN_HEX:
if (scanner->config->store_int64)
- _g_snprintf (token_string, token_string_len, "number `%" G_GUINT64_FORMAT "'", scanner->value.v_int64);
+ _g_snprintf (token_string, token_string_len, "number '%" G_GUINT64_FORMAT "'", scanner->value.v_int64);
else
- _g_snprintf (token_string, token_string_len, "number `%lu'", scanner->value.v_int);
+ _g_snprintf (token_string, token_string_len, "number '%lu'", scanner->value.v_int);
break;
case G_TOKEN_FLOAT:
- _g_snprintf (token_string, token_string_len, "number `%.3f'", scanner->value.v_float);
+ _g_snprintf (token_string, token_string_len, "number '%.3f'", scanner->value.v_float);
break;
case G_TOKEN_STRING:
if ((expected_token >= ' ' && expected_token <= '~') ||
strchr (scanner->config->cset_identifier_first, expected_token) ||
strchr (scanner->config->cset_identifier_nth, expected_token))
- _g_snprintf (expected_string, expected_string_len, "character `%c'", expected_token);
+ _g_snprintf (expected_string, expected_string_len, "character '%c'", expected_token);
else
- _g_snprintf (expected_string, expected_string_len, "character `\\%o'", expected_token);
+ _g_snprintf (expected_string, expected_string_len, "character '\\%o'", expected_token);
break;
}
else if (!scanner->config->symbol_2_token)
guint scan_binary : 1;
guint scan_octal : 1;
guint scan_float : 1;
- guint scan_hex : 1; /* `0x0ff0' */
- guint scan_hex_dollar : 1; /* `$0ff0' */
+ guint scan_hex : 1; /* '0x0ff0' */
+ guint scan_hex_dollar : 1; /* '$0ff0' */
guint scan_string_sq : 1; /* string: 'anything' */
guint scan_string_dq : 1; /* string: "\\-escapes!\n" */
guint numbers_2_int : 1; /* bin, octal, hex => int */
if (path == NULL)
{
- /* There is no `PATH' in the environment. The default
+ /* There is no 'PATH' in the environment. The default
* search path in libc is the current directory followed by
- * the path `confstr' returns for `_CS_PATH'.
+ * the path 'confstr' returns for '_CS_PATH'.
*/
/* In GLib we put . last, for security, and don't use the
if (p == path)
/* Two adjacent colons, or a colon at the beginning or the end
- * of `PATH' means to search the current directory.
+ * of 'PATH' means to search the current directory.
*/
startp = name + 1;
else
switch (errno)
{
case EACCES:
- /* Record the we got a `Permission denied' error. If we end
+ /* Record the we got a 'Permission denied' error. If we end
* up finding no executable we can use, we want to diagnose
* that we did find one but were denied access.
*/
"""A representation of a gtester test result as a pyunit TestCase."""
def __init__(self, case, binary):
- """Create a GTestCase for case `case` from binary program `binary`."""
+ """Create a GTestCase for case 'case' from binary program 'binary'."""
self._case = case
self._binary = binary
# the name of the case - e.g. /dbusmenu/glib/objects/menuitem/props_boolstr
GLIB_AVAILABLE_IN_ALL
gunichar g_unichar_totitle (gunichar c) G_GNUC_CONST;
-/* If C is a digit (according to `g_unichar_isdigit'), then return its
+/* If C is a digit (according to 'g_unichar_isdigit'), then return its
numeric value. Otherwise return -1. */
GLIB_AVAILABLE_IN_ALL
gint g_unichar_digit_value (gunichar c) G_GNUC_CONST;
#if defined(G_OS_UNIX) || defined(G_OS_BEOS)
if (path == NULL)
{
- /* There is no `PATH' in the environment. The default
+ /* There is no 'PATH' in the environment. The default
* search path in GNU libc is the current directory followed by
- * the path `confstr' returns for `_CS_PATH'.
+ * the path 'confstr' returns for '_CS_PATH'.
*/
/* In GLib we put . last, for security, and don't use the
if (p == path)
/* Two adjacent colons, or a colon at the beginning or the end
- * of `PATH' means to search the current directory.
+ * of 'PATH' means to search the current directory.
*/
startp = name + 1;
else
# endif /* va_list is a pointer */
#endif /* !G_VA_COPY */
-/* inlining hassle. for compilers that don't allow the `inline' keyword,
+/* inlining hassle. for compilers that don't allow the 'inline' keyword,
* mostly because of strict ANSI C compliance or dumbness, we try to fall
- * back to either `__inline__' or `__inline'.
+ * back to either '__inline__' or '__inline'.
* G_CAN_INLINE is defined in glibconfig.h if the compiler seems to be
* actually *capable* to do function inlining, in which case inline
* function bodies do make sense. we also define G_INLINE_FUNC to properly
{
token_stream_set_error (stream, error, FALSE,
G_VARIANT_PARSE_ERROR_UNEXPECTED_TOKEN,
- "expected `%s'%s", token, purpose);
+ "expected '%s'%s", token, purpose);
return FALSE;
}
typestr = g_variant_type_dup_string (type);
ast_set_error (ast, error, NULL,
G_VARIANT_PARSE_ERROR_TYPE_ERROR,
- "can not parse as value of type `%s'",
+ "can not parse as value of type '%s'",
typestr);
g_free (typestr);
if (need_comma &&
!token_stream_require (stream, ",",
- " or `]' to follow array element",
+ " or ']' to follow array element",
error))
goto error;
if (need_comma &&
!token_stream_require (stream, ",",
- " or `)' to follow tuple element",
+ " or ')' to follow tuple element",
error))
goto error;
only_one = token_stream_consume (stream, ",");
if (!only_one &&
!token_stream_require (stream, ":",
- " or `,' to follow dictionary entry key",
+ " or ',' to follow dictionary entry key",
error))
goto error;
AST *child;
if (!token_stream_require (stream, ",",
- " or `}' to follow dictionary entry", error))
+ " or '}' to follow dictionary entry", error))
goto error;
child = parse (stream, app, error);
{
ast_set_error (ast, error, NULL,
G_VARIANT_PARSE_ERROR_NUMBER_OUT_OF_RANGE,
- "number out of range for type `%c'",
+ "number out of range for type '%c'",
g_variant_type_peek_string (type)[0]);
return NULL;
}
{
if (array_element_size)
g_critical ("g_variant_get_fixed_array: assertion "
- "`g_variant_array_has_fixed_size (value, element_size)' "
+ "'g_variant_array_has_fixed_size (value, element_size)' "
"failed: array size %"G_GSIZE_FORMAT" does not match "
"given element_size %"G_GSIZE_FORMAT".",
array_element_size, element_size);
else
g_critical ("g_variant_get_fixed_array: assertion "
- "`g_variant_array_has_fixed_size (value, element_size)' "
+ "'g_variant_array_has_fixed_size (value, element_size)' "
"failed: array does not have fixed size.");
}
if G_UNLIKELY (type == NULL || (single && *endptr != '\0'))
{
if (single)
- g_critical ("`%s' is not a valid GVariant format string",
+ g_critical ("'%s' is not a valid GVariant format string",
format_string);
else
- g_critical ("`%s' does not have a valid GVariant format "
+ g_critical ("'%s' does not have a valid GVariant format "
"string as a prefix", format_string);
if (type != NULL)
fragment = g_strndup (format_string, endptr - format_string);
typestr = g_variant_type_dup_string (type);
- g_critical ("the GVariant format string `%s' has a type of "
- "`%s' but the given value has a type of `%s'",
+ g_critical ("the GVariant format string '%s' has a type of "
+ "'%s' but the given value has a type of '%s'",
fragment, typestr, g_variant_get_type_string (value));
g_variant_type_free (type);
if G_UNLIKELY (!g_variant_type_is_array (type))
g_error ("g_variant_new: expected array GVariantBuilder but "
- "the built value has type `%s'",
+ "the built value has type '%s'",
g_variant_get_type_string (value));
type = g_variant_type_element (type);
if G_UNLIKELY (!g_variant_type_is_subtype_of (type, (GVariantType *) *str))
g_error ("g_variant_new: expected GVariantBuilder array element "
- "type `%s' but the built value has element type `%s'",
+ "type '%s' but the built value has element type '%s'",
g_variant_type_dup_string ((GVariantType *) *str),
g_variant_get_type_string (value) + 1);
case '@':
if G_UNLIKELY (!g_variant_is_of_type (ptr, (GVariantType *) *str))
- g_error ("g_variant_new: expected GVariant of type `%s' but "
- "received value has type `%s'",
+ g_error ("g_variant_new: expected GVariant of type '%s' but "
+ "received value has type '%s'",
g_variant_type_dup_string ((GVariantType *) *str),
g_variant_get_type_string (ptr));
case '?':
if G_UNLIKELY (!g_variant_type_is_basic (g_variant_get_type (ptr)))
- g_error ("g_variant_new: format string `?' expects basic-typed "
- "GVariant, but received value has type `%s'",
+ g_error ("g_variant_new: format string '?' expects basic-typed "
+ "GVariant, but received value has type '%s'",
g_variant_get_type_string (ptr));
return ptr;
case 'r':
if G_UNLIKELY (!g_variant_type_is_tuple (g_variant_get_type (ptr)))
- g_error ("g_variant_new: format string `r` expects tuple-typed "
- "GVariant, but received value has type `%s'",
+ g_error ("g_variant_new: format string 'r' expects tuple-typed "
+ "GVariant, but received value has type '%s'",
g_variant_get_type_string (ptr));
return ptr;
value = g_variant_new ("y", 'a');
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
- "*type of `q' but * has a type of `y'*");
+ "*type of 'q' but * has a type of 'y'*");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*valid_format_string*");
g_variant_get (value, "q");
"[1, 2,", "6:", "expected value",
"", "0:", "expected value",
"(1, 2,", "6:", "expected value",
- "<1", "2:", "expected `>'",
+ "<1", "2:", "expected '>'",
"[]", "0-2:", "unable to infer",
"(,", "1:", "expected value",
"[4,'']", "1-2,3-5:", "common type",
"just [4, '']", "6-7,9-11:", "common type",
"[[4,'']]", "2-3,4-6:", "common type",
"([4,''],)", "2-3,4-6:", "common type",
- "(4)", "2:", "`,'",
+ "(4)", "2:", "','",
"{}", "0-2:", "unable to infer",
"{[1,2],[3,4]}", "0-13:", "basic types",
"{[1,2]:[3,4]}", "0-13:", "basic types",
"@i ()", "3-5:", "can not parse as",
"@ai (4,)", "4-8:", "can not parse as",
"@(i) []", "5-7:", "can not parse as",
- "(5 5)", "3:", "expected `,'",
- "[5 5]", "3:", "expected `,' or `]'",
- "(5, 5 5)", "6:", "expected `,' or `)'",
- "[5, 5 5]", "6:", "expected `,' or `]'",
+ "(5 5)", "3:", "expected ','",
+ "[5 5]", "3:", "expected ',' or ']'",
+ "(5, 5 5)", "6:", "expected ',' or ')'",
+ "[5, 5 5]", "6:", "expected ',' or ']'",
"<@i []>", "4-6:", "can not parse as",
- "<[5 5]>", "4:", "expected `,' or `]'",
+ "<[5 5]>", "4:", "expected ',' or ']'",
"{[4,''],5}", "2-3,4-6:", "common type",
"{5,[4,'']}", "4-5,6-8:", "common type",
"@i {1,2}", "3-8:", "can not parse as",
"@ai {}", "4-6:", "can not parse as",
"{@i '': 5}", "4-6:", "can not parse as",
"{5: @i ''}", "7-9:", "can not parse as",
- "{<4,5}", "3:", "expected `>'",
- "{4,<5}", "5:", "expected `>'",
- "{4,5,6}", "4:", "expected `}'",
- "{5 5}", "3:", "expected `:' or `,'",
- "{4: 5: 6}", "5:", "expected `,' or `}'",
- "{4:5,<6:7}", "7:", "expected `>'",
- "{4:5,6:<7}", "9:", "expected `>'",
- "{4:5,6 7}", "7:", "expected `:'",
+ "{<4,5}", "3:", "expected '>'",
+ "{4,<5}", "5:", "expected '>'",
+ "{4,5,6}", "4:", "expected '}'",
+ "{5 5}", "3:", "expected ':' or ','",
+ "{4: 5: 6}", "5:", "expected ',' or '}'",
+ "{4:5,<6:7}", "7:", "expected '>'",
+ "{4:5,6:<7}", "9:", "expected '>'",
+ "{4:5,6 7}", "7:", "expected ':'",
"@o 'foo'", "3-8:", "object path",
"@g 'zzz'", "3-8:", "signature",
"@i true", "3-7:", "can not parse as",
"@z 4", "0-2:", "invalid type",
"@a* []", "0-3:", "definite",
- "@ai [3 3]", "7:", "expected `,' or `]'",
+ "@ai [3 3]", "7:", "expected ',' or ']'",
"18446744073709551616", "0-20:", "too big for any type",
"-18446744073709551616", "0-21:", "too big for any type",
"byte 256", "5-8:", "out of range for type",
g_assert (value == NULL);
if (!strstr (error->message, test[i+2]))
- g_error ("test %d: Can't find `%s' in `%s'", i / 3,
+ g_error ("test %d: Can't find '%s' in '%s'", i / 3,
test[i+2], error->message);
if (!g_str_has_prefix (error->message, test[i+1]))
- g_error ("test %d: Expected location `%s' in `%s'", i / 3,
+ g_error ("test %d: Expected location '%s' in '%s'", i / 3,
test[i+1], error->message);
g_error_free (error);
"*can not parse as*");
do_failed_test ("/gvariant/parse/subprocess/bad-args",
- "*expected GVariant of type `i'*");
+ "*expected GVariant of type 'i'*");
}
}
g_markup_parse_context_parse (context, XML, -1, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
- "g_markup_parse_context_end_parse: assertion `context->state != STATE_ERROR' failed");
+ "g_markup_parse_context_end_parse: assertion 'context->state != STATE_ERROR' failed");
g_markup_parse_context_end_parse (context, NULL);
g_test_assert_expected_messages ();
if (strcmp (name, "_end") == 0)
{
- msg = g_strdup_printf ("unmatched symbol name `%s'", symbol_name);
+ msg = g_strdup_printf ("unmatched symbol name '%s'", symbol_name);
g_module_set_error (msg);
g_free (msg);
g_free (wfilename);
if (!handle)
- set_error ("`%s': ", file_name);
+ set_error ("'%s': ", file_name);
return handle;
}
{
gchar *error;
- error = g_strconcat ("`", symbol_name, "': ", module_error, NULL);
+ error = g_strconcat ("'", symbol_name, "': ", module_error, NULL);
g_module_set_error (error);
g_free (error);
*symbol = NULL;
GLIB_AVAILABLE_IN_ALL
gboolean g_module_supported (void) G_GNUC_CONST;
-/* open a module `file_name' and return handle, which is NULL on error */
+/* open a module 'file_name' and return handle, which is NULL on error */
GLIB_AVAILABLE_IN_ALL
GModule* g_module_open (const gchar *file_name,
GModuleFlags flags);
GLIB_AVAILABLE_IN_ALL
const gchar * g_module_error (void);
-/* retrieve a symbol pointer from `module', returns TRUE on success */
+/* retrieve a symbol pointer from 'module', returns TRUE on success */
GLIB_AVAILABLE_IN_ALL
gboolean g_module_symbol (GModule *module,
const gchar *symbol_name,
GLIB_AVAILABLE_IN_ALL
const gchar * g_module_name (GModule *module);
-/* Build the actual file name containing a module. `directory' is the
+/* Build the actual file name containing a module. 'directory' is the
* directory where the module file is supposed to be, or NULL or empty
* in which case it should either be in the current directory or, on
* some operating systems, in some standard place, for instance on the
* PATH. Hence, to be absoultely sure to get the correct module,
* always pass in a directory. The file name consists of the directory,
- * if supplied, and `module_name' suitably decorated according to
+ * if supplied, and 'module_name' suitably decorated according to
* the operating system's conventions (for instance lib*.so or *.dll).
*
* No checks are made that the file exists, or is of correct type.
gpointer *boxed_p = collect_values[0].v_pointer;
if (!boxed_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
if (!value->data[0].v_pointer)
*boxed_p = NULL;
/* double check and grouse if things went wrong */
if (dest_value.data[1].v_ulong)
- g_warning ("the copy_value() implementation of type `%s' seems to make use of reserved GValue fields",
+ g_warning ("the copy_value() implementation of type '%s' seems to make use of reserved GValue fields",
g_type_name (boxed_type));
dest_boxed = dest_value.data[0].v_pointer;
gint *int_p = collect_values[0].v_pointer;
if (!int_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*int_p = value->data[0].v_long;
{
if (g_param_spec_pool_lookup (pspec_pool, pspec->name, g_type, FALSE))
{
- g_warning ("When installing property: type `%s' already has a property named `%s'",
+ g_warning ("When installing property: type '%s' already has a property named '%s'",
g_type_name (g_type),
pspec->name);
return;
TRUE);
if (!pspec)
- g_warning ("%s: object class `%s' has no property named `%s'",
+ g_warning ("%s: object class '%s' has no property named '%s'",
G_STRFUNC,
G_OBJECT_TYPE_NAME (object),
property_name);
/* provide a copy to work from, convert (if necessary) and validate */
g_value_init (&tmp_value, pspec->value_type);
if (!g_value_transform (value, &tmp_value))
- g_warning ("unable to set property `%s' of type `%s' from value of type `%s'",
+ g_warning ("unable to set property '%s' of type '%s' from value of type '%s'",
pspec->name,
g_type_name (pspec->value_type),
G_VALUE_TYPE_NAME (value));
{
gchar *contents = g_strdup_value_contents (value);
- g_warning ("value \"%s\" of type `%s' is invalid or out of range for property `%s' of type `%s'",
+ g_warning ("value \"%s\" of type '%s' is invalid or out of range for property '%s' of type '%s'",
contents,
G_VALUE_TYPE_NAME (value),
pspec->name,
if G_UNLIKELY (!pspec)
{
- g_critical ("%s: object class `%s' has no property named `%s'",
+ g_critical ("%s: object class '%s' has no property named '%s'",
G_STRFUNC, g_type_name (object_type), parameters[i].name);
continue;
}
if G_UNLIKELY (~pspec->flags & G_PARAM_WRITABLE)
{
- g_critical ("%s: property `%s' of object class `%s' is not writable",
+ g_critical ("%s: property '%s' of object class '%s' is not writable",
G_STRFUNC, pspec->name, g_type_name (object_type));
continue;
}
break;
if G_UNLIKELY (k != j)
{
- g_critical ("%s: construct property `%s' for type `%s' cannot be set twice",
+ g_critical ("%s: construct property '%s' for type '%s' cannot be set twice",
G_STRFUNC, parameters[i].name, g_type_name (object_type));
continue;
}
if G_UNLIKELY (!pspec)
{
- g_critical ("%s: object class `%s' has no property named `%s'",
+ g_critical ("%s: object class '%s' has no property named '%s'",
G_STRFUNC, g_type_name (object_type), name);
/* Can't continue because arg list will be out of sync. */
break;
if G_UNLIKELY (~pspec->flags & G_PARAM_WRITABLE)
{
- g_critical ("%s: property `%s' of object class `%s' is not writable",
+ g_critical ("%s: property '%s' of object class '%s' is not writable",
G_STRFUNC, pspec->name, g_type_name (object_type));
break;
}
break;
if G_UNLIKELY (i != n_params)
{
- g_critical ("%s: property `%s' for type `%s' cannot be set twice",
+ g_critical ("%s: property '%s' for type '%s' cannot be set twice",
G_STRFUNC, name, g_type_name (object_type));
break;
}
TRUE);
if (!pspec)
{
- g_warning ("%s: object class `%s' has no property named `%s'",
+ g_warning ("%s: object class '%s' has no property named '%s'",
G_STRFUNC,
G_OBJECT_TYPE_NAME (object),
name);
}
if (!(pspec->flags & G_PARAM_WRITABLE))
{
- g_warning ("%s: property `%s' of object class `%s' is not writable",
+ g_warning ("%s: property '%s' of object class '%s' is not writable",
G_STRFUNC,
pspec->name,
G_OBJECT_TYPE_NAME (object));
}
if ((pspec->flags & G_PARAM_CONSTRUCT_ONLY) && !object_in_construction_list (object))
{
- g_warning ("%s: construct property \"%s\" for object `%s' can't be set after construction",
+ g_warning ("%s: construct property \"%s\" for object '%s' can't be set after construction",
G_STRFUNC, pspec->name, G_OBJECT_TYPE_NAME (object));
break;
}
TRUE);
if (!pspec)
{
- g_warning ("%s: object class `%s' has no property named `%s'",
+ g_warning ("%s: object class '%s' has no property named '%s'",
G_STRFUNC,
G_OBJECT_TYPE_NAME (object),
name);
}
if (!(pspec->flags & G_PARAM_READABLE))
{
- g_warning ("%s: property `%s' of object class `%s' is not readable",
+ g_warning ("%s: property '%s' of object class '%s' is not readable",
G_STRFUNC,
pspec->name,
G_OBJECT_TYPE_NAME (object));
G_OBJECT_TYPE (object),
TRUE);
if (!pspec)
- g_warning ("%s: object class `%s' has no property named `%s'",
+ g_warning ("%s: object class '%s' has no property named '%s'",
G_STRFUNC,
G_OBJECT_TYPE_NAME (object),
property_name);
else if (!(pspec->flags & G_PARAM_WRITABLE))
- g_warning ("%s: property `%s' of object class `%s' is not writable",
+ g_warning ("%s: property '%s' of object class '%s' is not writable",
G_STRFUNC,
pspec->name,
G_OBJECT_TYPE_NAME (object));
else if ((pspec->flags & G_PARAM_CONSTRUCT_ONLY) && !object_in_construction_list (object))
- g_warning ("%s: construct property \"%s\" for object `%s' can't be set after construction",
+ g_warning ("%s: construct property \"%s\" for object '%s' can't be set after construction",
G_STRFUNC, pspec->name, G_OBJECT_TYPE_NAME (object));
else
object_set_property (object, pspec, value, nqueue);
G_OBJECT_TYPE (object),
TRUE);
if (!pspec)
- g_warning ("%s: object class `%s' has no property named `%s'",
+ g_warning ("%s: object class '%s' has no property named '%s'",
G_STRFUNC,
G_OBJECT_TYPE_NAME (object),
property_name);
else if (!(pspec->flags & G_PARAM_READABLE))
- g_warning ("%s: property `%s' of object class `%s' is not readable",
+ g_warning ("%s: property '%s' of object class '%s' is not readable",
G_STRFUNC,
pspec->name,
G_OBJECT_TYPE_NAME (object));
}
else if (!g_value_type_transformable (pspec->value_type, G_VALUE_TYPE (value)))
{
- g_warning ("%s: can't retrieve property `%s' of type `%s' as value of type `%s'",
+ g_warning ("%s: can't retrieve property '%s' of type '%s' as value of type '%s'",
G_STRFUNC, pspec->name,
g_type_name (pspec->value_type),
G_VALUE_TYPE_NAME (value));
GObject *object = collect_values[0].v_pointer;
if (object->g_type_instance.g_class == NULL)
- return g_strconcat ("invalid unclassed object pointer for value type `",
+ return g_strconcat ("invalid unclassed object pointer for value type '",
G_VALUE_TYPE_NAME (value),
"'",
NULL);
else if (!g_value_type_compatible (G_OBJECT_TYPE (object), G_VALUE_TYPE (value)))
- return g_strconcat ("invalid object type `",
+ return g_strconcat ("invalid object type '",
G_OBJECT_TYPE_NAME (object),
- "' for value type `",
+ "' for value type '",
G_VALUE_TYPE_NAME (value),
"'",
NULL);
GObject **object_p = collect_values[0].v_pointer;
if (!object_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
if (!value->data[0].v_pointer)
*object_p = NULL;
GObject *_glib__object = (GObject*) (object); \
GParamSpec *_glib__pspec = (GParamSpec*) (pspec); \
guint _glib__property_id = (property_id); \
- g_warning ("%s: invalid %s id %u for \"%s\" of type `%s' in `%s'", \
+ g_warning ("%s: invalid %s id %u for \"%s\" of type '%s' in '%s'", \
G_STRLOC, \
(pname), \
_glib__property_id, \
GParamSpec *param = collect_values[0].v_pointer;
if (param->g_type_instance.g_class == NULL)
- return g_strconcat ("invalid unclassed param spec pointer for value type `",
+ return g_strconcat ("invalid unclassed param spec pointer for value type '",
G_VALUE_TYPE_NAME (value),
"'",
NULL);
else if (!g_value_type_compatible (G_PARAM_SPEC_TYPE (param), G_VALUE_TYPE (value)))
- return g_strconcat ("invalid param spec type `",
+ return g_strconcat ("invalid param spec type '",
G_PARAM_SPEC_TYPE_NAME (param),
- "' for value type `",
+ "' for value type '",
G_VALUE_TYPE_NAME (value),
"'",
NULL);
GParamSpec **param_p = collect_values[0].v_pointer;
if (!param_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
if (!value->data[0].v_pointer)
*param_p = NULL;
if (g_hash_table_remove (pool->hash_table, pspec))
g_param_spec_unref (pspec);
else
- g_warning (G_STRLOC ": attempt to remove unknown pspec `%s' from pool", pspec->name);
+ g_warning (G_STRLOC ": attempt to remove unknown pspec '%s' from pool", pspec->name);
g_mutex_unlock (&pool->mutex);
}
else
if (node->itype == itype)
{
if (node->destroyed)
- g_warning (G_STRLOC ": signal \"%s\" of type `%s' already destroyed",
+ g_warning (G_STRLOC ": signal \"%s\" of type '%s' already destroyed",
node->name,
type_debug_name (node->itype));
else
node = LOOKUP_SIGNAL_NODE (signal_id);
if (node && detail && !(node->flags & G_SIGNAL_DETAILED))
{
- g_warning ("%s: signal id `%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
+ g_warning ("%s: signal id '%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
SIGNAL_UNLOCK ();
return;
}
if (emission)
{
if (emission->state == EMISSION_HOOK)
- g_warning (G_STRLOC ": emission of signal \"%s\" for instance `%p' cannot be stopped from emission hook",
+ g_warning (G_STRLOC ": emission of signal \"%s\" for instance '%p' cannot be stopped from emission hook",
node->name, instance);
else if (emission->state == EMISSION_RUN)
emission->state = EMISSION_STOP;
}
else
- g_warning (G_STRLOC ": no emission of signal \"%s\" to stop for instance `%p'",
+ g_warning (G_STRLOC ": no emission of signal \"%s\" to stop for instance '%p'",
node->name, instance);
}
else
- g_warning ("%s: signal id `%u' is invalid for instance `%p'", G_STRLOC, signal_id, instance);
+ g_warning ("%s: signal id '%u' is invalid for instance '%p'", G_STRLOC, signal_id, instance);
SIGNAL_UNLOCK ();
}
node = LOOKUP_SIGNAL_NODE (signal_id);
if (!node || node->destroyed)
{
- g_warning ("%s: invalid signal id `%u'", G_STRLOC, signal_id);
+ g_warning ("%s: invalid signal id '%u'", G_STRLOC, signal_id);
SIGNAL_UNLOCK ();
return 0;
}
if (node->flags & G_SIGNAL_NO_HOOKS)
{
- g_warning ("%s: signal id `%u' does not support emission hooks (G_SIGNAL_NO_HOOKS flag set)", G_STRLOC, signal_id);
+ g_warning ("%s: signal id '%u' does not support emission hooks (G_SIGNAL_NO_HOOKS flag set)", G_STRLOC, signal_id);
SIGNAL_UNLOCK ();
return 0;
}
if (detail && !(node->flags & G_SIGNAL_DETAILED))
{
- g_warning ("%s: signal id `%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
+ g_warning ("%s: signal id '%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
SIGNAL_UNLOCK ();
return 0;
}
node = LOOKUP_SIGNAL_NODE (signal_id);
if (!node || node->destroyed)
{
- g_warning ("%s: invalid signal id `%u'", G_STRLOC, signal_id);
+ g_warning ("%s: invalid signal id '%u'", G_STRLOC, signal_id);
goto out;
}
else if (!node->emission_hooks || !g_hook_destroy (node->emission_hooks, hook_id))
SignalNode *node = LOOKUP_SIGNAL_NODE (signal_id);
if (detail && !(node->flags & G_SIGNAL_DETAILED))
- g_warning ("%s: signal `%s' does not support details", G_STRLOC, detailed_signal);
+ g_warning ("%s: signal '%s' does not support details", G_STRLOC, detailed_signal);
else if (!g_type_is_a (itype, node->itype))
- g_warning ("%s: signal `%s' is invalid for instance `%p' of type `%s'",
+ g_warning ("%s: signal '%s' is invalid for instance '%p' of type '%s'",
G_STRLOC, detailed_signal, instance, g_type_name (itype));
else
{
if (emission)
{
if (emission->state == EMISSION_HOOK)
- g_warning (G_STRLOC ": emission of signal \"%s\" for instance `%p' cannot be stopped from emission hook",
+ g_warning (G_STRLOC ": emission of signal \"%s\" for instance '%p' cannot be stopped from emission hook",
node->name, instance);
else if (emission->state == EMISSION_RUN)
emission->state = EMISSION_STOP;
}
else
- g_warning (G_STRLOC ": no emission of signal \"%s\" to stop for instance `%p'",
+ g_warning (G_STRLOC ": no emission of signal \"%s\" to stop for instance '%p'",
node->name, instance);
}
}
else
- g_warning ("%s: signal `%s' is invalid for instance `%p' of type `%s'",
+ g_warning ("%s: signal '%s' is invalid for instance '%p' of type '%s'",
G_STRLOC, detailed_signal, instance, g_type_name (itype));
SIGNAL_UNLOCK ();
}
{
/* give elaborate warnings */
if (!g_type_name (itype))
- g_warning (G_STRLOC ": unable to lookup signal \"%s\" for invalid type id `%"G_GSIZE_FORMAT"'",
+ g_warning (G_STRLOC ": unable to lookup signal \"%s\" for invalid type id '%"G_GSIZE_FORMAT"'",
name, itype);
else if (!G_TYPE_IS_INSTANTIATABLE (itype))
- g_warning (G_STRLOC ": unable to lookup signal \"%s\" for non instantiatable type `%s'",
+ g_warning (G_STRLOC ": unable to lookup signal \"%s\" for non instantiatable type '%s'",
name, g_type_name (itype));
else if (!g_type_class_peek (itype))
- g_warning (G_STRLOC ": unable to lookup signal \"%s\" of unloaded type `%s'",
+ g_warning (G_STRLOC ": unable to lookup signal \"%s\" of unloaded type '%s'",
name, g_type_name (itype));
}
{
/* give elaborate warnings */
if (!g_type_name (itype))
- g_warning (G_STRLOC ": unable to list signals for invalid type id `%"G_GSIZE_FORMAT"'",
+ g_warning (G_STRLOC ": unable to list signals for invalid type id '%"G_GSIZE_FORMAT"'",
itype);
else if (!G_TYPE_IS_INSTANTIATABLE (itype) && !G_TYPE_IS_INTERFACE (itype))
- g_warning (G_STRLOC ": unable to list signals of non instantiatable type `%s'",
+ g_warning (G_STRLOC ": unable to list signals of non instantiatable type '%s'",
g_type_name (itype));
else if (!g_type_class_peek (itype) && !G_TYPE_IS_INTERFACE (itype))
- g_warning (G_STRLOC ": unable to list signals of unloaded type `%s'",
+ g_warning (G_STRLOC ": unable to list signals of unloaded type '%s'",
g_type_name (itype));
}
node = LOOKUP_SIGNAL_NODE (signal_id);
if (node && !node->destroyed)
{
- g_warning (G_STRLOC ": signal \"%s\" already exists in the `%s' %s",
+ g_warning (G_STRLOC ": signal \"%s\" already exists in the '%s' %s",
name,
type_debug_name (node->itype),
G_TYPE_IS_INTERFACE (node->itype) ? "interface" : "class ancestry");
}
if (node && node->itype != itype)
{
- g_warning (G_STRLOC ": signal \"%s\" for type `%s' was previously created for type `%s'",
+ g_warning (G_STRLOC ": signal \"%s\" for type '%s' was previously created for type '%s'",
name,
type_debug_name (itype),
type_debug_name (node->itype));
for (i = 0; i < n_params; i++)
if (!G_TYPE_IS_VALUE (param_types[i] & ~G_SIGNAL_TYPE_STATIC_SCOPE))
{
- g_warning (G_STRLOC ": parameter %d of type `%s' for signal \"%s::%s\" is not a value type",
+ g_warning (G_STRLOC ": parameter %d of type '%s' for signal \"%s::%s\" is not a value type",
i + 1, type_debug_name (param_types[i]), type_debug_name (itype), name);
g_free (name);
SIGNAL_UNLOCK ();
}
if (return_type != G_TYPE_NONE && !G_TYPE_IS_VALUE (return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE))
{
- g_warning (G_STRLOC ": return value of type `%s' for signal \"%s::%s\" is not a value type",
+ g_warning (G_STRLOC ": return value of type '%s' for signal \"%s::%s\" is not a value type",
type_debug_name (return_type), type_debug_name (itype), name);
g_free (name);
SIGNAL_UNLOCK ();
if (return_type != G_TYPE_NONE &&
(signal_flags & (G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST | G_SIGNAL_RUN_CLEANUP)) == G_SIGNAL_RUN_FIRST)
{
- g_warning (G_STRLOC ": signal \"%s::%s\" has return type `%s' and is only G_SIGNAL_RUN_FIRST",
+ g_warning (G_STRLOC ": signal \"%s::%s\" has return type '%s' and is only G_SIGNAL_RUN_FIRST",
type_debug_name (itype), name, type_debug_name (return_type));
g_free (name);
SIGNAL_UNLOCK ();
for (emission = (node.flags & G_SIGNAL_NO_RECURSE) ? g_restart_emissions : g_recursive_emissions;
emission; emission = emission->next)
if (emission->ihint.signal_id == node.signal_id)
- g_critical (G_STRLOC ": signal \"%s\" being destroyed is currently in emission (instance `%p')",
+ g_critical (G_STRLOC ": signal \"%s\" being destroyed is currently in emission (instance '%p')",
node.name, emission->instance);
}
#endif
node = LOOKUP_SIGNAL_NODE (signal_id);
node_check_deprecated (node);
if (!g_type_is_a (instance_type, node->itype))
- g_warning ("%s: type `%s' cannot be overridden for signal id `%u'", G_STRLOC, type_debug_name (instance_type), signal_id);
+ g_warning ("%s: type '%s' cannot be overridden for signal id '%u'", G_STRLOC, type_debug_name (instance_type), signal_id);
else
{
ClassClosure *cc = signal_find_class_closure (node, instance_type);
if (cc && cc->instance_type == instance_type)
- g_warning ("%s: type `%s' is already overridden for signal id `%u'", G_STRLOC, type_debug_name (instance_type), signal_id);
+ g_warning ("%s: type '%s' is already overridden for signal id '%u'", G_STRLOC, type_debug_name (instance_type), signal_id);
else
signal_add_class_closure (node, instance_type, class_closure);
}
}
}
else
- g_warning ("%s: signal id `%u' cannot be chained from current emission stage for instance `%p'", G_STRLOC, node->signal_id, instance);
+ g_warning ("%s: signal id '%u' cannot be chained from current emission stage for instance '%p'", G_STRLOC, node->signal_id, instance);
}
else
- g_warning ("%s: no signal is currently being emitted for instance `%p'", G_STRLOC, instance);
+ g_warning ("%s: no signal is currently being emitted for instance '%p'", G_STRLOC, instance);
if (closure)
{
}
}
else
- g_warning ("%s: signal id `%u' cannot be chained from current emission stage for instance `%p'", G_STRLOC, node->signal_id, instance);
+ g_warning ("%s: signal id '%u' cannot be chained from current emission stage for instance '%p'", G_STRLOC, node->signal_id, instance);
}
else
- g_warning ("%s: no signal is currently being emitted for instance `%p'", G_STRLOC, instance);
+ g_warning ("%s: no signal is currently being emitted for instance '%p'", G_STRLOC, instance);
if (closure)
{
if (node)
{
if (detail && !(node->flags & G_SIGNAL_DETAILED))
- g_warning ("%s: signal id `%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
+ g_warning ("%s: signal id '%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
else if (!g_type_is_a (G_TYPE_FROM_INSTANCE (instance), node->itype))
- g_warning ("%s: signal id `%u' is invalid for instance `%p'", G_STRLOC, signal_id, instance);
+ g_warning ("%s: signal id '%u' is invalid for instance '%p'", G_STRLOC, signal_id, instance);
else
{
Handler *handler = handler_new (after);
}
}
else
- g_warning ("%s: signal id `%u' is invalid for instance `%p'", G_STRLOC, signal_id, instance);
+ g_warning ("%s: signal id '%u' is invalid for instance '%p'", G_STRLOC, signal_id, instance);
SIGNAL_UNLOCK ();
return handler_seq_no;
SignalNode *node = LOOKUP_SIGNAL_NODE (signal_id);
if (detail && !(node->flags & G_SIGNAL_DETAILED))
- g_warning ("%s: signal `%s' does not support details", G_STRLOC, detailed_signal);
+ g_warning ("%s: signal '%s' does not support details", G_STRLOC, detailed_signal);
else if (!g_type_is_a (itype, node->itype))
- g_warning ("%s: signal `%s' is invalid for instance `%p' of type `%s'",
+ g_warning ("%s: signal '%s' is invalid for instance '%p' of type '%s'",
G_STRLOC, detailed_signal, instance, g_type_name (itype));
else
{
}
}
else
- g_warning ("%s: signal `%s' is invalid for instance `%p' of type `%s'",
+ g_warning ("%s: signal '%s' is invalid for instance '%p' of type '%s'",
G_STRLOC, detailed_signal, instance, g_type_name (itype));
SIGNAL_UNLOCK ();
node_check_deprecated (node);
if (detail && !(node->flags & G_SIGNAL_DETAILED))
- g_warning ("%s: signal `%s' does not support details", G_STRLOC, detailed_signal);
+ g_warning ("%s: signal '%s' does not support details", G_STRLOC, detailed_signal);
else if (!g_type_is_a (itype, node->itype))
- g_warning ("%s: signal `%s' is invalid for instance `%p' of type `%s'",
+ g_warning ("%s: signal '%s' is invalid for instance '%p' of type '%s'",
G_STRLOC, detailed_signal, instance, g_type_name (itype));
else
{
}
}
else
- g_warning ("%s: signal `%s' is invalid for instance `%p' of type `%s'",
+ g_warning ("%s: signal '%s' is invalid for instance '%p' of type '%s'",
G_STRLOC, detailed_signal, instance, g_type_name (itype));
SIGNAL_UNLOCK ();
handler->block_count += 1;
}
else
- g_warning ("%s: instance `%p' has no handler with id `%lu'", G_STRLOC, instance, handler_id);
+ g_warning ("%s: instance '%p' has no handler with id '%lu'", G_STRLOC, instance, handler_id);
SIGNAL_UNLOCK ();
}
if (handler->block_count)
handler->block_count -= 1;
else
- g_warning (G_STRLOC ": handler `%lu' of instance `%p' is not blocked", handler_id, instance);
+ g_warning (G_STRLOC ": handler '%lu' of instance '%p' is not blocked", handler_id, instance);
}
else
- g_warning ("%s: instance `%p' has no handler with id `%lu'", G_STRLOC, instance, handler_id);
+ g_warning ("%s: instance '%p' has no handler with id '%lu'", G_STRLOC, instance, handler_id);
SIGNAL_UNLOCK ();
}
handler_unref_R (signal_id, instance, handler);
}
else
- g_warning ("%s: instance `%p' has no handler with id `%lu'", G_STRLOC, instance, handler_id);
+ g_warning ("%s: instance '%p' has no handler with id '%lu'", G_STRLOC, instance, handler_id);
SIGNAL_UNLOCK ();
}
if (!(node->flags & G_SIGNAL_DETAILED))
{
- g_warning ("%s: signal id `%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
+ g_warning ("%s: signal id '%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
SIGNAL_UNLOCK ();
return FALSE;
}
node = LOOKUP_SIGNAL_NODE (signal_id);
if (!node || !g_type_is_a (G_TYPE_FROM_INSTANCE (instance), node->itype))
{
- g_warning ("%s: signal id `%u' is invalid for instance `%p'", G_STRLOC, signal_id, instance);
+ g_warning ("%s: signal id '%u' is invalid for instance '%p'", G_STRLOC, signal_id, instance);
SIGNAL_UNLOCK ();
return;
}
#ifdef G_ENABLE_DEBUG
if (detail && !(node->flags & G_SIGNAL_DETAILED))
{
- g_warning ("%s: signal id `%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
+ g_warning ("%s: signal id '%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
SIGNAL_UNLOCK ();
return;
}
for (i = 0; i < node->n_params; i++)
if (!G_TYPE_CHECK_VALUE_TYPE (param_values + i, node->param_types[i] & ~G_SIGNAL_TYPE_STATIC_SCOPE))
{
- g_critical ("%s: value for `%s' parameter %u for signal \"%s\" is of type `%s'",
+ g_critical ("%s: value for '%s' parameter %u for signal \"%s\" is of type '%s'",
G_STRLOC,
type_debug_name (node->param_types[i]),
i,
{
if (!return_value)
{
- g_critical ("%s: return value `%s' for signal \"%s\" is (NULL)",
+ g_critical ("%s: return value '%s' for signal \"%s\" is (NULL)",
G_STRLOC,
type_debug_name (node->return_type),
node->name);
}
else if (!node->accumulator && !G_TYPE_CHECK_VALUE_TYPE (return_value, node->return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE))
{
- g_critical ("%s: return value `%s' for signal \"%s\" is of type `%s'",
+ g_critical ("%s: return value '%s' for signal \"%s\" is of type '%s'",
G_STRLOC,
type_debug_name (node->return_type),
node->name,
node = LOOKUP_SIGNAL_NODE (signal_id);
if (!node || !g_type_is_a (G_TYPE_FROM_INSTANCE (instance), node->itype))
{
- g_warning ("%s: signal id `%u' is invalid for instance `%p'", G_STRLOC, signal_id, instance);
+ g_warning ("%s: signal id '%u' is invalid for instance '%p'", G_STRLOC, signal_id, instance);
SIGNAL_UNLOCK ();
return;
}
#ifndef G_DISABLE_CHECKS
if (detail && !(node->flags & G_SIGNAL_DETAILED))
{
- g_warning ("%s: signal id `%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
+ g_warning ("%s: signal id '%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
SIGNAL_UNLOCK ();
return;
}
va_end (var_args);
}
else
- g_warning ("%s: signal name `%s' is invalid for instance `%p' of type `%s'",
+ g_warning ("%s: signal name '%s' is invalid for instance '%p' of type '%s'",
G_STRLOC, detailed_signal, instance, g_type_name (itype));
}
static const gchar _action[] = " invalidly modified type "; \
gpointer _arg = (gpointer) (arg); const gchar *_tname = (type_name), *_fname = (func); \
if (_arg) \
- g_error ("%s(%p)%s`%s'", _fname, _arg, _action, _tname); \
+ g_error ("%s(%p)%s'%s'", _fname, _arg, _action, _tname); \
else \
- g_error ("%s()%s`%s'", _fname, _action, _tname); \
+ g_error ("%s()%s'%s'", _fname, _action, _tname); \
}G_STMT_END
#define g_assert_type_system_initialized() \
g_assert (static_quark_type_flags)
*/
if (!plugin)
{
- g_warning ("plugin handle for type `%s' is NULL",
+ g_warning ("plugin handle for type '%s' is NULL",
type_name);
return FALSE;
}
if (!G_IS_TYPE_PLUGIN (plugin))
{
- g_warning ("plugin pointer (%p) for type `%s' is invalid",
+ g_warning ("plugin pointer (%p) for type '%s' is invalid",
plugin, type_name);
return FALSE;
}
if (need_complete_type_info && !G_TYPE_PLUGIN_GET_CLASS (plugin)->complete_type_info)
{
- g_warning ("plugin for type `%s' has no complete_type_info() implementation",
+ g_warning ("plugin for type '%s' has no complete_type_info() implementation",
type_name);
return FALSE;
}
if (need_complete_interface_info && !G_TYPE_PLUGIN_GET_CLASS (plugin)->complete_interface_info)
{
- g_warning ("plugin for type `%s' has no complete_interface_info() implementation",
+ g_warning ("plugin for type '%s' has no complete_interface_info() implementation",
type_name);
return FALSE;
}
if (!type_name[0] || !type_name[1] || !type_name[2])
{
- g_warning ("type name `%s' is too short", type_name);
+ g_warning ("type name '%s' is too short", type_name);
return FALSE;
}
/* check the first letter */
strchr (extra_chars, p[0]));
if (!name_valid)
{
- g_warning ("type name `%s' contains invalid characters", type_name);
+ g_warning ("type name '%s' contains invalid characters", type_name);
return FALSE;
}
if (g_type_from_name (type_name))
{
- g_warning ("cannot register existing type `%s'", type_name);
+ g_warning ("cannot register existing type '%s'", type_name);
return FALSE;
}
pnode = lookup_type_node_I (parent_type);
if (!pnode)
{
- g_warning ("cannot derive type `%s' from invalid parent type `%s'",
+ g_warning ("cannot derive type '%s' from invalid parent type '%s'",
type_name,
type_descriptive_name_I (parent_type));
return FALSE;
/* ensure flat derivability */
if (!(finfo->type_flags & G_TYPE_FLAG_DERIVABLE))
{
- g_warning ("cannot derive `%s' from non-derivable parent type `%s'",
+ g_warning ("cannot derive '%s' from non-derivable parent type '%s'",
type_name,
NODE_NAME (pnode));
return FALSE;
if (parent_type != NODE_FUNDAMENTAL_TYPE (pnode) &&
!(finfo->type_flags & G_TYPE_FLAG_DEEP_DERIVABLE))
{
- g_warning ("cannot derive `%s' from non-fundamental parent type `%s'",
+ g_warning ("cannot derive '%s' from non-fundamental parent type '%s'",
type_name,
NODE_NAME (pnode));
return FALSE;
value_table->value_peek_pointer ||
value_table->collect_format || value_table->collect_value ||
value_table->lcopy_format || value_table->lcopy_value)
- g_warning ("cannot handle uninitializable values of type `%s'",
+ g_warning ("cannot handle uninitializable values of type '%s'",
type_name);
return FALSE;
}
if (!value_table->value_free)
{
/* +++ optional +++
- * g_warning ("missing `value_free()' for type `%s'", type_name);
+ * g_warning ("missing 'value_free()' for type '%s'", type_name);
* return FALSE;
*/
}
if (!value_table->value_copy)
{
- g_warning ("missing `value_copy()' for type `%s'", type_name);
+ g_warning ("missing 'value_copy()' for type '%s'", type_name);
return FALSE;
}
if ((value_table->collect_format || value_table->collect_value) &&
(!value_table->collect_format || !value_table->collect_value))
{
- g_warning ("one of `collect_format' and `collect_value()' is unspecified for type `%s'",
+ g_warning ("one of 'collect_format' and 'collect_value()' is unspecified for type '%s'",
type_name);
return FALSE;
}
if (value_table->collect_format && !check_collect_format_I (value_table->collect_format))
{
- g_warning ("the `%s' specification for type `%s' is too long or invalid",
+ g_warning ("the '%s' specification for type '%s' is too long or invalid",
"collect_format",
type_name);
return FALSE;
if ((value_table->lcopy_format || value_table->lcopy_value) &&
(!value_table->lcopy_format || !value_table->lcopy_value))
{
- g_warning ("one of `lcopy_format' and `lcopy_value()' is unspecified for type `%s'",
+ g_warning ("one of 'lcopy_format' and 'lcopy_value()' is unspecified for type '%s'",
type_name);
return FALSE;
}
if (value_table->lcopy_format && !check_collect_format_I (value_table->lcopy_format))
{
- g_warning ("the `%s' specification for type `%s' is too long or invalid",
+ g_warning ("the '%s' specification for type '%s' is too long or invalid",
"lcopy_format",
type_name);
return FALSE;
(info->instance_size || info->n_preallocs || info->instance_init))
{
if (pnode)
- g_warning ("cannot instantiate `%s', derived from non-instantiatable parent type `%s'",
+ g_warning ("cannot instantiate '%s', derived from non-instantiatable parent type '%s'",
type_name,
NODE_NAME (pnode));
else
- g_warning ("cannot instantiate `%s' as non-instantiatable fundamental",
+ g_warning ("cannot instantiate '%s' as non-instantiatable fundamental",
type_name);
return FALSE;
}
info->class_size || info->base_init || info->base_finalize))
{
if (pnode)
- g_warning ("cannot create class for `%s', derived from non-classed parent type `%s'",
+ g_warning ("cannot create class for '%s', derived from non-classed parent type '%s'",
type_name,
NODE_NAME (pnode));
else
- g_warning ("cannot create class for `%s' as non-classed fundamental",
+ g_warning ("cannot create class for '%s' as non-classed fundamental",
type_name);
return FALSE;
}
/* check interface size */
if (is_interface && info->class_size < sizeof (GTypeInterface))
{
- g_warning ("specified interface size for type `%s' is smaller than `GTypeInterface' size",
+ g_warning ("specified interface size for type '%s' is smaller than 'GTypeInterface' size",
type_name);
return FALSE;
}
{
if (info->class_size < sizeof (GTypeClass))
{
- g_warning ("specified class size for type `%s' is smaller than `GTypeClass' size",
+ g_warning ("specified class size for type '%s' is smaller than 'GTypeClass' size",
type_name);
return FALSE;
}
if (pnode && info->class_size < pnode->data->class.class_size)
{
- g_warning ("specified class size for type `%s' is smaller "
- "than the parent type's `%s' class size",
+ g_warning ("specified class size for type '%s' is smaller "
+ "than the parent type's '%s' class size",
type_name,
NODE_NAME (pnode));
return FALSE;
{
if (info->instance_size < sizeof (GTypeInstance))
{
- g_warning ("specified instance size for type `%s' is smaller than `GTypeInstance' size",
+ g_warning ("specified instance size for type '%s' is smaller than 'GTypeInstance' size",
type_name);
return FALSE;
}
if (pnode && info->instance_size < pnode->data->instance.instance_size)
{
- g_warning ("specified instance size for type `%s' is smaller "
- "than the parent type's `%s' instance size",
+ g_warning ("specified instance size for type '%s' is smaller "
+ "than the parent type's '%s' instance size",
type_name,
NODE_NAME (pnode));
return FALSE;
if (!node || !node->is_instantiatable)
{
- g_warning ("cannot add interfaces to invalid (non-instantiatable) type `%s'",
+ g_warning ("cannot add interfaces to invalid (non-instantiatable) type '%s'",
type_descriptive_name_I (instance_type));
return FALSE;
}
if (!iface || !NODE_IS_IFACE (iface))
{
- g_warning ("cannot add invalid (non-interface) type `%s' to type `%s'",
+ g_warning ("cannot add invalid (non-interface) type '%s' to type '%s'",
type_descriptive_name_I (iface_type),
NODE_NAME (node));
return FALSE;
if (NODE_PARENT_TYPE (tnode) && !type_lookup_iface_entry_L (node, tnode))
{
/* 2001/7/31:timj: erk, i guess this warning is junk as interface derivation is flat */
- g_warning ("cannot add sub-interface `%s' to type `%s' which does not conform to super-interface `%s'",
+ g_warning ("cannot add sub-interface '%s' to type '%s' which does not conform to super-interface '%s'",
NODE_NAME (iface),
NODE_NAME (node),
NODE_NAME (tnode));
tnode = find_conforming_child_type_L (node, iface); /* tnode is_a node */
if (tnode)
{
- g_warning ("cannot add interface type `%s' to type `%s', since type `%s' already conforms to interface",
+ g_warning ("cannot add interface type '%s' to type '%s', since type '%s' already conforms to interface",
NODE_NAME (iface),
NODE_NAME (node),
NODE_NAME (tnode));
tnode = lookup_type_node_I (prerequisites[i]);
if (!type_node_is_a_L (node, tnode))
{
- g_warning ("cannot add interface type `%s' to type `%s' which does not conform to prerequisite `%s'",
+ g_warning ("cannot add interface type '%s' to type '%s' which does not conform to prerequisite '%s'",
NODE_NAME (iface),
NODE_NAME (node),
NODE_NAME (tnode));
{
if ((info->interface_finalize || info->interface_data) && !info->interface_init)
{
- g_warning ("interface type `%s' for type `%s' comes without initializer",
+ g_warning ("interface type '%s' for type '%s' comes without initializer",
NODE_NAME (iface),
type_descriptive_name_I (instance_type));
return FALSE;
prerequisite_node = lookup_type_node_I (prerequisite_type);
if (!iface || !prerequisite_node || !NODE_IS_IFACE (iface))
{
- g_warning ("interface type `%s' or prerequisite type `%s' invalid",
+ g_warning ("interface type '%s' or prerequisite type '%s' invalid",
type_descriptive_name_I (interface_type),
type_descriptive_name_I (prerequisite_type));
return;
if (holders)
{
G_WRITE_UNLOCK (&type_rw_lock);
- g_warning ("unable to add prerequisite `%s' to interface `%s' which is already in use for `%s'",
+ g_warning ("unable to add prerequisite '%s' to interface '%s' which is already in use for '%s'",
type_descriptive_name_I (prerequisite_type),
type_descriptive_name_I (interface_type),
type_descriptive_name_I (holders->instance_type));
if (prnode->is_instantiatable)
{
G_WRITE_UNLOCK (&type_rw_lock);
- g_warning ("adding prerequisite `%s' to interface `%s' conflicts with existing prerequisite `%s'",
+ g_warning ("adding prerequisite '%s' to interface '%s' conflicts with existing prerequisite '%s'",
type_descriptive_name_I (prerequisite_type),
type_descriptive_name_I (interface_type),
type_descriptive_name_I (NODE_TYPE (prnode)));
else
{
G_WRITE_UNLOCK (&type_rw_lock);
- g_warning ("prerequisite `%s' for interface `%s' is neither instantiatable nor interface",
+ g_warning ("prerequisite '%s' for interface '%s' is neither instantiatable nor interface",
type_descriptive_name_I (prerequisite_type),
type_descriptive_name_I (interface_type));
}
node = lookup_type_node_I (type);
if (!node || !node->is_instantiatable)
{
- g_error ("cannot create new instance of invalid (non-instantiatable) type `%s'",
+ g_error ("cannot create new instance of invalid (non-instantiatable) type '%s'",
type_descriptive_name_I (type));
}
/* G_TYPE_IS_ABSTRACT() is an external call: _U */
if (!node->mutatable_check_cache && G_TYPE_IS_ABSTRACT (type))
{
- g_error ("cannot create instance of abstract (non-instantiatable) type `%s'",
+ g_error ("cannot create instance of abstract (non-instantiatable) type '%s'",
type_descriptive_name_I (type));
}
node = lookup_type_node_I (class->g_type);
if (!node || !node->is_instantiatable || !node->data || node->data->class.class != (gpointer) class)
{
- g_warning ("cannot free instance of invalid (non-instantiatable) type `%s'",
+ g_warning ("cannot free instance of invalid (non-instantiatable) type '%s'",
type_descriptive_name_I (class->g_type));
return;
}
/* G_TYPE_IS_ABSTRACT() is an external call: _U */
if (!node->mutatable_check_cache && G_TYPE_IS_ABSTRACT (NODE_TYPE (node)))
{
- g_warning ("cannot free instance of abstract (non-instantiatable) type `%s'",
+ g_warning ("cannot free instance of abstract (non-instantiatable) type '%s'",
NODE_NAME (node));
return;
}
if (!node->data || NODE_REFCOUNT (node) == 0)
{
- g_warning ("cannot drop last reference to unreferenced type `%s'",
+ g_warning ("cannot drop last reference to unreferenced type '%s'",
NODE_NAME (node));
return;
}
{
if (!node->plugin)
{
- g_warning ("static type `%s' unreferenced too often",
+ g_warning ("static type '%s' unreferenced too often",
NODE_NAME (node));
return;
}
if ((type_id & TYPE_ID_MASK) ||
type_id > G_TYPE_FUNDAMENTAL_MAX)
{
- g_warning ("attempt to register fundamental type `%s' with invalid type id (%" G_GSIZE_FORMAT ")",
+ g_warning ("attempt to register fundamental type '%s' with invalid type id (%" G_GSIZE_FORMAT ")",
type_name,
type_id);
return 0;
if ((finfo->type_flags & G_TYPE_FLAG_INSTANTIATABLE) &&
!(finfo->type_flags & G_TYPE_FLAG_CLASSED))
{
- g_warning ("cannot register instantiatable fundamental type `%s' as non-classed",
+ g_warning ("cannot register instantiatable fundamental type '%s' as non-classed",
type_name);
return 0;
}
if (lookup_type_node_I (type_id))
{
- g_warning ("cannot register existing fundamental type `%s' (as `%s')",
+ g_warning ("cannot register existing fundamental type '%s' (as '%s')",
type_descriptive_name_I (type_id),
type_name);
return 0;
return 0;
if (info->class_finalize)
{
- g_warning ("class finalizer specified for static type `%s'",
+ g_warning ("class finalizer specified for static type '%s'",
type_name);
return 0;
}
node = lookup_type_node_I (type);
if (!node || !node->is_classed)
{
- g_warning ("cannot retrieve class for invalid (unclassed) type `%s'",
+ g_warning ("cannot retrieve class for invalid (unclassed) type '%s'",
type_descriptive_name_I (type));
return NULL;
}
if (node && node->is_classed && NODE_REFCOUNT (node))
type_data_unref_U (node, FALSE);
else
- g_warning ("cannot unreference class of invalid (unclassed) type `%s'",
+ g_warning ("cannot unreference class of invalid (unclassed) type '%s'",
type_descriptive_name_I (class->g_type));
}
if (node && node->is_classed && NODE_REFCOUNT (node))
type_data_unref_U (node, TRUE);
else
- g_warning ("cannot unreference class of invalid (unclassed) type `%s'",
+ g_warning ("cannot unreference class of invalid (unclassed) type '%s'",
type_descriptive_name_I (class->g_type));
}
class = node->data->class.class;
}
else if (NODE_PARENT_TYPE (node))
- g_warning (G_STRLOC ": invalid class pointer `%p'", g_class);
+ g_warning (G_STRLOC ": invalid class pointer '%p'", g_class);
return class;
}
if (node && node->is_instantiatable && iface)
type_lookup_iface_vtable_I (node, iface, &vtable);
else
- g_warning (G_STRLOC ": invalid class pointer `%p'", class);
+ g_warning (G_STRLOC ": invalid class pointer '%p'", class);
return vtable;
}
if (node && node->is_instantiatable && iface)
type_lookup_iface_vtable_I (node, iface, &vtable);
else if (node)
- g_warning (G_STRLOC ": invalid interface pointer `%p'", g_iface);
+ g_warning (G_STRLOC ": invalid interface pointer '%p'", g_iface);
return vtable;
}
g_return_if_fail (node != NULL);
if ((flags & TYPE_FLAG_MASK) && node->is_classed && node->data && node->data->class.class)
- g_warning ("tagging type `%s' as abstract after class initialization", NODE_NAME (node));
+ g_warning ("tagging type '%s' as abstract after class initialization", NODE_NAME (node));
dflags = GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags));
dflags |= flags;
type_set_qdata_W (node, static_quark_type_flags, GUINT_TO_POINTER (dflags));
return type_instance;
if (is_instantiatable)
- g_warning ("invalid cast from `%s' to `%s'",
+ g_warning ("invalid cast from '%s' to '%s'",
type_descriptive_name_I (type_instance->g_class->g_type),
type_descriptive_name_I (iface_type));
else
- g_warning ("invalid uninstantiatable type `%s' in cast to `%s'",
+ g_warning ("invalid uninstantiatable type '%s' in cast to '%s'",
type_descriptive_name_I (type_instance->g_class->g_type),
type_descriptive_name_I (iface_type));
}
else
- g_warning ("invalid unclassed pointer in cast to `%s'",
+ g_warning ("invalid unclassed pointer in cast to '%s'",
type_descriptive_name_I (iface_type));
}
return type_class;
if (is_classed)
- g_warning ("invalid class cast from `%s' to `%s'",
+ g_warning ("invalid class cast from '%s' to '%s'",
type_descriptive_name_I (type_class->g_type),
type_descriptive_name_I (is_a_type));
else
- g_warning ("invalid unclassed type `%s' in class cast to `%s'",
+ g_warning ("invalid unclassed type '%s' in class cast to '%s'",
type_descriptive_name_I (type_class->g_type),
type_descriptive_name_I (is_a_type));
}
else
- g_warning ("invalid class cast from (NULL) pointer to `%s'",
+ g_warning ("invalid class cast from (NULL) pointer to '%s'",
type_descriptive_name_I (is_a_type));
return type_class;
}
if (node && node->is_instantiatable)
return TRUE;
- g_warning ("instance of invalid non-instantiatable type `%s'",
+ g_warning ("instance of invalid non-instantiatable type '%s'",
type_descriptive_name_I (type_instance->g_class->g_type));
}
else
return vtable;
if (!node)
- g_warning (G_STRLOC ": type id `%" G_GSIZE_FORMAT "' is invalid", type);
+ g_warning (G_STRLOC ": type id '%" G_GSIZE_FORMAT "' is invalid", type);
if (!has_refed_data)
- g_warning ("can't peek value table for type `%s' which is not currently referenced",
+ g_warning ("can't peek value table for type '%s' which is not currently referenced",
type_descriptive_name_I (type));
return NULL;
node = lookup_type_node_I (private_type);
if (G_UNLIKELY (!node || !node->is_instantiatable))
{
- g_warning ("instance of invalid non-instantiatable type `%s'",
+ g_warning ("instance of invalid non-instantiatable type '%s'",
type_descriptive_name_I (instance->g_class->g_type));
return NULL;
}
class_node = lookup_type_node_I (klass->g_type);
if (G_UNLIKELY (!class_node || !class_node->is_classed))
{
- g_warning ("class of invalid type `%s'",
+ g_warning ("class of invalid type '%s'",
type_descriptive_name_I (klass->g_type));
return NULL;
}
value_table->value_init (value);
}
else if (G_VALUE_TYPE (value))
- g_warning ("%s: cannot initialize GValue with type `%s', the value has already been initialized as `%s'",
+ g_warning ("%s: cannot initialize GValue with type '%s', the value has already been initialized as '%s'",
G_STRLOC,
g_type_name (g_type),
g_type_name (G_VALUE_TYPE (value)));
else /* !G_TYPE_IS_VALUE (g_type) */
- g_warning ("%s: cannot initialize GValue with type `%s', %s",
+ g_warning ("%s: cannot initialize GValue with type '%s', %s",
G_STRLOC,
g_type_name (g_type),
g_type_value_table_peek (g_type) ?
#if 0 /* let transform function replacement be a valid operation */
if (g_bsearch_array_lookup (transform_array, &transform_bconfig, &entry))
- g_warning ("reregistering value transformation function (%p) for `%s' to `%s'",
+ g_warning ("reregistering value transformation function (%p) for '%s' to '%s'",
transform_func,
g_type_name (src_type),
g_type_name (dest_type));
gint8 *int8_p = collect_values[0].v_pointer;
if (!int8_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*int8_p = value->data[0].v_int;
gboolean *bool_p = collect_values[0].v_pointer;
if (!bool_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*bool_p = value->data[0].v_int;
gint *int_p = collect_values[0].v_pointer;
if (!int_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*int_p = value->data[0].v_int;
glong *long_p = collect_values[0].v_pointer;
if (!long_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*long_p = value->data[0].v_long;
gint64 *int64_p = collect_values[0].v_pointer;
if (!int64_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*int64_p = value->data[0].v_int64;
gfloat *float_p = collect_values[0].v_pointer;
if (!float_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*float_p = value->data[0].v_float;
gdouble *double_p = collect_values[0].v_pointer;
if (!double_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*double_p = value->data[0].v_double;
gchar **string_p = collect_values[0].v_pointer;
if (!string_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
if (!value->data[0].v_pointer)
*string_p = NULL;
gpointer *pointer_p = collect_values[0].v_pointer;
if (!pointer_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
*pointer_p = value->data[0].v_pointer;
GVariant **variant_p = collect_values[0].v_pointer;
if (!variant_p)
- return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+ return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
if (!value->data[0].v_pointer)
*variant_p = NULL;
{
if (input[0] == '\n')
{
- g_print("Enter a date to parse and press enter, or type `POSIX':\n");
+ g_print("Enter a date to parse and press enter, or type 'POSIX':\n");
continue;
}
while (*s) {
g_date_set_parse(d, *s);
- g_print("POSIXy parse test `%s' ...", *s);
+ g_print("POSIXy parse test '%s' ...", *s);
if (!g_date_valid(d))
{
{
gchar buf[256];
- g_date_strftime(buf,100," parsed `%x' (%B %d %Y)\n",
+ g_date_strftime(buf,100," parsed '%x' (%B %d %Y)\n",
d);
g_print("%s", buf);
}
{
gchar buf[256];
- g_date_strftime(buf,100,"Parsed: `%x' (%B %d %Y)\n",
+ g_date_strftime(buf,100,"Parsed: '%x' (%B %d %Y)\n",
d);
g_print("%s", buf);
}