~ubuntu-branches/ubuntu/natty/folks/natty

« back to all changes in this revision

Viewing changes to tools/import-pidgin.c

  • Committer: Bazaar Package Importer
  • Author(s): Ken VanDine
  • Date: 2011-03-18 16:49:27 UTC
  • mfrom: (1.2.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20110318164927-ho97ckhsq73glhm4
Tags: 0.4.1-0ubuntu1
* New upstream release
  - Fixed crasher when reconnecting a Telepathy account

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* import-pidgin.c generated by valac 0.11.6, the Vala compiler
 
1
/* import-pidgin.c generated by valac 0.11.7, the Vala compiler
2
2
 * generated from import-pidgin.vala, do not modify */
3
3
 
4
4
/*
103
103
        gchar* source_filename;
104
104
        guint result;
105
105
        FolksPersonaStore* _tmp0_;
106
 
        FolksPersonaStore* _tmp1_;
107
 
        gchar* _tmp2_;
 
106
        gchar* _tmp1_;
108
107
        gchar* filename;
109
 
        gboolean _tmp3_;
 
108
        gboolean _tmp2_;
 
109
        gchar* _tmp3_;
110
110
        gchar* _tmp4_;
111
 
        gchar* _tmp5_;
112
 
        const gchar* _tmp6_;
113
 
        gchar* _tmp7_;
114
 
        gchar* _tmp8_;
115
 
        GFile* _tmp9_;
 
111
        const gchar* _tmp5_;
 
112
        gchar* _tmp6_;
 
113
        GFile* _tmp7_;
116
114
        GFile* file;
117
 
        gboolean _tmp10_;
118
 
        const gchar* _tmp11_;
119
 
        GError* _tmp12_;
 
115
        gboolean _tmp8_;
 
116
        const gchar* _tmp9_;
 
117
        GError* _tmp10_;
120
118
        GFileInfo* file_info;
121
 
        GFileInfo* _tmp13_;
122
 
        GFileInfo* _tmp14_;
123
 
        GFileInfo* _tmp15_;
 
119
        GFileInfo* _tmp11_;
 
120
        GFileInfo* _tmp12_;
124
121
        GError * e;
 
122
        const gchar* _tmp13_;
 
123
        GError* _tmp14_;
 
124
        gboolean _tmp15_;
125
125
        const gchar* _tmp16_;
126
126
        GError* _tmp17_;
127
 
        gboolean _tmp18_;
 
127
        xmlDoc* _tmp18_;
 
128
        xmlDoc* xml_doc;
128
129
        const gchar* _tmp19_;
129
130
        GError* _tmp20_;
130
 
        xmlDoc* _tmp21_;
131
 
        xmlDoc* xml_doc;
132
 
        const gchar* _tmp22_;
133
 
        GError* _tmp23_;
134
 
        xmlNode* _tmp24_;
 
131
        xmlNode* _tmp21_;
135
132
        xmlNode* root_node;
136
 
        gboolean _tmp25_;
137
 
        gboolean _tmp26_;
138
 
        gchar* _tmp27_;
139
 
        gchar* _tmp28_;
140
 
        const gchar* _tmp29_;
141
 
        GError* _tmp30_;
 
133
        gboolean _tmp22_;
 
134
        gboolean _tmp23_;
 
135
        gchar* _tmp24_;
 
136
        gchar* _tmp25_;
 
137
        const gchar* _tmp26_;
 
138
        GError* _tmp27_;
142
139
        xmlNode* iter;
143
 
        gboolean _tmp31_;
144
 
        gboolean _tmp32_;
145
 
        const gchar* _tmp33_;
 
140
        gboolean _tmp28_;
 
141
        gboolean _tmp29_;
 
142
        const gchar* _tmp30_;
146
143
        GError * _inner_error_;
147
144
};
148
145
 
205
202
        gboolean _tmp6_;
206
203
        gchar* _tmp7_;
207
204
        gchar* _tmp8_;
208
 
        gchar* _tmp9_;
209
205
        gchar* im_address;
210
 
        gconstpointer _tmp10_;
 
206
        gconstpointer _tmp9_;
 
207
        GPtrArray* _tmp10_;
 
208
        GPtrArray* im_address_array;
211
209
        GPtrArray* _tmp11_;
212
 
        GPtrArray* im_address_array;
213
 
        GPtrArray* _tmp12_;
 
210
        gchar* _tmp12_;
214
211
        GPtrArray* _tmp13_;
215
212
        gchar* _tmp14_;
216
 
        GPtrArray* _tmp15_;
 
213
        gchar* _tmp15_;
217
214
        gchar* _tmp16_;
218
215
        gchar* _tmp17_;
219
 
        gchar* _tmp18_;
220
 
        gchar* _tmp19_;
 
216
        gboolean _tmp18_;
 
217
        guint _tmp19_;
221
218
        gboolean _tmp20_;
222
 
        guint _tmp21_;
223
 
        gboolean _tmp22_;
224
 
        gboolean _tmp23_;
 
219
        gboolean _tmp21_;
 
220
        gchar* _tmp22_;
 
221
        gchar* _tmp23_;
225
222
        gchar* _tmp24_;
226
223
        gchar* _tmp25_;
227
224
        gchar* _tmp26_;
228
225
        gchar* _tmp27_;
229
 
        gchar* _tmp28_;
230
 
        gchar* _tmp29_;
231
 
        const gchar* _tmp30_;
232
 
        GHashTable* _tmp31_;
 
226
        const gchar* _tmp28_;
 
227
        GHashTable* _tmp29_;
233
228
        GHashTable* details;
234
229
        GValue im_addresses_value;
235
 
        gchar* _tmp32_;
236
 
        GValue* _tmp33_;
 
230
        gchar* _tmp30_;
 
231
        GValue* _tmp31_;
237
232
        FolksPersona* persona;
238
 
        FolksPersona* _tmp34_;
239
 
        FolksPersona* _tmp35_;
240
 
        FolksPersona* _tmp36_;
 
233
        FolksPersona* _tmp32_;
 
234
        FolksPersona* _tmp33_;
241
235
        GError * e;
 
236
        const gchar* _tmp34_;
 
237
        gboolean _tmp35_;
 
238
        const gchar* _tmp36_;
242
239
        const gchar* _tmp37_;
243
 
        gboolean _tmp38_;
244
 
        const gchar* _tmp39_;
245
 
        const gchar* _tmp40_;
246
240
        GError * _inner_error_;
247
241
};
248
242
 
363
357
        }
364
358
        _state_0:
365
359
        data->_tmp0_ = _g_object_ref0 (data->destination_store);
366
 
        data->_tmp1_ = data->_tmp0_;
367
360
        _g_object_unref0 (data->self->priv->destination_store);
368
 
        data->self->priv->destination_store = data->_tmp1_;
369
 
        data->_tmp2_ = g_strdup (data->source_filename);
370
 
        data->filename = data->_tmp2_;
 
361
        data->self->priv->destination_store = data->_tmp0_;
 
362
        data->_tmp1_ = g_strdup (data->source_filename);
 
363
        data->filename = data->_tmp1_;
371
364
        if (data->filename == NULL) {
372
 
                data->_tmp3_ = TRUE;
 
365
                data->_tmp2_ = TRUE;
373
366
        } else {
374
 
                data->_tmp4_ = NULL;
375
 
                data->_tmp4_ = string_strip (data->filename);
376
 
                data->_tmp5_ = data->_tmp4_;
377
 
                data->_tmp3_ = g_strcmp0 (data->_tmp5_, "") == 0;
378
 
                _g_free0 (data->_tmp5_);
 
367
                data->_tmp3_ = NULL;
 
368
                data->_tmp3_ = string_strip (data->filename);
 
369
                data->_tmp4_ = data->_tmp3_;
 
370
                data->_tmp2_ = g_strcmp0 (data->_tmp4_, "") == 0;
 
371
                _g_free0 (data->_tmp4_);
379
372
        }
380
 
        if (data->_tmp3_) {
 
373
        if (data->_tmp2_) {
 
374
                data->_tmp5_ = NULL;
 
375
                data->_tmp5_ = g_get_home_dir ();
381
376
                data->_tmp6_ = NULL;
382
 
                data->_tmp6_ = g_get_home_dir ();
383
 
                data->_tmp7_ = NULL;
384
 
                data->_tmp7_ = g_build_filename (data->_tmp6_, ".purple", "blist.xml", NULL, NULL);
385
 
                data->_tmp8_ = data->_tmp7_;
 
377
                data->_tmp6_ = g_build_filename (data->_tmp5_, ".purple", "blist.xml", NULL, NULL);
386
378
                _g_free0 (data->filename);
387
 
                data->filename = data->_tmp8_;
 
379
                data->filename = data->_tmp6_;
388
380
        }
389
 
        data->_tmp9_ = NULL;
390
 
        data->_tmp9_ = g_file_new_for_path (data->filename);
391
 
        data->file = data->_tmp9_;
392
 
        data->_tmp10_ = g_file_query_exists (data->file, NULL);
393
 
        if (!data->_tmp10_) {
394
 
                data->_tmp11_ = NULL;
395
 
                data->_tmp11_ = _ ("File %s does not exist.");
396
 
                data->_tmp12_ = NULL;
397
 
                data->_tmp12_ = g_error_new (FOLKS_IMPORT_ERROR, FOLKS_IMPORT_ERROR_MALFORMED_INPUT, data->_tmp11_, data->filename);
398
 
                data->_inner_error_ = data->_tmp12_;
 
381
        data->_tmp7_ = NULL;
 
382
        data->_tmp7_ = g_file_new_for_path (data->filename);
 
383
        data->file = data->_tmp7_;
 
384
        data->_tmp8_ = g_file_query_exists (data->file, NULL);
 
385
        if (!data->_tmp8_) {
 
386
                data->_tmp9_ = NULL;
 
387
                data->_tmp9_ = _ ("File %s does not exist.");
 
388
                data->_tmp10_ = NULL;
 
389
                data->_tmp10_ = g_error_new (FOLKS_IMPORT_ERROR, FOLKS_IMPORT_ERROR_MALFORMED_INPUT, data->_tmp9_, data->filename);
 
390
                data->_inner_error_ = data->_tmp10_;
399
391
                if (data->_inner_error_->domain == FOLKS_IMPORT_ERROR) {
400
392
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
401
393
                        g_error_free (data->_inner_error_);
420
412
        g_file_query_info_async (data->file, G_FILE_ATTRIBUTE_ACCESS_CAN_READ, G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, NULL, folks_importers_pidgin_import_ready, data);
421
413
        return FALSE;
422
414
        _state_1:
423
 
        data->_tmp13_ = NULL;
424
 
        data->_tmp13_ = g_file_query_info_finish (data->file, data->_res_, &data->_inner_error_);
425
 
        data->_tmp14_ = data->_tmp13_;
 
415
        data->_tmp11_ = NULL;
 
416
        data->_tmp11_ = g_file_query_info_finish (data->file, data->_res_, &data->_inner_error_);
 
417
        data->_tmp12_ = data->_tmp11_;
426
418
        if (data->_inner_error_ != NULL) {
427
419
                goto __catch5_g_error;
428
420
        }
429
 
        data->_tmp15_ = data->_tmp14_;
430
421
        _g_object_unref0 (data->file_info);
431
 
        data->file_info = data->_tmp15_;
 
422
        data->file_info = data->_tmp12_;
432
423
        goto __finally5;
433
424
        __catch5_g_error:
434
425
        {
435
426
                data->e = data->_inner_error_;
436
427
                data->_inner_error_ = NULL;
 
428
                data->_tmp13_ = NULL;
 
429
                data->_tmp13_ = _ ("Failed to get information about file %s: %s");
 
430
                data->_tmp14_ = NULL;
 
431
                data->_tmp14_ = g_error_new (FOLKS_IMPORT_ERROR, FOLKS_IMPORT_ERROR_MALFORMED_INPUT, data->_tmp13_, data->filename, data->e->message);
 
432
                data->_inner_error_ = data->_tmp14_;
 
433
                _g_error_free0 (data->e);
 
434
                goto __finally5;
 
435
        }
 
436
        __finally5:
 
437
        if (data->_inner_error_ != NULL) {
 
438
                if (data->_inner_error_->domain == FOLKS_IMPORT_ERROR) {
 
439
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
 
440
                        g_error_free (data->_inner_error_);
 
441
                        _g_object_unref0 (data->file_info);
 
442
                        _g_object_unref0 (data->file);
 
443
                        _g_free0 (data->filename);
 
444
                        if (data->_state_ == 0) {
 
445
                                g_simple_async_result_complete_in_idle (data->_async_result);
 
446
                        } else {
 
447
                                g_simple_async_result_complete (data->_async_result);
 
448
                        }
 
449
                        g_object_unref (data->_async_result);
 
450
                        return FALSE;
 
451
                } else {
 
452
                        _g_object_unref0 (data->file_info);
 
453
                        _g_object_unref0 (data->file);
 
454
                        _g_free0 (data->filename);
 
455
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
 
456
                        g_clear_error (&data->_inner_error_);
 
457
                        return FALSE;
 
458
                }
 
459
        }
 
460
        data->_tmp15_ = g_file_info_get_attribute_boolean (data->file_info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
 
461
        if (!data->_tmp15_) {
437
462
                data->_tmp16_ = NULL;
438
 
                data->_tmp16_ = _ ("Failed to get information about file %s: %s");
 
463
                data->_tmp16_ = _ ("File %s is not readable.");
439
464
                data->_tmp17_ = NULL;
440
 
                data->_tmp17_ = g_error_new (FOLKS_IMPORT_ERROR, FOLKS_IMPORT_ERROR_MALFORMED_INPUT, data->_tmp16_, data->filename, data->e->message);
 
465
                data->_tmp17_ = g_error_new (FOLKS_IMPORT_ERROR, FOLKS_IMPORT_ERROR_MALFORMED_INPUT, data->_tmp16_, data->filename);
441
466
                data->_inner_error_ = data->_tmp17_;
442
 
                _g_error_free0 (data->e);
443
 
                goto __finally5;
444
 
        }
445
 
        __finally5:
446
 
        if (data->_inner_error_ != NULL) {
447
467
                if (data->_inner_error_->domain == FOLKS_IMPORT_ERROR) {
448
468
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
449
469
                        g_error_free (data->_inner_error_);
466
486
                        return FALSE;
467
487
                }
468
488
        }
469
 
        data->_tmp18_ = g_file_info_get_attribute_boolean (data->file_info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
470
 
        if (!data->_tmp18_) {
 
489
        data->_tmp18_ = NULL;
 
490
        data->_tmp18_ = xmlParseFile (data->filename);
 
491
        data->xml_doc = data->_tmp18_;
 
492
        if (data->xml_doc == NULL) {
471
493
                data->_tmp19_ = NULL;
472
 
                data->_tmp19_ = _ ("File %s is not readable.");
 
494
                data->_tmp19_ = _ ("The Pidgin buddy list file '%s' could not be loaded.");
473
495
                data->_tmp20_ = NULL;
474
496
                data->_tmp20_ = g_error_new (FOLKS_IMPORT_ERROR, FOLKS_IMPORT_ERROR_MALFORMED_INPUT, data->_tmp19_, data->filename);
475
497
                data->_inner_error_ = data->_tmp20_;
496
518
                }
497
519
        }
498
520
        data->_tmp21_ = NULL;
499
 
        data->_tmp21_ = xmlParseFile (data->filename);
500
 
        data->xml_doc = data->_tmp21_;
501
 
        if (data->xml_doc == NULL) {
502
 
                data->_tmp22_ = NULL;
503
 
                data->_tmp22_ = _ ("The Pidgin buddy list file '%s' could not be loaded.");
504
 
                data->_tmp23_ = NULL;
505
 
                data->_tmp23_ = g_error_new (FOLKS_IMPORT_ERROR, FOLKS_IMPORT_ERROR_MALFORMED_INPUT, data->_tmp22_, data->filename);
506
 
                data->_inner_error_ = data->_tmp23_;
507
 
                if (data->_inner_error_->domain == FOLKS_IMPORT_ERROR) {
508
 
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
509
 
                        g_error_free (data->_inner_error_);
510
 
                        _g_object_unref0 (data->file_info);
511
 
                        _g_object_unref0 (data->file);
512
 
                        _g_free0 (data->filename);
513
 
                        if (data->_state_ == 0) {
514
 
                                g_simple_async_result_complete_in_idle (data->_async_result);
515
 
                        } else {
516
 
                                g_simple_async_result_complete (data->_async_result);
517
 
                        }
518
 
                        g_object_unref (data->_async_result);
519
 
                        return FALSE;
520
 
                } else {
521
 
                        _g_object_unref0 (data->file_info);
522
 
                        _g_object_unref0 (data->file);
523
 
                        _g_free0 (data->filename);
524
 
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
525
 
                        g_clear_error (&data->_inner_error_);
526
 
                        return FALSE;
527
 
                }
528
 
        }
529
 
        data->_tmp24_ = NULL;
530
 
        data->_tmp24_ = xmlDocGetRootElement (data->xml_doc);
531
 
        data->root_node = data->_tmp24_;
 
521
        data->_tmp21_ = xmlDocGetRootElement (data->xml_doc);
 
522
        data->root_node = data->_tmp21_;
532
523
        if (data->root_node == NULL) {
533
 
                data->_tmp26_ = TRUE;
534
 
        } else {
535
 
                data->_tmp26_ = g_strcmp0 (data->root_node->name, "purple") != 0;
536
 
        }
537
 
        if (data->_tmp26_) {
538
 
                data->_tmp25_ = TRUE;
539
 
        } else {
540
 
                data->_tmp27_ = NULL;
541
 
                data->_tmp27_ = xmlGetProp (data->root_node, "version");
542
 
                data->_tmp28_ = data->_tmp27_;
543
 
                data->_tmp25_ = g_strcmp0 (data->_tmp28_, "1.0") != 0;
544
 
                _g_free0 (data->_tmp28_);
545
 
        }
546
 
        if (data->_tmp25_) {
 
524
                data->_tmp23_ = TRUE;
 
525
        } else {
 
526
                data->_tmp23_ = g_strcmp0 (data->root_node->name, "purple") != 0;
 
527
        }
 
528
        if (data->_tmp23_) {
 
529
                data->_tmp22_ = TRUE;
 
530
        } else {
 
531
                data->_tmp24_ = NULL;
 
532
                data->_tmp24_ = xmlGetProp (data->root_node, "version");
 
533
                data->_tmp25_ = data->_tmp24_;
 
534
                data->_tmp22_ = g_strcmp0 (data->_tmp25_, "1.0") != 0;
 
535
                _g_free0 (data->_tmp25_);
 
536
        }
 
537
        if (data->_tmp22_) {
547
538
                xmlFreeDoc (data->xml_doc);
548
 
                data->_tmp29_ = NULL;
549
 
                data->_tmp29_ = _ ("The Pidgin buddy list file '%s' could not be loaded: the root element " \
 
539
                data->_tmp26_ = NULL;
 
540
                data->_tmp26_ = _ ("The Pidgin buddy list file '%s' could not be loaded: the root element " \
550
541
"could not be found or was not recognised.");
551
 
                data->_tmp30_ = NULL;
552
 
                data->_tmp30_ = g_error_new (FOLKS_IMPORT_ERROR, FOLKS_IMPORT_ERROR_MALFORMED_INPUT, data->_tmp29_, data->filename);
553
 
                data->_inner_error_ = data->_tmp30_;
 
542
                data->_tmp27_ = NULL;
 
543
                data->_tmp27_ = g_error_new (FOLKS_IMPORT_ERROR, FOLKS_IMPORT_ERROR_MALFORMED_INPUT, data->_tmp26_, data->filename);
 
544
                data->_inner_error_ = data->_tmp27_;
554
545
                if (data->_inner_error_->domain == FOLKS_IMPORT_ERROR) {
555
546
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
556
547
                        g_error_free (data->_inner_error_);
576
567
        {
577
568
                data->iter = data->root_node->children;
578
569
                {
579
 
                        data->_tmp31_ = TRUE;
 
570
                        data->_tmp28_ = TRUE;
580
571
                        while (TRUE) {
581
 
                                if (!data->_tmp31_) {
 
572
                                if (!data->_tmp28_) {
582
573
                                        data->iter = data->iter->next;
583
574
                                }
584
 
                                data->_tmp31_ = FALSE;
 
575
                                data->_tmp28_ = FALSE;
585
576
                                if (!(data->iter != NULL)) {
586
577
                                        break;
587
578
                                }
588
579
                                if (data->iter->type != XML_ELEMENT_NODE) {
589
 
                                        data->_tmp32_ = TRUE;
 
580
                                        data->_tmp29_ = TRUE;
590
581
                                } else {
591
 
                                        data->_tmp32_ = g_strcmp0 (data->iter->name, "blist") != 0;
 
582
                                        data->_tmp29_ = g_strcmp0 (data->iter->name, "blist") != 0;
592
583
                                }
593
 
                                if (data->_tmp32_) {
 
584
                                if (data->_tmp29_) {
594
585
                                        continue;
595
586
                                }
596
587
                                data->_state_ = 2;
602
593
                }
603
594
        }
604
595
        xmlFreeDoc (data->xml_doc);
605
 
        data->_tmp33_ = NULL;
606
 
        data->_tmp33_ = _ ("Imported %u buddies from '%s'.\n");
607
 
        fprintf (stdout, data->_tmp33_, data->self->priv->persona_count, data->filename);
 
596
        data->_tmp30_ = NULL;
 
597
        data->_tmp30_ = _ ("Imported %u buddies from '%s'.\n");
 
598
        fprintf (stdout, data->_tmp30_, data->self->priv->persona_count, data->filename);
608
599
        data->result = data->self->priv->persona_count;
609
600
        _g_object_unref0 (data->file_info);
610
601
        _g_object_unref0 (data->file);
987
978
                                                        if (g_strcmp0 (data->subiter->name, "alias") == 0) {
988
979
                                                                data->_tmp7_ = NULL;
989
980
                                                                data->_tmp7_ = xmlNodeGetContent (data->subiter);
990
 
                                                                data->_tmp8_ = data->_tmp7_;
991
981
                                                                _g_free0 (data->alias);
992
 
                                                                data->alias = data->_tmp8_;
 
982
                                                                data->alias = data->_tmp7_;
993
983
                                                        } else {
994
984
                                                                if (g_strcmp0 (data->subiter->name, "name") == 0) {
 
985
                                                                        data->_tmp8_ = NULL;
 
986
                                                                        data->_tmp8_ = xmlNodeGetContent (data->subiter);
 
987
                                                                        data->im_address = data->_tmp8_;
995
988
                                                                        data->_tmp9_ = NULL;
996
 
                                                                        data->_tmp9_ = xmlNodeGetContent (data->subiter);
997
 
                                                                        data->im_address = data->_tmp9_;
998
 
                                                                        data->_tmp10_ = NULL;
999
 
                                                                        data->_tmp10_ = g_hash_table_lookup (data->im_addresses, data->tp_protocol);
1000
 
                                                                        data->_tmp11_ = _g_ptr_array_ref0 ((GPtrArray*) data->_tmp10_);
1001
 
                                                                        data->im_address_array = data->_tmp11_;
 
989
                                                                        data->_tmp9_ = g_hash_table_lookup (data->im_addresses, data->tp_protocol);
 
990
                                                                        data->_tmp10_ = _g_ptr_array_ref0 ((GPtrArray*) data->_tmp9_);
 
991
                                                                        data->im_address_array = data->_tmp10_;
1002
992
                                                                        if (data->im_address_array == NULL) {
1003
 
                                                                                data->_tmp12_ = NULL;
1004
 
                                                                                data->_tmp12_ = g_ptr_array_new_with_free_func (_g_free0_);
1005
 
                                                                                data->_tmp13_ = data->_tmp12_;
 
993
                                                                                data->_tmp11_ = NULL;
 
994
                                                                                data->_tmp11_ = g_ptr_array_new_with_free_func (_g_free0_);
1006
995
                                                                                _g_ptr_array_unref0 (data->im_address_array);
1007
 
                                                                                data->im_address_array = data->_tmp13_;
1008
 
                                                                                data->_tmp14_ = g_strdup (data->tp_protocol);
1009
 
                                                                                data->_tmp15_ = _g_ptr_array_ref0 (data->im_address_array);
1010
 
                                                                                g_hash_table_insert (data->im_addresses, data->_tmp14_, data->_tmp15_);
 
996
                                                                                data->im_address_array = data->_tmp11_;
 
997
                                                                                data->_tmp12_ = g_strdup (data->tp_protocol);
 
998
                                                                                data->_tmp13_ = _g_ptr_array_ref0 (data->im_address_array);
 
999
                                                                                g_hash_table_insert (data->im_addresses, data->_tmp12_, data->_tmp13_);
1011
1000
                                                                        }
1012
 
                                                                        data->_tmp16_ = g_strdup (data->im_address);
1013
 
                                                                        g_ptr_array_add (data->im_address_array, data->_tmp16_);
1014
 
                                                                        data->_tmp17_ = NULL;
1015
 
                                                                        data->_tmp17_ = g_strdup_printf ("    %s\n", data->im_address);
1016
 
                                                                        data->_tmp18_ = data->_tmp17_;
1017
 
                                                                        data->_tmp19_ = g_strconcat (data->im_address_string, data->_tmp18_, NULL);
 
1001
                                                                        data->_tmp14_ = g_strdup (data->im_address);
 
1002
                                                                        g_ptr_array_add (data->im_address_array, data->_tmp14_);
 
1003
                                                                        data->_tmp15_ = NULL;
 
1004
                                                                        data->_tmp15_ = g_strdup_printf ("    %s\n", data->im_address);
 
1005
                                                                        data->_tmp16_ = data->_tmp15_;
 
1006
                                                                        data->_tmp17_ = g_strconcat (data->im_address_string, data->_tmp16_, NULL);
1018
1007
                                                                        _g_free0 (data->im_address_string);
1019
 
                                                                        data->im_address_string = data->_tmp19_;
1020
 
                                                                        _g_free0 (data->_tmp18_);
 
1008
                                                                        data->im_address_string = data->_tmp17_;
 
1009
                                                                        _g_free0 (data->_tmp16_);
1021
1010
                                                                        _g_ptr_array_unref0 (data->im_address_array);
1022
1011
                                                                        _g_free0 (data->im_address);
1023
1012
                                                                }
1030
1019
                        }
1031
1020
                }
1032
1021
        }
1033
 
        data->_tmp21_ = g_hash_table_size (data->im_addresses);
1034
 
        if (data->_tmp21_ < 2) {
 
1022
        data->_tmp19_ = g_hash_table_size (data->im_addresses);
 
1023
        if (data->_tmp19_ < 2) {
1035
1024
                if (data->alias == NULL) {
1036
 
                        data->_tmp23_ = TRUE;
 
1025
                        data->_tmp21_ = TRUE;
 
1026
                } else {
 
1027
                        data->_tmp22_ = NULL;
 
1028
                        data->_tmp22_ = string_strip (data->alias);
 
1029
                        data->_tmp23_ = data->_tmp22_;
 
1030
                        data->_tmp21_ = g_strcmp0 (data->_tmp23_, "") == 0;
 
1031
                        _g_free0 (data->_tmp23_);
 
1032
                }
 
1033
                if (data->_tmp21_) {
 
1034
                        data->_tmp20_ = TRUE;
1037
1035
                } else {
1038
1036
                        data->_tmp24_ = NULL;
1039
1037
                        data->_tmp24_ = string_strip (data->alias);
1040
1038
                        data->_tmp25_ = data->_tmp24_;
1041
 
                        data->_tmp23_ = g_strcmp0 (data->_tmp25_, "") == 0;
1042
 
                        _g_free0 (data->_tmp25_);
1043
 
                }
1044
 
                if (data->_tmp23_) {
1045
 
                        data->_tmp22_ = TRUE;
1046
 
                } else {
1047
1039
                        data->_tmp26_ = NULL;
1048
 
                        data->_tmp26_ = string_strip (data->alias);
 
1040
                        data->_tmp26_ = string_strip (data->im_address_string);
1049
1041
                        data->_tmp27_ = data->_tmp26_;
1050
 
                        data->_tmp28_ = NULL;
1051
 
                        data->_tmp28_ = string_strip (data->im_address_string);
1052
 
                        data->_tmp29_ = data->_tmp28_;
1053
 
                        data->_tmp22_ = g_strcmp0 (data->_tmp27_, data->_tmp29_) == 0;
1054
 
                        _g_free0 (data->_tmp29_);
 
1042
                        data->_tmp20_ = g_strcmp0 (data->_tmp25_, data->_tmp27_) == 0;
1055
1043
                        _g_free0 (data->_tmp27_);
 
1044
                        _g_free0 (data->_tmp25_);
1056
1045
                }
1057
 
                data->_tmp20_ = data->_tmp22_;
 
1046
                data->_tmp18_ = data->_tmp20_;
1058
1047
        } else {
1059
 
                data->_tmp20_ = FALSE;
 
1048
                data->_tmp18_ = FALSE;
1060
1049
        }
1061
 
        if (data->_tmp20_) {
1062
 
                data->_tmp30_ = NULL;
1063
 
                data->_tmp30_ = _ ("Ignoring buddy with no alias and only one IM address:\n%s");
1064
 
                fprintf (stdout, data->_tmp30_, data->im_address_string);
 
1050
        if (data->_tmp18_) {
 
1051
                data->_tmp28_ = NULL;
 
1052
                data->_tmp28_ = _ ("Ignoring buddy with no alias and only one IM address:\n%s");
 
1053
                fprintf (stdout, data->_tmp28_, data->im_address_string);
1065
1054
                data->result = NULL;
1066
1055
                _g_free0 (data->im_address_string);
1067
1056
                _g_hash_table_unref0 (data->im_addresses);
1074
1063
                g_object_unref (data->_async_result);
1075
1064
                return FALSE;
1076
1065
        }
1077
 
        data->_tmp31_ = NULL;
1078
 
        data->_tmp31_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, __vala_GValue_free0_);
1079
 
        data->details = data->_tmp31_;
 
1066
        data->_tmp29_ = NULL;
 
1067
        data->_tmp29_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, __vala_GValue_free0_);
 
1068
        data->details = data->_tmp29_;
1080
1069
        g_value_init (&data->im_addresses_value, G_TYPE_HASH_TABLE);
1081
1070
        g_value_set_boxed (&data->im_addresses_value, data->im_addresses);
1082
 
        data->_tmp32_ = g_strdup ("im-addresses");
1083
 
        data->_tmp33_ = __g_value_dup0 (&data->im_addresses_value);
1084
 
        g_hash_table_insert (data->details, data->_tmp32_, data->_tmp33_);
 
1071
        data->_tmp30_ = g_strdup ("im-addresses");
 
1072
        data->_tmp31_ = __g_value_dup0 (&data->im_addresses_value);
 
1073
        g_hash_table_insert (data->details, data->_tmp30_, data->_tmp31_);
1085
1074
        data->_state_ = 1;
1086
1075
        folks_persona_store_add_persona_from_details (data->self->priv->destination_store, data->details, folks_importers_pidgin_parse_contact_ready, data);
1087
1076
        return FALSE;
1088
1077
        _state_1:
1089
 
        data->_tmp34_ = NULL;
1090
 
        data->_tmp34_ = folks_persona_store_add_persona_from_details_finish (data->self->priv->destination_store, data->_res_, &data->_inner_error_);
1091
 
        data->_tmp35_ = data->_tmp34_;
 
1078
        data->_tmp32_ = NULL;
 
1079
        data->_tmp32_ = folks_persona_store_add_persona_from_details_finish (data->self->priv->destination_store, data->_res_, &data->_inner_error_);
 
1080
        data->_tmp33_ = data->_tmp32_;
1092
1081
        if (data->_inner_error_ != NULL) {
1093
1082
                if (data->_inner_error_->domain == FOLKS_PERSONA_STORE_ERROR) {
1094
1083
                        goto __catch7_folks_persona_store_error;
1103
1092
                g_clear_error (&data->_inner_error_);
1104
1093
                return FALSE;
1105
1094
        }
1106
 
        data->_tmp36_ = data->_tmp35_;
1107
1095
        _g_object_unref0 (data->persona);
1108
 
        data->persona = data->_tmp36_;
 
1096
        data->persona = data->_tmp33_;
1109
1097
        goto __finally7;
1110
1098
        __catch7_folks_persona_store_error:
1111
1099
        {
1112
1100
                data->e = data->_inner_error_;
1113
1101
                data->_inner_error_ = NULL;
1114
 
                data->_tmp37_ = NULL;
1115
 
                data->_tmp37_ = _ ("Failed to create new persona for buddy with alias '%s' and IM addresse" \
 
1102
                data->_tmp34_ = NULL;
 
1103
                data->_tmp34_ = _ ("Failed to create new persona for buddy with alias '%s' and IM addresse" \
1116
1104
"s:\n" \
1117
1105
"%s\n" \
1118
1106
"Error: %s\n");
1119
 
                fprintf (stderr, data->_tmp37_, data->alias, data->im_address_string, data->e->message);
 
1107
                fprintf (stderr, data->_tmp34_, data->alias, data->im_address_string, data->e->message);
1120
1108
                data->result = NULL;
1121
1109
                _g_error_free0 (data->e);
1122
1110
                _g_object_unref0 (data->persona);
1146
1134
                return FALSE;
1147
1135
        }
1148
1136
        if (data->alias != NULL) {
1149
 
                data->_tmp38_ = FOLKS_IS_ALIAS_DETAILS (data->persona);
 
1137
                data->_tmp35_ = FOLKS_IS_ALIAS_DETAILS (data->persona);
1150
1138
        } else {
1151
 
                data->_tmp38_ = FALSE;
 
1139
                data->_tmp35_ = FALSE;
1152
1140
        }
1153
 
        if (data->_tmp38_) {
 
1141
        if (data->_tmp35_) {
1154
1142
                folks_alias_details_set_alias (FOLKS_ALIAS_DETAILS (data->persona), data->alias);
1155
1143
        }
1156
 
        data->_tmp39_ = NULL;
1157
 
        data->_tmp39_ = _ ("Created persona '%s' for buddy with alias '%s' and IM addresses:\n%s");
1158
 
        data->_tmp40_ = NULL;
1159
 
        data->_tmp40_ = folks_persona_get_uid (data->persona);
1160
 
        fprintf (stdout, data->_tmp39_, data->_tmp40_, data->alias, data->im_address_string);
 
1144
        data->_tmp36_ = NULL;
 
1145
        data->_tmp36_ = _ ("Created persona '%s' for buddy with alias '%s' and IM addresses:\n%s");
 
1146
        data->_tmp37_ = NULL;
 
1147
        data->_tmp37_ = folks_persona_get_uid (data->persona);
 
1148
        fprintf (stdout, data->_tmp36_, data->_tmp37_, data->alias, data->im_address_string);
1161
1149
        data->self->priv->persona_count++;
1162
1150
        data->result = data->persona;
1163
1151
        G_IS_VALUE (&data->im_addresses_value) ? (g_value_unset (&data->im_addresses_value), NULL) : NULL;
1188
1176
}
1189
1177
 
1190
1178
 
 
1179
static glong string_strnlen (gchar* str, glong maxlen) {
 
1180
        glong result = 0L;
 
1181
        gchar* _tmp0_ = NULL;
 
1182
        gchar* end;
 
1183
        _tmp0_ = memchr (str, 0, (gsize) maxlen);
 
1184
        end = _tmp0_;
 
1185
        if (end == NULL) {
 
1186
                result = maxlen;
 
1187
                return result;
 
1188
        } else {
 
1189
                result = (glong) (end - str);
 
1190
                return result;
 
1191
        }
 
1192
}
 
1193
 
 
1194
 
1191
1195
static gchar* string_substring (const gchar* self, glong offset, glong len) {
1192
1196
        gchar* result = NULL;
1193
1197
        glong string_length = 0L;
1201
1205
        }
1202
1206
        if (_tmp0_) {
1203
1207
                glong _tmp1_;
1204
 
                _tmp1_ = strnlen ((gchar*) self, (gsize) (offset + len));
 
1208
                _tmp1_ = string_strnlen ((gchar*) self, offset + len);
1205
1209
                string_length = _tmp1_;
1206
1210
        } else {
1207
1211
                gint _tmp2_;
1236
1240
        _tmp1_ = g_str_has_prefix (blist_protocol, "prpl-");
1237
1241
        if (_tmp1_) {
1238
1242
                gchar* _tmp2_ = NULL;
 
1243
                _tmp2_ = string_substring (blist_protocol, (glong) 5, (glong) (-1));
 
1244
                _g_free0 (tp_protocol);
 
1245
                tp_protocol = _tmp2_;
 
1246
        }
 
1247
        if (g_strcmp0 (tp_protocol, "bonjour") == 0) {
1239
1248
                gchar* _tmp3_;
1240
 
                _tmp2_ = string_substring (blist_protocol, (glong) 5, (glong) (-1));
1241
 
                _tmp3_ = _tmp2_;
 
1249
                _tmp3_ = g_strdup ("local-xmpp");
1242
1250
                _g_free0 (tp_protocol);
1243
1251
                tp_protocol = _tmp3_;
1244
 
        }
1245
 
        if (g_strcmp0 (tp_protocol, "bonjour") == 0) {
1246
 
                gchar* _tmp4_;
1247
 
                gchar* _tmp5_;
1248
 
                _tmp4_ = g_strdup ("local-xmpp");
1249
 
                _tmp5_ = _tmp4_;
1250
 
                _g_free0 (tp_protocol);
1251
 
                tp_protocol = _tmp5_;
1252
1252
        } else {
1253
1253
                if (g_strcmp0 (tp_protocol, "novell") == 0) {
1254
 
                        gchar* _tmp6_;
1255
 
                        gchar* _tmp7_;
1256
 
                        _tmp6_ = g_strdup ("groupwise");
1257
 
                        _tmp7_ = _tmp6_;
 
1254
                        gchar* _tmp4_;
 
1255
                        _tmp4_ = g_strdup ("groupwise");
1258
1256
                        _g_free0 (tp_protocol);
1259
 
                        tp_protocol = _tmp7_;
 
1257
                        tp_protocol = _tmp4_;
1260
1258
                } else {
1261
1259
                        if (g_strcmp0 (tp_protocol, "gg") == 0) {
1262
 
                                gchar* _tmp8_;
1263
 
                                gchar* _tmp9_;
1264
 
                                _tmp8_ = g_strdup ("gadugadu");
1265
 
                                _tmp9_ = _tmp8_;
 
1260
                                gchar* _tmp5_;
 
1261
                                _tmp5_ = g_strdup ("gadugadu");
1266
1262
                                _g_free0 (tp_protocol);
1267
 
                                tp_protocol = _tmp9_;
 
1263
                                tp_protocol = _tmp5_;
1268
1264
                        } else {
1269
1265
                                if (g_strcmp0 (tp_protocol, "meanwhile") == 0) {
1270
 
                                        gchar* _tmp10_;
1271
 
                                        gchar* _tmp11_;
1272
 
                                        _tmp10_ = g_strdup ("sametime");
1273
 
                                        _tmp11_ = _tmp10_;
 
1266
                                        gchar* _tmp6_;
 
1267
                                        _tmp6_ = g_strdup ("sametime");
1274
1268
                                        _g_free0 (tp_protocol);
1275
 
                                        tp_protocol = _tmp11_;
 
1269
                                        tp_protocol = _tmp6_;
1276
1270
                                } else {
1277
1271
                                        if (g_strcmp0 (tp_protocol, "simple") == 0) {
1278
 
                                                gchar* _tmp12_;
1279
 
                                                gchar* _tmp13_;
1280
 
                                                _tmp12_ = g_strdup ("sip");
1281
 
                                                _tmp13_ = _tmp12_;
 
1272
                                                gchar* _tmp7_;
 
1273
                                                _tmp7_ = g_strdup ("sip");
1282
1274
                                                _g_free0 (tp_protocol);
1283
 
                                                tp_protocol = _tmp13_;
 
1275
                                                tp_protocol = _tmp7_;
1284
1276
                                        }
1285
1277
                                }
1286
1278
                        }