static gboolean
parse_reviews (GsPlugin *plugin, JsonParser *parser, GsApp *app, GCancellable *cancellable, GError **error)
{
GsAuth *auth;
JsonArray *array;
const gchar *consumer_key = NULL;
guint i;
auth = gs_plugin_get_auth_by_id (plugin, "ubuntuone");
if (auth != NULL)
consumer_key = gs_auth_get_metadata_item (auth, "consumer-key");
if (!JSON_NODE_HOLDS_ARRAY (json_parser_get_root (parser)))
return FALSE;
array = json_node_get_array (json_parser_get_root (parser));
for (i = 0; i < json_array_get_length (array); i++) {
g_autoptr(AsReview) review = NULL;
/* Read in from JSON... (skip bad entries) */
review = as_review_new ();
if (parse_review (review, consumer_key, json_array_get_element (array, i)))
gs_app_add_review (app, review);
}
return TRUE;
}
/**
* json_reader_count_elements:
* @reader: a #JsonReader
*
* Counts the elements of the current position, if @reader is
* positioned on an array
*
* Return value: the number of elements, or -1. In case of failure
* the #JsonReader is set in an error state
*
* Since: 0.12
*/
gint
json_reader_count_elements (JsonReader *reader)
{
JsonReaderPrivate *priv;
g_return_val_if_fail (JSON_IS_READER (reader), -1);
priv = reader->priv;
if (priv->current_node == NULL)
{
json_reader_set_error (reader, JSON_READER_ERROR_INVALID_NODE,
_("No node available at the current position"));
return -1;
}
if (!JSON_NODE_HOLDS_ARRAY (priv->current_node))
{
json_reader_set_error (reader, JSON_READER_ERROR_NO_ARRAY,
_("The current position holds a '%s' and not an array"),
json_node_type_get_name (JSON_NODE_TYPE (priv->current_node)));
return -1;
}
return json_array_get_length (json_node_get_array (priv->current_node));
}
/**
* wbl_string_set_union_dependencies:
* @set: (transfer floating): a #WblStringSet
* @dependencies: a JSON object mapping property names to arrays of property
* names (or to object instances)
*
* Calculate the transitive union of the dependencies of the elements of an
* initial @set and return it as a new #WblStringSet. @dependencies is treated
* as a map of property names to dependencies; the function essentially
* calculates
* output = set ∪ ⋃_{d ϵ output} dependencies(d)
*
* Complexity: O(S * D) in the size S of @set and number D of @dependencies keys
* Returns: the transitive dependency set of @set
* Since: 0.2.0
*/
WblStringSet *
wbl_string_set_union_dependencies (WblStringSet *set,
JsonObject *dependencies)
{
WblStringSet *output = NULL;
guint old_output_size;
g_return_val_if_fail (_wbl_string_set_is_valid (set), NULL);
g_return_val_if_fail (dependencies != NULL, NULL);
output = _wbl_string_set_new ();
wbl_string_set_ref_sink (set);
do {
GHashTableIter iter;
const gchar *property_name;
old_output_size = g_hash_table_size (output->set);
g_hash_table_iter_init (&iter, set->set);
while (g_hash_table_iter_next (&iter, (gpointer *) &property_name, NULL)) {
JsonNode *dependency_value;
guint i, len;
/* Add the dependency key. */
_wbl_string_set_add (output, property_name);
/* See if there are any values associated with the
* dependency key. */
dependency_value = json_object_get_member (dependencies,
property_name);
/* Ignore schema dependencies; we only care about
* property dependencies, for which we add all
* dependent properties. */
if (dependency_value != NULL &&
JSON_NODE_HOLDS_ARRAY (dependency_value)) {
JsonArray *array;
array = json_node_get_array (dependency_value);
for (i = 0, len = json_array_get_length (array);
i < len;
i++) {
_wbl_string_set_add (output,
json_array_get_string_element (array, i));
}
}
}
} while (old_output_size != g_hash_table_size (output->set));
wbl_string_set_unref (set);
output->state |= STATE_IMMUTABLE;
return output;
}
/* This function is synchronous! Blocking once at startup seems pretty
* reasonable and allows us to avoid any complexity re. races
*/
static void
mex_queue_model_load (MexQueueModel *model)
{
JsonParser *parser;
gchar *filename;
GError *error = NULL;
JsonNode *root;
JsonArray *array;
gint i = 0;
filename = _queue_file_name ();
if (!g_file_test (filename, G_FILE_TEST_EXISTS))
{
g_free (filename);
return;
}
parser = json_parser_new ();
if (!json_parser_load_from_file (parser, filename, &error))
{
g_warning (G_STRLOC ": error populating from file: %s",
error->message);
g_clear_error (&error);
goto out;
}
root = json_parser_get_root (parser);
if (!JSON_NODE_HOLDS_ARRAY (root))
{
g_warning (G_STRLOC ": JSON data not of expected format!");
goto out;
}
array = json_node_get_array (root);
for (i = 0; i < json_array_get_length (array); i++)
{
MexContent *content;
JsonNode *node;
node = json_array_get_element (array, i);
content = (MexContent *)json_gobject_deserialize (MEX_TYPE_PROGRAM,
node);
mex_model_add_content (MEX_MODEL (model), content);
}
out:
g_free (filename);
g_object_unref (parser);
}
/**
* json_reader_is_array:
* @reader: a #JsonReader
*
* Checks whether the @reader is currently on an array
*
* Return value: %TRUE if the #JsonReader is on an array, and %FALSE
* otherwise
*
* Since: 0.12
*/
gboolean
json_reader_is_array (JsonReader *reader)
{
g_return_val_if_fail (JSON_IS_READER (reader), FALSE);
json_reader_return_val_if_error_set (reader, FALSE);
if (reader->priv->current_node == NULL)
return FALSE;
return JSON_NODE_HOLDS_ARRAY (reader->priv->current_node);
}
void
cockpit_package_dump (void)
{
GHashTable *listing;
GHashTable *by_name;
GHashTableIter iter;
CockpitPackage *package;
GList *names, *l;
const gchar *prefix;
JsonArray *array;
guint i;
listing = cockpit_package_listing (NULL);
by_name = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_iter_init (&iter, listing);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&package))
g_hash_table_replace (by_name, package->name, package);
names = g_hash_table_get_keys (by_name);
names = g_list_sort (names, (GCompareFunc)strcmp);
for (l = names; l != NULL; l = g_list_next (l))
{
package = g_hash_table_lookup (by_name, l->data);
g_print ("%s: %s\n", package->name, package->directory);
if (package->checksum)
g_print (" checksum: %s\n", package->checksum);
if (package->alias)
{
prefix = " alias: ";
if (JSON_NODE_HOLDS_ARRAY (package->alias))
{
array = json_node_get_array (package->alias);
for (i = 0; i < json_array_get_length (array); i++)
{
g_print ("%s%s\n", prefix, json_array_get_string_element (array, i));
prefix = " ";
}
}
else
{
g_print ("%s%s\n", prefix, json_node_get_string (package->alias));
}
}
}
g_list_free (names);
g_hash_table_unref (by_name);
g_hash_table_unref (listing);
}
static void
snra_json_node_into_val (JsonNode *element_node, GValue *v)
{
if (JSON_NODE_HOLDS_OBJECT (element_node)) {
GstStructure *child = snra_json_to_gst_structure (element_node);
g_value_init (v, GST_TYPE_STRUCTURE);
gst_value_set_structure (v, child);
} else if (JSON_NODE_HOLDS_ARRAY (element_node)) {
JsonArray *arr = json_node_get_array (element_node);
g_value_init (v, GST_TYPE_ARRAY);
json_array_foreach_element (arr,
(JsonArrayForeach) snra_json_array_add_to_val, v);
} else {
json_node_get_value (element_node, v);
}
}
/**
* json_reader_count_elements:
* @reader: a #JsonReader
*
* Counts the elements of the current position, if @reader is
* positioned on an array
*
* Return value: the number of elements, or -1. In case of failure
* the #JsonReader is set in an error state
*
* Since: 0.12
*/
gint
json_reader_count_elements (JsonReader *reader)
{
JsonReaderPrivate *priv;
g_return_val_if_fail (JSON_IS_READER (reader), -1);
priv = reader->priv;
if (priv->current_node == NULL)
return -1;
if (!JSON_NODE_HOLDS_ARRAY (priv->current_node))
return -1;
return json_array_get_length (json_node_get_array (priv->current_node));
}
static void show_obj_value (gpointer data, gpointer p)
{
JsonNode *node = data;
struct jsdata *jsd = p;
if (JSON_NODE_HOLDS_ARRAY(node)) {
fprintf(stderr, " show_obj_value: got array!\n");
}
if (node != NULL && !*jsd->err) {
*jsd->err = output_json_node_value(node, jsd->prn);
if (!*jsd->err) {
*jsd->n_objects += 1;
pputc(jsd->prn, '\n');
}
}
}
/**
* json_object_get_array_member:
* @object: a #JsonObject
* @member_name: the name of the member
*
* Convenience function that retrieves the array
* stored in @member_name of @object
*
* See also: json_object_get_member()
*
* Return value: (transfer none): the array inside the object's member
*
* Since: 0.8
*/
JsonArray *
json_object_get_array_member (JsonObject *object,
const gchar *member_name)
{
JsonNode *node;
g_return_val_if_fail (object != NULL, NULL);
g_return_val_if_fail (member_name != NULL, NULL);
node = object_get_member_internal (object, member_name);
g_return_val_if_fail (node != NULL, NULL);
g_return_val_if_fail (JSON_NODE_HOLDS_ARRAY (node) || JSON_NODE_HOLDS_NULL (node), NULL);
if (JSON_NODE_HOLDS_NULL (node))
return NULL;
return json_node_get_array (node);
}
/**
* json_array_get_array_element:
* @array: a #JsonArray
* @index_: the index of the element to retrieve
*
* Conveniently retrieves the array from the element at @index_
* inside @array
*
* See also: json_array_get_element(), json_node_get_array()
*
* Return value: (transfer none): the array
*
* Since: 0.8
*/
JsonArray *
json_array_get_array_element (JsonArray *array,
guint index_)
{
JsonNode *node;
g_return_val_if_fail (array != NULL, NULL);
g_return_val_if_fail (index_ < array->elements->len, NULL);
node = g_ptr_array_index (array->elements, index_);
g_return_val_if_fail (node != NULL, NULL);
g_return_val_if_fail (JSON_NODE_HOLDS_ARRAY (node) || JSON_NODE_HOLDS_NULL (node), NULL);
if (JSON_NODE_HOLDS_NULL (node))
return NULL;
return json_node_get_array (node);
}
/**
* json_array_get_null_element:
* @array: a #JsonArray
* @index_: the index of the element to retrieve
*
* Conveniently retrieves whether the element at @index_ is set to null
*
* See also: json_array_get_element(), JSON_NODE_TYPE(), %JSON_NODE_NULL
*
* Return value: %TRUE if the element is null
*
* Since: 0.8
*/
gboolean
json_array_get_null_element (JsonArray *array,
guint index_)
{
JsonNode *node;
g_return_val_if_fail (array != NULL, FALSE);
g_return_val_if_fail (index_ < array->elements->len, FALSE);
node = g_ptr_array_index (array->elements, index_);
g_return_val_if_fail (node != NULL, FALSE);
if (JSON_NODE_HOLDS_NULL (node))
return TRUE;
if (JSON_NODE_HOLDS_ARRAY (node))
return json_node_get_array (node) == NULL;
if (JSON_NODE_HOLDS_OBJECT (node))
return json_node_get_object (node) == NULL;
return FALSE;
}
static gboolean
parse_histogram (const gchar *text, Histogram *histogram)
{
g_autoptr(JsonParser) parser = NULL;
JsonArray *array;
/* Histogram is a five element JSON array, e.g. "[1, 3, 5, 8, 4]" */
parser = json_parser_new ();
if (!json_parser_load_from_data (parser, text, -1, NULL))
return FALSE;
if (!JSON_NODE_HOLDS_ARRAY (json_parser_get_root (parser)))
return FALSE;
array = json_node_get_array (json_parser_get_root (parser));
if (json_array_get_length (array) != 5)
return FALSE;
histogram->one_star_count = (guint64) json_array_get_int_element (array, 0);
histogram->two_star_count = (guint64) json_array_get_int_element (array, 1);
histogram->three_star_count = (guint64) json_array_get_int_element (array, 2);
histogram->four_star_count = (guint64) json_array_get_int_element (array, 3);
histogram->five_star_count = (guint64) json_array_get_int_element (array, 4);
return TRUE;
}
/**
* json_object_get_null_member:
* @object: a #JsonObject
* @member_name: the name of the member
*
* Convenience function that checks whether the value
* stored in @member_name of @object is null
*
* See also: json_object_get_member()
*
* Return value: %TRUE if the value is null
*
* Since: 0.8
*/
gboolean
json_object_get_null_member (JsonObject *object,
const gchar *member_name)
{
JsonNode *node;
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (member_name != NULL, FALSE);
node = object_get_member_internal (object, member_name);
g_return_val_if_fail (node != NULL, FALSE);
if (JSON_NODE_HOLDS_NULL (node))
return TRUE;
if (JSON_NODE_HOLDS_OBJECT (node))
return json_node_get_object (node) == NULL;
if (JSON_NODE_HOLDS_ARRAY (node))
return json_node_get_array (node) == NULL;
return FALSE;
}
static gboolean
parse_review_entries (GsPlugin *plugin, JsonParser *parser, GError **error)
{
JsonArray *array;
guint i;
if (!JSON_NODE_HOLDS_ARRAY (json_parser_get_root (parser)))
return FALSE;
array = json_node_get_array (json_parser_get_root (parser));
for (i = 0; i < json_array_get_length (array); i++) {
const gchar *package_name;
Histogram histogram;
/* Read in from JSON... (skip bad entries) */
if (!parse_review_entry (json_array_get_element (array, i), &package_name, &histogram))
continue;
/* ...write into the database (abort everything if can't write) */
if (!set_package_stats (plugin, package_name, &histogram, error))
return FALSE;
}
return TRUE;
}
/**
* json_reader_read_element:
* @reader: a #JsonReader
* @index_: the index of the element
*
* Advances the cursor of @reader to the element @index_ of the array
* or the object at the current position.
*
* You can use the json_reader_get_value* family of functions to retrieve
* the value of the element; for instance:
*
* |[
* json_reader_read_element (reader, 0);
* int_value = json_reader_get_int_value (reader);
* ]|
*
* After reading the value, json_reader_end_element() should be called to
* reposition the cursor inside the #JsonReader, e.g.:
*
* |[
* json_reader_read_element (reader, 1);
* str_value = json_reader_get_string_value (reader);
* json_reader_end_element (reader);
*
* json_reader_read_element (reader, 2);
* str_value = json_reader_get_string_value (reader);
* json_reader_end_element (reader);
* ]|
*
* If @reader is not currently on an array or an object, or if the @index_ is
* bigger than the size of the array or the object, the #JsonReader will be
* put in an error state until json_reader_end_element() is called.
*
* Return value: %TRUE on success, and %FALSE otherwise
*
* Since: 0.12
*/
gboolean
json_reader_read_element (JsonReader *reader,
guint index_)
{
JsonReaderPrivate *priv;
g_return_val_if_fail (JSON_READER (reader), FALSE);
json_reader_return_val_if_error_set (reader, FALSE);
priv = reader->priv;
if (priv->current_node == NULL)
priv->current_node = priv->root;
if (!(JSON_NODE_HOLDS_ARRAY (priv->current_node) ||
JSON_NODE_HOLDS_OBJECT (priv->current_node)))
return json_reader_set_error (reader, JSON_READER_ERROR_NO_ARRAY,
"The current node is of type '%s', but "
"an array or an object was expected.",
json_node_type_name (priv->current_node));
switch (json_node_get_node_type (priv->current_node))
{
case JSON_NODE_ARRAY:
{
JsonArray *array = json_node_get_array (priv->current_node);
if (index_ >= json_array_get_length (array))
return json_reader_set_error (reader, JSON_READER_ERROR_INVALID_INDEX,
"The index '%d' is greater than the size "
"of the array at the current position.",
index_);
priv->previous_node = priv->current_node;
priv->current_node = json_array_get_element (array, index_);
}
break;
case JSON_NODE_OBJECT:
{
JsonObject *object = json_node_get_object (priv->current_node);
GList *members;
const gchar *name;
if (index_ >= json_object_get_size (object))
return json_reader_set_error (reader, JSON_READER_ERROR_INVALID_INDEX,
"The index '%d' is greater than the size "
"of the object at the current position.",
index_);
priv->previous_node = priv->current_node;
g_free (priv->current_member);
members = json_object_get_members (object);
name = g_list_nth_data (members, index_);
priv->current_node = json_object_get_member (object, name);
priv->current_member = g_strdup (name);
g_list_free (members);
}
break;
default:
g_assert_not_reached ();
return FALSE;
}
return TRUE;
}
static int real_json_get (JsonParser *parser, const char *pathstr,
int *n_objects, PRN *prn)
{
GError *gerr = NULL;
JsonNode *match, *node;
JsonPath *path;
GType ntype;
double x;
int err = 0;
*n_objects = 0;
node = json_parser_get_root(parser);
path = json_path_new();
if (!json_path_compile(path, pathstr, &gerr)) {
if (gerr != NULL) {
gretl_errmsg_sprintf("Failed to compile JsonPath: %s",
gerr->message);
g_error_free(gerr);
} else {
gretl_errmsg_set("Failed to compile JsonPath");
}
g_object_unref(path);
return E_DATA;
}
match = json_path_match(path, node);
if (match == NULL) {
/* FIXME : maybe return empty string? */
g_object_unref(path);
return E_DATA;
}
/* in case we get floating-point output */
gretl_push_c_numeric_locale();
if (JSON_NODE_HOLDS_ARRAY(match)) {
JsonArray *array;
array = json_node_get_array(match);
node = json_array_get_element(array, 0);
repeat:
if (node == NULL) {
gretl_errmsg_set("Failed to match JsonPath");
ntype = 0;
} else {
ntype = json_node_get_value_type(node);
}
if (!handled_type(ntype)) {
if (JSON_NODE_HOLDS_ARRAY(node)) {
array = json_node_get_array(node);
node = json_array_get_element(array, 0);
goto repeat;
} else {
gretl_errmsg_sprintf("Unhandled array type '%s'",
g_type_name(ntype));
err = E_DATA;
}
} else {
int i, n = json_array_get_length(array);
for (i=0; i<n; i++) {
node = json_array_get_element(array, i);
if (ntype == G_TYPE_STRING) {
pputs(prn, json_node_get_string(node));
} else {
x = json_node_get_double(node);
pprintf(prn, "%.15g", x);
}
if (n > 1) {
pputc(prn, '\n');
}
}
*n_objects = n;
}
} else {
ntype = json_node_get_value_type(match);
if (!handled_type(ntype)) {
gretl_errmsg_sprintf("Unhandled object type '%s'",
g_type_name(ntype));
err = E_DATA;
} else {
if (ntype == G_TYPE_STRING) {
pputs(prn, json_node_get_string(match));
} else {
x = json_node_get_double(match);
pprintf(prn, "%.15g", x);
}
*n_objects = 1;
}
}
gretl_pop_c_numeric_locale();
json_node_free(match);
g_object_unref(path);
return err;
}
static int real_json_get (JsonParser *parser, const char *pathstr,
int *n_objects, PRN *prn)
{
GError *gerr = NULL;
JsonNode *match, *node;
JsonPath *path;
GType ntype;
int err = 0;
*n_objects = 0;
node = json_parser_get_root(parser);
if (node == NULL || json_node_is_null(node)) {
gretl_errmsg_set("jsonget: got null root node");
return E_DATA;
}
path = json_path_new();
if (!json_path_compile(path, pathstr, &gerr)) {
if (gerr != NULL) {
gretl_errmsg_sprintf("jsonget: failed to compile JsonPath: %s",
gerr->message);
g_error_free(gerr);
} else {
gretl_errmsg_set("jsonget: failed to compile JsonPath");
}
g_object_unref(path);
return E_DATA;
}
match = json_path_match(path, node);
if (null_node(match)) {
/* FIXME : maybe return empty string? */
g_object_unref(path);
return E_DATA;
}
/* in case we get floating-point output */
gretl_push_c_numeric_locale();
if (JSON_NODE_HOLDS_ARRAY(match)) {
JsonArray *array = json_node_get_array(match);
int len = 0, index = 0;
if (non_empty_array(array)) {
len = json_array_get_length(array);
node = json_array_get_element(array, index);
} else {
node = NULL;
}
repeat:
if (null_node(node)) {
gretl_errmsg_set("jsonget: failed to match JsonPath");
ntype = 0;
err = E_DATA;
goto bailout;
} else {
ntype = json_node_get_value_type(node);
}
if (node != NULL && !handled_type(ntype)) {
if (JSON_NODE_HOLDS_ARRAY(node)) {
/* recurse on array type */
array = json_node_get_array(node);
if (non_empty_array(array)) {
node = json_array_get_element(array, 0);
goto repeat;
}
} else if (json_node_get_node_type(node) == JSON_NODE_OBJECT) {
err = excavate_json_object(node, n_objects, prn);
if (!err) {
if (index < len - 1) {
node = json_array_get_element(array, ++index);
goto repeat;
}
}
} else {
gretl_errmsg_sprintf("jsonget: unhandled array type '%s'",
g_type_name(ntype));
err = E_DATA;
}
} else if (array != NULL) {
int i, n = json_array_get_length(array);
for (i=0; i<n && !err; i++) {
node = json_array_get_element(array, i);
err = output_json_node_value(node, prn);
if (!err) {
*n_objects += 1;
if (n > 1) {
pputc(prn, '\n');
}
}
}
}
} else {
/* not an array-holding node */
err = output_json_node_value(match, prn);
if (!err) {
*n_objects += 1;
}
}
bailout:
gretl_pop_c_numeric_locale();
json_node_free(match);
g_object_unref(path);
return err;
}
static gboolean
catch_resource_group_api_parse_objects (CatchResourceGroup *group,
JsonNode *result,
guint *result_offset,
guint *n_resources,
GError **error)
{
CatchResourceGroupPrivate *priv;
CatchResource *resource;
JsonObject *obj;
JsonArray *array;
JsonNode *element;
gboolean set_first_page = FALSE;
gboolean ret = FALSE;
GType resource_type;
guint i;
guint length;
guint offset = 0;
ENTRY;
g_return_val_if_fail(CATCH_IS_RESOURCE_GROUP(group), FALSE);
g_return_val_if_fail(result != NULL, FALSE);
priv = group->priv;
g_object_freeze_notify(G_OBJECT(group));
if (!JSON_NODE_HOLDS_OBJECT(result) ||
!(obj = json_node_get_object(result)) ||
!json_object_has_member(obj, "objects") ||
!JSON_NODE_HOLDS_ARRAY(json_object_get_member(obj, "objects")) ||
!(array = json_object_get_array_member(obj, "objects"))) {
g_set_error(error, CATCH_API_ERROR, CATCH_API_ERROR_BAD_RESPONSE,
_("The resonse did not contain the objects array."));
GOTO(failure);
}
if (json_object_has_member(obj, "count") &&
JSON_NODE_HOLDS_VALUE(json_object_get_member(obj, "count"))) {
priv->count = json_object_get_int_member(obj, "count");
set_first_page = TRUE;
g_object_notify(G_OBJECT(group), "count");
}
if (json_object_has_member(obj, "offset") &&
JSON_NODE_HOLDS_VALUE(json_object_get_member(obj, "offset"))) {
offset = json_object_get_int_member(obj, "offset");
}
length = json_array_get_length(array);
for (i = 0; i < length; i++) {
element = json_array_get_element(array, i);
if (!(resource_type = object_peek_type(element))) {
g_set_error(error, CATCH_API_ERROR, CATCH_API_ERROR_BAD_RESPONSE,
_("The JSON object did not contain a \"type\" field."));
GOTO(failure);
}
resource = g_object_new(resource_type, NULL);
g_assert(CATCH_IS_RESOURCE(resource));
if (!catch_resource_load_from_json(resource, element, error)) {
g_object_unref(resource);
GOTO(failure);
}
catch_resource_group_set_resource(CATCH_RESOURCE_GROUP(group),
offset + i, resource);
g_object_unref(resource);
}
if (set_first_page) {
priv->first_page_size = length;
}
if (result_offset) {
*result_offset = offset;
}
if (n_resources) {
*n_resources = length;
}
ret = TRUE;
failure:
g_object_thaw_notify(G_OBJECT(group));
RETURN(ret);
}
GHashTable *
cockpit_package_listing (JsonArray **json)
{
JsonArray *root = NULL;
GHashTable *listing;
CockpitPackage *package;
GHashTable *ids;
JsonObject *object;
JsonArray *id;
GList *names, *l;
GList *packages;
const gchar *name;
JsonNode *node;
JsonArray *array;
guint i, length;
listing = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, cockpit_package_unref);
build_package_listing (listing);
/* Add aliases to the listing */
packages = g_hash_table_get_values (listing);
packages = g_list_sort (packages, compar_packages);
g_list_foreach (packages, (GFunc)cockpit_package_ref, NULL);
for (l = packages; l != NULL; l = g_list_next (l))
{
package = l->data;
node = json_object_get_member (package->manifest, "alias");
if (node)
{
/*
* Process and remove "alias" from the manifest, as it results in
* confusing and duplicated information for the front end.
*/
package->alias = node = json_node_copy (node);
json_object_remove_member (package->manifest, "alias");
if (JSON_NODE_HOLDS_ARRAY (node))
{
array = json_node_get_array (node);
length = json_array_get_length (array);
for (i = 0; i < length; i++)
add_alias_to_listing (listing, package, json_array_get_element (array, i));
}
else
{
add_alias_to_listing (listing, package, node);
}
}
}
g_list_free_full (packages, (GDestroyNotify)cockpit_package_unref);
/* Now wrap up the checksums */
finish_checksums (listing);
/* Add checksums to the listing */
packages = g_hash_table_get_values (listing);
g_list_foreach (packages, (GFunc)cockpit_package_ref, NULL);
for (l = packages; l != NULL; l = g_list_next (l))
{
package = l->data;
if (package->checksum && !g_hash_table_contains (listing, package->checksum))
{
g_hash_table_replace (listing, package->checksum, cockpit_package_ref (package));
g_debug ("%s: package has checksum: %s", package->name, package->checksum);
}
}
g_list_free_full (packages, (GDestroyNotify)cockpit_package_unref);
/* Build JSON packages block */
if (json)
{
*json = root = json_array_new ();
ids = g_hash_table_new (g_direct_hash, g_direct_equal);
names = g_hash_table_get_keys (listing);
names = g_list_sort (names, (GCompareFunc)strcmp);
for (l = names; l != NULL; l = g_list_next (l))
{
name = l->data;
package = g_hash_table_lookup (listing, name);
id = g_hash_table_lookup (ids, package);
if (!id)
{
object = json_object_new ();
id = json_array_new();
/* The actual package name always comes first */
json_object_set_array_member (object, "id", id);
json_array_add_string_element (id, package->name);
g_hash_table_insert (ids, package, id);
json_object_set_object_member (object, "manifest", json_object_ref (package->manifest));
json_array_add_object_element (root, object);
}
/* Other ways to refer to the package */
if (!g_str_equal (name, package->name))
json_array_add_string_element (id, name);
}
g_list_free (names);
g_hash_table_destroy (ids);
}
return listing;
}
static void
ide_compile_commands_load_worker (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
IdeCompileCommands *self = source_object;
GFile *gfile = task_data;
g_autoptr(JsonParser) parser = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GHashTable) info_by_file = NULL;
g_autoptr(GHashTable) directories_by_path = NULL;
g_autoptr(GPtrArray) vala_info = NULL;
g_autofree gchar *contents = NULL;
JsonNode *root;
JsonArray *ar;
gsize len = 0;
guint n_items;
IDE_ENTRY;
g_assert (G_IS_TASK (task));
g_assert (IDE_IS_COMPILE_COMMANDS (self));
g_assert (G_IS_FILE (gfile));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
parser = json_parser_new ();
if (!g_file_load_contents (gfile, cancellable, &contents, &len, NULL, &error) ||
!json_parser_load_from_data (parser, contents, len, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
IDE_EXIT;
}
if (NULL == (root = json_parser_get_root (parser)) ||
!JSON_NODE_HOLDS_ARRAY (root) ||
NULL == (ar = json_node_get_array (root)))
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Failed to extract commands, invalid json");
IDE_EXIT;
}
info_by_file = g_hash_table_new_full (g_file_hash,
(GEqualFunc)g_file_equal,
NULL,
compile_info_free);
directories_by_path = g_hash_table_new_full (g_str_hash,
g_str_equal,
NULL,
g_object_unref);
vala_info = g_ptr_array_new_with_free_func (compile_info_free);
n_items = json_array_get_length (ar);
for (guint i = 0; i < n_items; i++)
{
CompileInfo *info;
JsonNode *item;
JsonNode *value;
JsonObject *obj;
GFile *dir;
const gchar *directory = NULL;
const gchar *file = NULL;
const gchar *command = NULL;
item = json_array_get_element (ar, i);
/* Skip past this node if its invalid for some reason, so we
* can try to be tolerante of errors created by broken tooling.
*/
if (item == NULL ||
!JSON_NODE_HOLDS_OBJECT (item) ||
NULL == (obj = json_node_get_object (item)))
continue;
if (json_object_has_member (obj, "file") &&
NULL != (value = json_object_get_member (obj, "file")) &&
JSON_NODE_HOLDS_VALUE (value))
file = json_node_get_string (value);
if (json_object_has_member (obj, "directory") &&
NULL != (value = json_object_get_member (obj, "directory")) &&
JSON_NODE_HOLDS_VALUE (value))
directory = json_node_get_string (value);
if (json_object_has_member (obj, "command") &&
NULL != (value = json_object_get_member (obj, "command")) &&
JSON_NODE_HOLDS_VALUE (value))
command = json_node_get_string (value);
/* Ignore items that are missing something or other */
if (file == NULL || command == NULL || directory == NULL)
continue;
/* Try to reduce the number of GFile we have for directories */
if (NULL == (dir = g_hash_table_lookup (directories_by_path, directory)))
{
dir = g_file_new_for_path (directory);
g_hash_table_insert (directories_by_path, (gchar *)directory, dir);
}
info = g_slice_new (CompileInfo);
info->file = g_file_resolve_relative_path (dir, file);
info->directory = g_object_ref (dir);
info->command = g_strdup (command);
g_hash_table_replace (info_by_file, info->file, info);
/*
* We might need to keep a special copy of this for resolving .vala
* builds which won't be able ot be matched based on the filename. We
* keep all of them around right now in case we want to later on find
* the closest match based on directory.
*/
if (g_str_has_suffix (file, ".vala"))
{
info = g_slice_new (CompileInfo);
info->file = g_file_resolve_relative_path (dir, file);
info->directory = g_object_ref (dir);
info->command = g_strdup (command);
g_ptr_array_add (vala_info, info);
}
}
self->info_by_file = g_steal_pointer (&info_by_file);
self->vala_info = g_steal_pointer (&vala_info);
g_task_return_boolean (task, TRUE);
IDE_EXIT;
}
END_TEST
START_TEST(test_anitomy_parser_sample_data)
{
AnitomyElements* elements;
JsonObject* data = json_array_get_object_element(sample_array, _i);
const char* fname;
fname = json_object_get_string_member(data, "file_name");
anitomy_parse(anitomy, fname);
elements = anitomy_elements(anitomy);
//TODO: Handle arrays
if (json_object_has_member(data, "anime_title"))
{
const char* actual = json_object_get_string_member(data, "anime_title");
char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_ANIME_TITLE);
ck_assert_msg(strcmp(actual, parsed) == 0,
"Failed anime title: actual = %s, parsed = %s, filename = %s", actual, parsed, fname);
free(parsed);
}
if (json_object_has_member(data, "file_checksum"))
{
const char* actual = json_object_get_string_member(data, "file_checksum");
char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_FILE_CHECKSUM);
ck_assert_msg(strcmp(actual, parsed) == 0,
"Failed file checksum: actual = %s, parsed = %s, filename = %s", actual, parsed, fname);
free(parsed);
}
if (json_object_has_member(data, "file_extension"))
{
const char* actual = json_object_get_string_member(data, "file_extension");
char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_FILE_EXTENSION);
ck_assert_msg(strcmp(actual, parsed) == 0,
"Failed file extension: actual = %s, parsed = %s, filename = %s", actual, parsed, fname);
free(parsed);
}
if (json_object_has_member(data, "release_group") &&
!JSON_NODE_HOLDS_ARRAY(json_object_get_member(data, "release_group")))
{
const char* actual = json_object_get_string_member(data, "release_group");
char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_RELEASE_GROUP);
ck_assert_msg(strcmp(actual, parsed) == 0,
"Failed release group: actual = %s, parsed = %s, filename = %s", actual, parsed, fname);
free(parsed);
}
if (json_object_has_member(data, "anime_year"))
{
const char* actual = json_object_get_string_member(data, "anime_year");
char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_ANIME_YEAR);
ck_assert_msg(strcmp(actual, parsed) == 0,
"Failed anime year: actual = %s, parsed = %s, filename = %s", actual, parsed, fname);
free(parsed);
}
if (json_object_has_member(data, "episode_title"))
{
const char* actual = json_object_get_string_member(data, "episode_title");
char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_EPISODE_TITLE);
ck_assert_msg(strcmp(actual, parsed) == 0,
"Failed episode title: actual = %s, parsed = %s, filename = %s", actual, parsed, fname);
free(parsed);
}
if (json_object_has_member(data, "video_resolution"))
{
const char* actual = json_object_get_string_member(data, "video_resolution");
char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_VIDEO_RESOLUTION);
ck_assert_msg(strcmp(actual, parsed) == 0,
"Failed video resolution: actual = %s, parsed = %s, filename = %s", actual, parsed, fname);
free(parsed);
}
if (json_object_has_member(data, "source"))
{
const char* actual = json_object_get_string_member(data, "source");
char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_SOURCE);
ck_assert_msg(strcmp(actual, parsed) == 0,
"Failed source: actual = %s, parsed = %s, filename = %s", actual, parsed, fname);
free(parsed);
}
if (json_object_has_member(data, "audio_term") &&
!JSON_NODE_HOLDS_ARRAY(json_object_get_member(data, "audio_term")))
{
const char* actual = json_object_get_string_member(data, "audio_term");
char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_AUDIO_TERM);
ck_assert_msg(strcmp(actual, parsed) == 0,
"Failed audio term: actual = %s, parsed = %s, filename = %s", actual, parsed, fname);
free(parsed);
}
if (json_object_has_member(data, "video_term") &&
!JSON_NODE_HOLDS_ARRAY(json_object_get_member(data, "video_term")))
{
const char* actual = json_object_get_string_member(data, "video_term");
char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_VIDEO_TERM);
ck_assert_msg(strcmp(actual, parsed) == 0,
"Failed video term: actual = %s, parsed = %s, filename = %s", actual, parsed, fname);
free(parsed);
}
}
static void
postal_http_handle_v1_notify (UrlRouter *router,
SoupServer *server,
SoupMessage *message,
const gchar *path,
GHashTable *params,
GHashTable *query,
SoupClientContext *client,
gpointer user_data)
{
PostalNotification *notif;
const gchar *collapse_key = NULL;
const gchar *str;
PostalHttp *http = user_data;
JsonObject *aps;
JsonObject *c2dm;
JsonObject *gcm;
JsonObject *object;
JsonArray *devices;
JsonArray *users;
GPtrArray *devices_ptr;
GPtrArray *users_ptr;
JsonNode *node;
GError *error = NULL;
guint count;
guint i;
g_assert(SOUP_IS_SERVER(server));
g_assert(SOUP_IS_MESSAGE(message));
g_assert(path);
g_assert(client);
g_assert(POSTAL_IS_HTTP(http));
if (message->method != SOUP_METHOD_POST) {
soup_message_set_status(message, SOUP_STATUS_METHOD_NOT_ALLOWED);
return;
}
soup_server_pause_message(server, message);
if (!(node = postal_http_parse_body(message, &error))) {
postal_http_reply_error(http, message, error);
g_error_free(error);
return;
}
if (!JSON_NODE_HOLDS_OBJECT(node) ||
!(object = json_node_get_object(node)) ||
!json_object_has_member(object, "aps") ||
!(node = json_object_get_member(object, "aps")) ||
!JSON_NODE_HOLDS_OBJECT(node) ||
!(aps = json_object_get_object_member(object, "aps")) ||
!json_object_has_member(object, "c2dm") ||
!(node = json_object_get_member(object, "c2dm")) ||
!JSON_NODE_HOLDS_OBJECT(node) ||
!(c2dm = json_object_get_object_member(object, "c2dm")) ||
!json_object_has_member(object, "gcm") ||
!(node = json_object_get_member(object, "gcm")) ||
!JSON_NODE_HOLDS_OBJECT(node) ||
!(gcm = json_object_get_object_member(object, "gcm")) ||
!json_object_has_member(object, "users") ||
!(node = json_object_get_member(object, "users")) ||
!JSON_NODE_HOLDS_ARRAY(node) ||
!(users = json_object_get_array_member(object, "users")) ||
!json_object_has_member(object, "devices") ||
!(node = json_object_get_member(object, "devices")) ||
!JSON_NODE_HOLDS_ARRAY(node) ||
!(devices = json_object_get_array_member(object, "devices"))) {
error = g_error_new(postal_json_error_quark(), 0,
"Missing or invalid fields in JSON payload.");
postal_http_reply_error(http, message, error);
json_node_free(node);
g_error_free(error);
return;
}
if (json_object_has_member(object, "collapse_key") &&
(node = json_object_get_member(object, "collapse_key")) &&
JSON_NODE_HOLDS_VALUE(node)) {
collapse_key = json_node_get_string(node);
}
notif = g_object_new(POSTAL_TYPE_NOTIFICATION,
"aps", aps,
"c2dm", c2dm,
"collapse-key", collapse_key,
"gcm", gcm,
NULL);
count = json_array_get_length(users);
users_ptr = g_ptr_array_sized_new(count);
for (i = 0; i < count; i++) {
node = json_array_get_element(users, i);
if (json_node_get_value_type(node) == G_TYPE_STRING) {
str = json_node_get_string(node);
g_ptr_array_add(users_ptr, (gchar *)str);
}
}
g_ptr_array_add(users_ptr, NULL);
count = json_array_get_length(devices);
devices_ptr = g_ptr_array_sized_new(count);
g_ptr_array_set_free_func(devices_ptr, g_free);
for (i = 0; i < count; i++) {
node = json_array_get_element(devices, i);
if (json_node_get_value_type(node) == G_TYPE_STRING) {
str = json_node_get_string(node);
g_ptr_array_add(devices_ptr, g_strdup(str));
}
}
g_ptr_array_add(devices_ptr, NULL);
postal_service_notify(http->priv->service,
notif,
(gchar **)users_ptr->pdata,
(gchar **)devices_ptr->pdata,
NULL, /* TODO: Cancellable/Timeout? */
postal_http_notify_cb,
g_object_ref(message));
g_ptr_array_unref(devices_ptr);
g_ptr_array_unref(users_ptr);
json_node_free(node);
g_object_unref(notif);
}
static gboolean
catch_resource_group_api_parse_activities (CatchResourceGroup *group,
JsonNode *result,
guint *result_offset,
guint *n_resources,
GError **error)
{
CatchResourceGroupPrivate *priv;
CatchResource *resource;
JsonObject *obj;
JsonArray *array;
JsonNode *element;
gboolean set_first_page = FALSE;
gboolean ret = FALSE;
guint i;
guint length;
guint offset = 0;
ENTRY;
g_return_val_if_fail(CATCH_IS_RESOURCE_GROUP(group), FALSE);
g_return_val_if_fail(result != NULL, FALSE);
priv = group->priv;
g_object_freeze_notify(G_OBJECT(group));
if (!JSON_NODE_HOLDS_OBJECT(result) ||
!(obj = json_node_get_object(result)) ||
!json_object_has_member(obj, "activities") ||
!JSON_NODE_HOLDS_ARRAY(json_object_get_member(obj, "activities")) ||
!(array = json_object_get_array_member(obj, "activities"))) {
g_set_error(error, CATCH_API_ERROR, CATCH_API_ERROR_BAD_RESPONSE,
_("The resonse was invalid."));
GOTO(failure);
}
if (json_object_has_member(obj, "count") &&
JSON_NODE_HOLDS_VALUE(json_object_get_member(obj, "count"))) {
priv->count = json_object_get_int_member(obj, "count");
set_first_page = TRUE;
g_object_notify_by_pspec(G_OBJECT(group), gParamSpecs[PROP_COUNT]);
}
if (json_object_has_member(obj, "offset") &&
JSON_NODE_HOLDS_VALUE(json_object_get_member(obj, "offset"))) {
offset = json_object_get_int_member(obj, "offset");
}
length = json_array_get_length(array);
for (i = 0; i < length; i++) {
element = json_array_get_element(array, i);
resource = g_object_new(CATCH_TYPE_ACTIVITY, NULL);
if (!catch_resource_load_from_json(resource, element, error)) {
g_object_unref(resource);
GOTO(failure);
}
catch_resource_group_set_resource(CATCH_RESOURCE_GROUP(group),
offset + i, resource);
g_object_unref(resource);
}
if (set_first_page) {
priv->first_page_size = length;
}
if (result_offset) {
*result_offset = offset;
}
if (n_resources) {
*n_resources = length;
}
ret = TRUE;
failure:
g_object_thaw_notify(G_OBJECT(group));
RETURN(ret);
}
static void
push_gcm_client_deliver_cb (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
const gchar *str;
JsonObject *obj;
JsonParser *p = NULL;
JsonArray *ar;
JsonNode *root;
JsonNode *node;
gboolean removed;
GError *error = NULL;
GList *list;
gsize length;
guint i;
ENTRY;
g_assert(SOUP_IS_SESSION(session));
g_assert(SOUP_IS_MESSAGE(message));
g_assert(G_IS_SIMPLE_ASYNC_RESULT(simple));
switch (message->status_code) {
case SOUP_STATUS_OK:
break;
case SOUP_STATUS_BAD_REQUEST:
/*
* TODO: Log that there was a JSON encoding error likely.
*/
break;
case SOUP_STATUS_UNAUTHORIZED:
g_simple_async_result_set_error(simple,
SOUP_HTTP_ERROR,
message->status_code,
_("GCM request unauthorized."));
GOTO(failure);
default:
if (SOUP_STATUS_IS_SERVER_ERROR(message->status_code) &&
(str = soup_message_headers_get_one(message->response_headers,
"Retry-After"))) {
/*
* TODO: Implement exponential back-off.
*/
}
g_simple_async_result_set_error(simple,
SOUP_HTTP_ERROR,
message->status_code,
_("Unknown failure occurred."));
break;
}
if (!message->response_body->data || !message->response_body->length) {
g_simple_async_result_set_error(simple,
SOUP_HTTP_ERROR,
SOUP_STATUS_IO_ERROR,
_("No data was received from GCM."));
GOTO(failure);
}
p = json_parser_new();
if (!json_parser_load_from_data(p,
message->response_body->data,
message->response_body->length,
&error)) {
g_simple_async_result_take_error(simple, error);
GOTO(failure);
}
list = g_object_get_data(G_OBJECT(simple), "identities");
if ((root = json_parser_get_root(p)) &&
JSON_NODE_HOLDS_OBJECT(root) &&
(obj = json_node_get_object(root)) &&
json_object_has_member(obj, "results") &&
(node = json_object_get_member(obj, "results")) &&
JSON_NODE_HOLDS_ARRAY(node) &&
(ar = json_node_get_array(node))) {
length = json_array_get_length(ar);
for (i = 0; i < length && list; i++, list = list->next) {
/*
* TODO: Handle the case that the device_token has been renamed.
*/
removed = FALSE;
if ((obj = json_array_get_object_element(ar, i)) &&
json_object_has_member(obj, "error") &&
(node = json_object_get_member(obj, "error")) &&
JSON_NODE_HOLDS_VALUE(node) &&
(str = json_node_get_string(node))) {
if (!g_strcmp0(str, "MissingRegistration")) {
removed = TRUE;
} else if (!g_strcmp0(str, "InvalidRegistration")) {
removed = TRUE;
} else if (!g_strcmp0(str, "MismatchSenderId")) {
} else if (!g_strcmp0(str, "NotRegistered")) {
removed = TRUE;
} else if (!g_strcmp0(str, "MessageTooBig")) {
} else if (!g_strcmp0(str, "InvalidDataKey")) {
} else if (!g_strcmp0(str, "InvalidTtl")) {
}
if (removed) {
g_assert(PUSH_IS_GCM_IDENTITY(list->data));
g_signal_emit(session, gSignals[IDENTITY_REMOVED], 0, list->data);
}
}
}
}
g_simple_async_result_set_op_res_gboolean(simple, TRUE);
failure:
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
if (p) {
g_object_unref(p);
}
EXIT;
}
static void
ide_langserv_rename_provider_rename_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeLangservClient *client = (IdeLangservClient *)object;
IdeLangservRenameProvider *self;
g_autoptr(JsonNode) return_value = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GTask) task = user_data;
g_autoptr(GPtrArray) ret = NULL;
JsonObject *changes_by_uri = NULL;
JsonObjectIter iter;
const gchar *uri;
IdeContext *context;
JsonNode *changes;
IDE_ENTRY;
g_assert (IDE_IS_LANGSERV_CLIENT (client));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (G_IS_TASK (task));
self = g_task_get_source_object (task);
g_assert (IDE_IS_LANGSERV_RENAME_PROVIDER (self));
if (!ide_langserv_client_call_finish (client, result, &return_value, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
IDE_EXIT;
}
if (!JCON_EXTRACT (return_value, "changes", JCONE_OBJECT (changes_by_uri)))
IDE_EXIT;
context = ide_object_get_context (IDE_OBJECT (self));
ret = g_ptr_array_new_with_free_func (g_object_unref);
json_object_iter_init (&iter, changes_by_uri);
while (json_object_iter_next (&iter, &uri, &changes))
{
g_autoptr(GFile) gfile = g_file_new_for_uri (uri);
g_autoptr(IdeFile) ifile = ide_file_new (context, gfile);
JsonArray *array;
guint length;
if (!JSON_NODE_HOLDS_ARRAY (changes))
continue;
array = json_node_get_array (changes);
length = json_array_get_length (array);
for (guint i = 0; i < length; i++)
{
JsonNode *change = json_array_get_element (array, i);
g_autoptr(IdeSourceLocation) begin_location = NULL;
g_autoptr(IdeSourceLocation) end_location = NULL;
g_autoptr(IdeSourceRange) range = NULL;
g_autoptr(IdeProjectEdit) edit = NULL;
const gchar *new_text = NULL;
gboolean success;
struct {
gint line;
gint column;
} begin, end;
success = JCON_EXTRACT (change,
"range", "{",
"start", "{",
"line", JCONE_INT (begin.line),
"character", JCONE_INT (begin.column),
"}",
"end", "{",
"line", JCONE_INT (end.line),
"character", JCONE_INT (end.column),
"}",
"}",
"newText", JCONE_STRING (new_text)
);
if (!success)
continue;
begin_location = ide_source_location_new (ifile, begin.line, begin.column, 0);
end_location = ide_source_location_new (ifile, end.line, end.column, 0);
range = ide_source_range_new (begin_location, end_location);
edit = g_object_new (IDE_TYPE_PROJECT_EDIT,
"range", range,
"replacement", new_text,
NULL);
g_ptr_array_add (ret, g_steal_pointer (&edit));
}
}
g_task_return_pointer (task, g_steal_pointer (&ret), (GDestroyNotify)g_ptr_array_unref);
IDE_EXIT;
}
