static void
_tarif_clear(gint tarif_id)
{
GSList **tarif = NULL;
GSList *link = NULL;
CCL_tarifpart *tp = NULL;
GData *freed = NULL;
tarif = g_new0(GSList *, 1);
*tarif = g_datalist_id_get_data(&ccl->tarifs, tarif_id);
g_assert(NULL != tarif);
g_datalist_init(&freed);
while ((link = g_slist_last(*tarif)) && *tarif)
{
*tarif = g_slist_remove_link(*tarif, link);
tp = (CCL_tarifpart *) link->data;
if (!g_datalist_id_get_data(&freed, GPOINTER_TO_INT(tp->prices)))
{
g_datalist_clear(tp->prices);
g_datalist_id_set_data(&freed, GPOINTER_TO_INT(tp->prices),
(void *)tp->prices);
g_free(tp->prices);
}
g_slist_free_1(link);
g_free(tp);
}
g_datalist_clear(&freed);
*tarif = NULL;
g_datalist_id_remove_data(&ccl->tarifs, tarif_id);
g_free(tarif);
}
qq_im_format *qq_im_fmt_new_by_purple(const gchar *msg)
{
qq_im_format *fmt;
const gchar *start, *end, *last;
GData *attribs;
gchar *tmp;
unsigned char *rgb;
g_return_val_if_fail(msg != NULL, NULL);
fmt = qq_im_fmt_new();
last = msg;
while (purple_markup_find_tag("font", last, &start, &end, &attribs)) {
tmp = g_datalist_get_data(&attribs, "face");
if (tmp && strlen(tmp) > 0) {
if (fmt->font) g_free(fmt->font);
fmt->font_len = strlen(tmp);
fmt->font = g_strdup(tmp);
}
tmp = g_datalist_get_data(&attribs, "size");
if (tmp) {
fmt->attr = atoi(tmp) * 3 + 1;
fmt->attr &= 0x0f;
}
tmp = g_datalist_get_data(&attribs, "color");
if (tmp && strlen(tmp) > 1) {
rgb = purple_base16_decode(tmp + 1, NULL);
g_memmove(fmt->rgb, rgb, 3);
g_free(rgb);
}
g_datalist_clear(&attribs);
last = end + 1;
}
if (purple_markup_find_tag("b", msg, &start, &end, &attribs)) {
fmt->attr |= 0x20;
g_datalist_clear(&attribs);
}
if (purple_markup_find_tag("i", msg, &start, &end, &attribs)) {
fmt->attr |= 0x40;
g_datalist_clear(&attribs);
}
if (purple_markup_find_tag("u", msg, &start, &end, &attribs)) {
fmt->attr |= 0x80;
g_datalist_clear(&attribs);
}
return fmt;
}
/**
* Rebuild all the tarifs from the data on the db.
*
* This should be used after you have initialized CCL.
*/
void
CCL_tarif_rebuild_all(void)
{
GSList ** tarif = NULL;
gint tarif_id;
gint i;
for (i = 0; -1 != (tarif_id = CCL_tarif_get_nth(i)); i++)
_tarif_clear(tarif_id);
g_datalist_clear(&ccl->tarifs);
g_datalist_init(&ccl->tarifs);
for (i = 0; -1 != (tarif_id = CCL_tarif_get_nth(i)); i++)
{
tarif = g_new0(GSList *, 1);
*tarif = NULL;
_tarif_rebuild(tarif_id, tarif);
g_datalist_id_set_data(&ccl->tarifs, tarif_id, *tarif);
g_free(tarif);
}
#ifdef DEBUG
printf("CCL_tarif_rebuild_all(): [ %d ] Tariffs found\n", i);
#endif
}
static void
gca_service_proxy_finalize (GObject *object)
{
GcaServiceProxy *proxy = GCA_SERVICE_PROXY (object);
g_datalist_clear (&proxy->priv->qdata);
G_OBJECT_CLASS (gca_service_proxy_parent_class)->finalize (object);
}
/* Funcion initReceivers
* Precondiciones:
* Postcondiciones:
* Entrada:
* Salida:
* Proceso:
* */
gboolean
initReceivers (GData** receiveConfig, gchar** error)
{
/* Free memory and exit. */
g_datalist_clear(receiveConfig);
return (TRUE);
}
static void
record_logout_for_all_remaining_sessions (void)
{
g_datalist_foreach (&humanity_by_session_id,
(GDataForeachFunc) record_stop_for_login,
NULL /* user_data */);
g_datalist_clear (&humanity_by_session_id);
}
/**
* 类析构函数.
*/
SoundSystem::~SoundSystem()
{
GstElement *pipeline;
if ( (pipeline = GST_ELEMENT(g_datalist_get_data(&eltset, "pipeline-element"))))
gst_element_set_state(pipeline, GST_STATE_NULL);
g_datalist_clear(&eltset);
}
static void instance_finalize( GbdX11emitter* self ) {
GbdX11emitterPrivate* const priv = self->priv;
g_clear_object( &priv->srcdata );
g_clear_object( &priv->srcstream );
g_datalist_clear( &priv->mapcache );
G_OBJECT_CLASS( g_type_class_peek( G_TYPE_OBJECT ) )->finalize( G_OBJECT( self ) );
}
static void gfire_sq_gamespy_data_free(gfire_sq_gamespy_data *p_data)
{
g_datalist_clear(&p_data->info);
g_datalist_clear(&p_data->rules);
g_datalist_clear(&p_data->player_data);
while(p_data->players)
{
gfire_sq_gamespy_player *player = (gfire_sq_gamespy_player*)p_data->players->data;
g_free(player->name);
g_free(player->mesh);
g_free(player->skin);
g_free(player->face);
g_free(player);
p_data->players = g_slist_delete_link(p_data->players, p_data->players);
}
g_free(p_data);
}
static void
ibus_serializable_destroy (IBusSerializable *object)
{
IBusSerializablePrivate *priv;
priv = IBUS_SERIALIZABLE_GET_PRIVATE (object);
g_datalist_clear (&priv->attachments);
parent_class->destroy (IBUS_OBJECT (object));
}
static void gfire_sq_savage_free_server(gfire_game_server *p_server)
{
if(p_server->data && p_server->data->proto_data)
{
gfire_sq_savage_data *data = (gfire_sq_savage_data*)p_server->data->proto_data;
g_datalist_clear(&data->info);
g_strfreev(data->players);
g_free(data);
}
}
void
g_scanner_destroy (GScanner *scanner)
{
g_return_if_fail (scanner != NULL);
g_datalist_clear (&scanner->qdata);
g_hash_table_foreach (scanner->symbol_table,
g_scanner_destroy_symbol_table_entry, NULL);
g_hash_table_destroy (scanner->symbol_table);
g_scanner_free_value (&scanner->token, &scanner->value);
g_scanner_free_value (&scanner->next_token, &scanner->next_value);
g_free (scanner->config);
g_free (scanner->buffer);
g_free (scanner);
}
inline void gs_set_player(player_t* player)
{
thread_tls_initonce(&tls_player);
thread_tls_set(&tls_player, player);
if(!player) {
GData* transact_data;
thread_tls_initonce(&tls_transact_data);
transact_data = (GData*)thread_tls_get(&tls_transact_data);
g_datalist_clear(&transact_data);
g_datalist_init(&transact_data);
thread_tls_set(&tls_transact_data, transact_data);
}
}
/**
* e_uri_free:
* @uri: A pointer to the #EUri to free.
*
* Frees the memory of an #EUri structure.
**/
void
e_uri_free (EUri *uri)
{
if (uri) {
g_free (uri->protocol);
g_free (uri->user);
g_free (uri->authmech);
g_free (uri->passwd);
g_free (uri->host);
g_free (uri->path);
g_datalist_clear (&uri->params);
g_free (uri->query);
g_free (uri->fragment);
g_free (uri);
}
}
static void
static_finalize (GObject *object)
{
TpStaticHandleRepo *self = TP_STATIC_HANDLE_REPO (object);
guint i;
if (self->datalists)
{
for (i = 0; i < self->last_handle; i++)
{
g_datalist_clear (self->datalists + i);
}
}
g_strfreev (self->handle_names);
G_OBJECT_CLASS (tp_static_handle_repo_parent_class)->finalize (object);
}
static void
static_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
TpStaticHandleRepo *self = TP_STATIC_HANDLE_REPO (object);
TpHandle i;
switch (property_id)
{
case PROP_HANDLE_TYPE:
self->handle_type = g_value_get_uint (value);
break;
case PROP_HANDLE_NAMES:
if (self->datalists)
{
for (i = 0; i < self->last_handle; i++)
{
g_datalist_clear (self->datalists + i);
}
}
g_strfreev (self->handle_names);
self->handle_names = g_strdupv (g_value_get_boxed (value));
i = 0;
while (self->handle_names[i] != NULL)
{
i++;
}
self->last_handle = i;
g_free (self->datalists);
self->datalists = NULL;
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void free_ase_data(gfire_sq_ase_data *p_data)
{
g_free(p_data->game_name);
g_free(p_data->server_name);
g_free(p_data->game_type);
g_free(p_data->map);
g_free(p_data->version);
if(p_data->rules)
g_datalist_clear(&p_data->rules);
while(p_data->players)
{
free_ase_player(p_data->players->data);
p_data->players = g_slist_delete_link(p_data->players, p_data->players);
}
g_free(p_data);
}
static void
gst_v4l2_empty_lists (GstV4l2Object * v4l2object)
{
GST_DEBUG_OBJECT (v4l2object->element, "deleting enumerations");
g_list_foreach (v4l2object->channels, (GFunc) g_object_unref, NULL);
g_list_free (v4l2object->channels);
v4l2object->channels = NULL;
g_list_foreach (v4l2object->norms, (GFunc) g_object_unref, NULL);
g_list_free (v4l2object->norms);
v4l2object->norms = NULL;
g_list_foreach (v4l2object->colors, (GFunc) g_object_unref, NULL);
g_list_free (v4l2object->colors);
v4l2object->colors = NULL;
g_datalist_clear (&v4l2object->controls);
}
/**
* camel_url_free:
* @url: a #CamelURL
*
* Frees @url.
**/
void
camel_url_free (CamelURL *url)
{
if (url) {
if (url->user)
memset (url->user, 0, strlen (url->user));
if (url->host)
memset (url->host, 0, strlen (url->host));
g_free (url->protocol);
g_free (url->user);
g_free (url->authmech);
g_free (url->host);
g_free (url->path);
g_datalist_clear (&url->params);
g_free (url->query);
g_free (url->fragment);
g_free (url);
}
}
static void gfire_sq_gamespy2_free_server(gfire_game_server *p_server)
{
if(p_server->data && p_server->data->proto_data)
{
gfire_sq_gamespy2_data *data = (gfire_sq_gamespy2_data*)p_server->data->proto_data;
g_datalist_clear(&data->info);
while(data->players)
{
gfire_sq_gamespy2_player *player = (gfire_sq_gamespy2_player*)data->players->data;
g_free(player->name);
g_free(player);
data->players = g_slist_delete_link(data->players, data->players);
}
g_free(data);
}
}
static void
ec_target_free(EImport *ep, EImportTarget *t)
{
switch (t->type) {
case E_IMPORT_TARGET_URI: {
EImportTargetURI *s = (EImportTargetURI *)t;
g_free(s->uri_src);
g_free(s->uri_dest);
break; }
case E_IMPORT_TARGET_HOME: {
EImportTargetHome *s = (EImportTargetHome *)t;
g_free(s->homedir);
break; }
}
g_datalist_clear(&t->data);
g_free(t);
g_object_unref(ep);
}
gboolean qq_im_smiley_none(const gchar *msg)
{
const gchar *start, *end, *last;
GData *attribs;
gchar *tmp;
gboolean ret = FALSE;
g_return_val_if_fail(msg != NULL, TRUE);
last = msg;
while (purple_markup_find_tag("font", last, &start, &end, &attribs)) {
tmp = g_datalist_get_data(&attribs, "sml");
if (tmp && strlen(tmp) > 0) {
if (strcmp(tmp, "none") == 0) {
ret = TRUE;
break;
}
}
g_datalist_clear(&attribs);
last = end + 1;
}
return ret;
}
int S57_doneData (_S57_geo *geoData, gpointer user_data)
{
// quiet line overlap analysis that trigger a bunch of harmless warning
if (NULL!=user_data && NULL==geoData)
return FALSE;
#ifdef S52_USE_WORLD
{
S57_geo *geoDataNext = NULL;
if (NULL != (geoDataNext = S57_getNextPoly(geoData))) {
S57_doneData(geoDataNext, user_data);
}
}
#endif
#ifndef S52_USE_GV
// data from OGR is a copy --so this need to be deleted
_doneGeoData(geoData);
#endif
S57_donePrimGeo(geoData);
if (NULL != geoData->name)
g_string_free(geoData->name, TRUE);
if (NULL != geoData->attribs)
g_datalist_clear(&geoData->attribs);
if (NULL != geoData->centroid)
g_array_free(geoData->centroid, TRUE);
g_free(geoData);
return TRUE;
}
static gboolean
crank_composite_def_remove_compositable (CrankComposite *composite,
CrankCompositable *compositable,
GError **error)
{
CrankCompositePrivate *priv = crank_composite_get_instance_private (composite);
gint i = crank_composite_index_of_compositable (composite, compositable);
// First check a compositable exists.
if (i == -1)
{
g_set_error (error, CRANK_COMPOSITE_ERROR,
CRANK_COMPOSITE_ERROR_NOT_HAVE_COMPOSITABLE,
"Compositable is not in the compositable.\n"
"%s@%p <= %s@%p",
G_OBJECT_TYPE_NAME (composite), composite,
G_OBJECT_TYPE_NAME (compositable), compositable);
return FALSE;
}
// Do adding
else if (crank_compositable_removing (compositable, composite, error))
{
Percompositable *percompositable =
& g_array_index (priv->data, Percompositable, i);
g_datalist_clear (& percompositable->dictionary);
g_object_unref (compositable);
g_array_remove_index (priv->data, i);
g_object_notify_by_pspec ((GObject*)composite, pspecs[PROP_NCOMPOSITABLES]);
return TRUE;
}
return FALSE;
}
void scripts_done() {
g_datalist_clear(&scriptdata);
}
int PurpleLine::send_message(std::string to, const char *markup) {
// Parse markup and send message as parts if it contains images
bool any_sent = false;
std::cout << "debug ---> " << std::endl;
std::cout << to << std::endl;
std::cout << markup << std::endl;
for (const char *p = markup; p && *p; ) {
const char *start, *end;
const char *filestart, *fileend;
GData *attributes;
GData *fileattributes;
std::cout << "Sending LINE Message..." << std::endl;
bool img_found = purple_markup_find_tag("IMG", p, &start, &end, &attributes);
bool imgfile_found = purple_markup_find_tag("FILE", p, &filestart, &fileend, &fileattributes);
std::cout << "---Image file ? " << std::endl;
std::cout << img_found << std::endl;
std::cout << imgfile_found << std::endl;
std::string text;
if (img_found) {
// Image found but there's text before it, store it
text = std::string(p, start - p);
p = end + 1;
} else {
// No image found, store the rest of the text
text = std::string(p);
// Break the loop
p = NULL;
}
// If the text is not all whitespace, send it as a text message
if (text.find_first_not_of("\t\n\r ") != std::string::npos && !imgfile_found)
{
line::Message msg;
msg.contentType = line::ContentType::NONE;
msg.from = profile.mid;
msg.to = to;
msg.text = markup_unescape(text);
send_message(msg);
any_sent = true;
}
if (imgfile_found) {
std::cout << "Start upload file!!" << std::endl;
char *path = (char *)g_datalist_get_data(&fileattributes, "path");
std::cout << path << std::endl;
gchar *data = NULL;
size_t len;
GError *err = NULL;
if (!g_file_get_contents(path, &data, &len, &err))
{
std::cout << "Error get file contents!!" << std::endl;
continue;
}
std::cout << "Success get file content!!" << std::endl;
PurpleStoredImage *img =
purple_imgstore_add(data, len, path);
if (!img)
{
std::cout << "Error image stored add!!" << std::endl;
continue;
}
std::cout << "Success image stored add!!" << std::endl;
std::string img_data(
(const char *)purple_imgstore_get_data(img),
purple_imgstore_get_size(img));
line::Message msg;
msg.contentType = line::ContentType::IMAGE;
msg.from = profile.mid;
msg.to = to;
send_message(msg, [this, img_data](line::Message &msg_back) {
upload_media(msg_back.id, "image", img_data);
});
any_sent = true;
}
if (img_found) {
// Image test
int image_id = std::stoi((char *)g_datalist_get_data(&attributes, "id"));
g_datalist_clear(&attributes);
std::stringstream ss;
ss << "(img ID: " << image_id << ")";
PurpleStoredImage *img = purple_imgstore_find_by_id(image_id);
if (!img) {
purple_debug_warning("line", "Tried to send non-existent image: %d\n", image_id);
continue;
}
std::string img_data(
(const char *)purple_imgstore_get_data(img),
purple_imgstore_get_size(img));
line::Message msg;
msg.contentType = line::ContentType::IMAGE;
msg.from = profile.mid;
msg.to = to;
send_message(msg, [this, img_data](line::Message &msg_back) {
upload_media(msg_back.id, "image", img_data);
});
any_sent = true;
}
}
return any_sent ? 1 : 0;
}
SilcDList silcpurple_image_message(const char *msg, SilcMessageFlags *mflags)
{
SilcMime mime = NULL, p;
SilcDList list, parts = NULL;
const char *start, *end, *last;
GData *attribs;
char *type;
gboolean images = FALSE;
last = msg;
while (last && *last && purple_markup_find_tag("img", last, &start,
&end, &attribs)) {
PurpleStoredImage *image = NULL;
const char *id;
/* Check if there is text before image */
if (start - last) {
char *text, *tmp;
p = silc_mime_alloc();
/* Add content type */
silc_mime_add_field(p, "Content-Type",
"text/plain; charset=utf-8");
tmp = g_strndup(last, start - last);
text = purple_unescape_html(tmp);
g_free(tmp);
/* Add text */
silc_mime_add_data(p, (const unsigned char *)text, strlen(text));
g_free(text);
if (!parts)
parts = silc_dlist_init();
silc_dlist_add(parts, p);
}
id = g_datalist_get_data(&attribs, "id");
if (id && (image = purple_imgstore_find_by_id(atoi(id)))) {
unsigned long imglen = purple_imgstore_get_size(image);
gconstpointer img = purple_imgstore_get_data(image);
p = silc_mime_alloc();
/* Add content type */
type = silcpurple_file2mime(purple_imgstore_get_filename(image));
if (!type) {
g_datalist_clear(&attribs);
last = end + 1;
continue;
}
silc_mime_add_field(p, "Content-Type", type);
g_free(type);
/* Add content transfer encoding */
silc_mime_add_field(p, "Content-Transfer-Encoding", "binary");
/* Add image data */
silc_mime_add_data(p, img, imglen);
if (!parts)
parts = silc_dlist_init();
silc_dlist_add(parts, p);
images = TRUE;
}
g_datalist_clear(&attribs);
/* Continue after tag */
last = end + 1;
}
/* Check for text after the image(s) */
if (images && last && *last) {
char *tmp = purple_unescape_html(last);
p = silc_mime_alloc();
/* Add content type */
silc_mime_add_field(p, "Content-Type",
"text/plain; charset=utf-8");
/* Add text */
silc_mime_add_data(p, (const unsigned char *)tmp, strlen(tmp));
g_free(tmp);
if (!parts)
parts = silc_dlist_init();
silc_dlist_add(parts, p);
}
/* If there weren't any images, don't return anything. */
if (!images) {
if (parts)
silc_dlist_uninit(parts);
return NULL;
}
if (silc_dlist_count(parts) > 1) {
/* Multipart MIME message */
char b[32];
mime = silc_mime_alloc();
silc_mime_add_field(mime, "MIME-Version", "1.0");
g_snprintf(b, sizeof(b), "b%4X%4X",
(unsigned int)time(NULL),
silc_dlist_count(parts));
silc_mime_set_multipart(mime, "mixed", b);
silc_dlist_start(parts);
while ((p = silc_dlist_get(parts)) != SILC_LIST_END)
silc_mime_add_multipart(mime, p);
} else {
/* Simple MIME message */
silc_dlist_start(parts);
mime = silc_dlist_get(parts);
silc_mime_add_field(mime, "MIME-Version", "1.0");
}
*mflags &= ~SILC_MESSAGE_FLAG_UTF8;
*mflags |= SILC_MESSAGE_FLAG_DATA;
/* Encode message. Fragment if it is too large */
list = silc_mime_encode_partial(mime, 0xfc00);
silc_dlist_uninit(parts);
/* Added multiparts gets freed here */
silc_mime_free(mime);
return list;
}
void
qipu_destroy (qipu_t *qipu)
{
g_datalist_clear (&qipu->tv_list);
free (qipu);
}