Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • protocols/twitter/twitter_lib.c

    rbbff22d red83279  
    3636#include "base64.h"
    3737#include "twitter_lib.h"
    38 #include "json_util.h"
     38#include "parson.h"
    3939#include <ctype.h>
    4040#include <errno.h>
    … …  
    6464        gboolean from_filter;
    6565};
     66
     67#define JSON_O_FOREACH(o, k, v) \
     68    const char *k; const JSON_Value *v; int __i; \
     69    for (__i = 0; json_object_get_tuple(o, __i, &k, &v); __i++)
    6670
    6771/**
    … …  
    166170{
    167171        static char *ret = NULL;
    168         json_value *root, *err;
     172        JSON_Value *root, *err;
    169173
    170174        g_free(ret);
    … …  
    172176
    173177        if (req->body_size > 0) {
    174                 root = json_parse(req->reply_body, req->body_size);
    175                 err = json_o_get(root, "errors");
    176                 if (err && err->type == json_array && (err = err->u.array.values[0]) &&
    177                     err->type == json_object) {
    178                         const char *msg = json_o_str(err, "message");
     178                root = json_parse_string(req->reply_body);
     179                err = json_object_get_value(json_object(root), "errors");
     180                if (err && json_type(err) == JSONArray &&
     181                    (err = json_array_get_value(json_array(err), 0)) &&
     182                    json_type(err) == JSONObject) {
     183                        const char *msg = json_object_get_string(json_object(err), "message");
    179184                        if (msg) {
    180185                                ret = g_strdup_printf("%s (%s)", req->status_string, msg);
    … …  
    189194/* WATCH OUT: This function might or might not destroy your connection.
    190195   Sub-optimal indeed, but just be careful when this returns NULL! */
    191 static json_value *twitter_parse_response(struct im_connection *ic, struct http_request *req)
     196static JSON_Value *twitter_parse_response(struct im_connection *ic, struct http_request *req)
    192197{
    193198        gboolean logging_in = !(ic->flags & OPT_LOGGED_IN);
    194199        gboolean periodic;
    195200        struct twitter_data *td = ic->proto_data;
    196         json_value *ret;
     201        JSON_Value *ret;
    197202        char path[64] = "", *s;
    198203
    … …  
    232237        }
    233238
    234         if ((ret = json_parse(req->reply_body, req->body_size)) == NULL) {
     239        if ((ret = json_parse_string(req->reply_body)) == NULL) {
    235240                imcb_error(ic, "Could not retrieve %s: %s",
    236241                           path, "XML parse error");
    … …  
    259264 * Fill a list of ids.
    260265 */
    261 static gboolean twitter_xt_get_friends_id_list(json_value *node, struct twitter_xml_list *txl)
    262 {
    263         json_value *c;
     266static gboolean twitter_xt_get_friends_id_list(JSON_Value *node, struct twitter_xml_list *txl)
     267{
     268        JSON_Array *c;
    264269        int i;
    265270
    … …  
    267272        txl->type = TXL_ID;
    268273
    269         c = json_o_get(node, "ids");
    270         if (!c || c->type != json_array) {
     274        if (!(c = json_object_get_array(json_object(node), "ids"))) {
    271275                return FALSE;
    272276        }
    273277
    274         for (i = 0; i < c->u.array.length; i++) {
    275                 if (c->u.array.values[i]->type != json_integer) {
    276                         continue;
    277                 }
     278        for (i = 0; i < json_array_get_count(c); i++) {
     279                jint id = json_array_get_integer(c, i);
    278280
    279281                txl->list = g_slist_prepend(txl->list,
    280                                             g_strdup_printf("%" PRIu64, c->u.array.values[i]->u.integer));
    281         }
    282 
    283         c = json_o_get(node, "next_cursor");
    284         if (c && c->type == json_integer) {
    285                 txl->next_cursor = c->u.integer;
     282                                            g_strdup_printf("%lld", id));
     283        }
     284
     285        JSON_Value *next = json_object_get_value(json_object(node), "next_cursor");
     286        if (next && json_type(next) == JSONInteger) {
     287                txl->next_cursor = json_integer(next);
    286288        } else {
    287289                txl->next_cursor = -1;
    … …  
    299301{
    300302        struct im_connection *ic;
    301         json_value *parsed;
     303        JSON_Value *parsed;
    302304        struct twitter_xml_list *txl;
    303305        struct twitter_data *td;
    … …  
    312314        td = ic->proto_data;
    313315
     316        txl = g_new0(struct twitter_xml_list, 1);
     317        txl->list = td->follow_ids;
     318
    314319        // Parse the data.
    315320        if (!(parsed = twitter_parse_response(ic, req))) {
    316321                return;
    317322        }
    318 
    319         txl = g_new0(struct twitter_xml_list, 1);
    320         txl->list = td->follow_ids;
    321323
    322324        twitter_xt_get_friends_id_list(parsed, txl);
    … …  
    337339}
    338340
    339 static gboolean twitter_xt_get_users(json_value *node, struct twitter_xml_list *txl);
     341static gboolean twitter_xt_get_users(JSON_Value *node, struct twitter_xml_list *txl);
    340342static void twitter_http_get_users_lookup(struct http_request *req);
    341343
    … …  
    378380{
    379381        struct im_connection *ic = req->data;
    380         json_value *parsed;
     382        JSON_Value *parsed;
    381383        struct twitter_xml_list *txl;
    382384        GSList *l = NULL;
    … …  
    388390        }
    389391
     392        txl = g_new0(struct twitter_xml_list, 1);
     393        txl->list = NULL;
     394
    390395        // Get the user list from the parsed xml feed.
    391396        if (!(parsed = twitter_parse_response(ic, req))) {
    392397                return;
    393398        }
    394 
    395         txl = g_new0(struct twitter_xml_list, 1);
    396         txl->list = NULL;
    397 
    398399        twitter_xt_get_users(parsed, txl);
    399400        json_value_free(parsed);
    … …  
    411412}
    412413
    413 struct twitter_xml_user *twitter_xt_get_user(const json_value *node)
     414struct twitter_xml_user *twitter_xt_get_user(const JSON_Object *node)
    414415{
    415416        struct twitter_xml_user *txu;
    416         json_value *jv;
     417       
     418        if (!node)
     419                return NULL;
    417420
    418421        txu = g_new0(struct twitter_xml_user, 1);
    419         txu->name = g_strdup(json_o_str(node, "name"));
    420         txu->screen_name = g_strdup(json_o_str(node, "screen_name"));
    421 
    422         jv = json_o_get(node, "id");
    423         txu->uid = jv->u.integer;
     422        txu->name = g_strdup(json_object_get_string(node, "name"));
     423        txu->screen_name = g_strdup(json_object_get_string(node, "screen_name"));
     424        txu->uid = json_object_get_integer(node, "id");
    424425
    425426        return txu;
    … …  
    431432 *  - all <user>s from the <users> element.
    432433 */
    433 static gboolean twitter_xt_get_users(json_value *node, struct twitter_xml_list *txl)
     434static gboolean twitter_xt_get_users(JSON_Value *node, struct twitter_xml_list *txl)
    434435{
    435436        struct twitter_xml_user *txu;
    … …  
    439440        txl->type = TXL_USER;
    440441
    441         if (!node || node->type != json_array) {
     442        if (json_type(node) != JSONArray) {
    442443                return FALSE;
    443444        }
    444 
     445       
    445446        // The root <users> node should hold the list of users <user>
    446447        // Walk over the nodes children.
    447         for (i = 0; i < node->u.array.length; i++) {
    448                 txu = twitter_xt_get_user(node->u.array.values[i]);
     448        JSON_Array *arr = json_array(node);
     449        for (i = 0; i < json_array_get_count(arr); i++) {
     450                JSON_Object *o = json_array_get_object(arr, i);
     451                if (!o)
     452                        continue;
     453                txu = twitter_xt_get_user(o);
    449454                if (txu) {
    450455                        txl->list = g_slist_prepend(txl->list, txu);
    … …  
    461466#endif
    462467
    463 static void expand_entities(char **text, const json_value *node);
     468static void expand_entities(char **text, const JSON_Object *node);
    464469
    465470/**
    … …  
    471476 *  - the user in a twitter_xml_user struct.
    472477 */
    473 static struct twitter_xml_status *twitter_xt_get_status(const json_value *node)
     478static struct twitter_xml_status *twitter_xt_get_status(const JSON_Object *node)
    474479{
    475480        struct twitter_xml_status *txs;
    476         const json_value *rt = NULL;
    477 
    478         if (node->type != json_object) {
     481        const JSON_Object *rt = NULL;
     482
     483        if (!node) {
    479484                return FALSE;
    480485        }
    … …  
    482487
    483488        JSON_O_FOREACH(node, k, v) {
    484                 if (strcmp("text", k) == 0 && v->type == json_string) {
    485                         txs->text = g_memdup(v->u.string.ptr, v->u.string.length + 1);
     489                if (strcmp("text", k) == 0 && (txs->text = g_strdup(json_string(v)))) {
     490                        // TODO: Huh strip html? In json? Not sure whether I have to..
    486491                        strip_html(txs->text);
    487                 } else if (strcmp("retweeted_status", k) == 0 && v->type == json_object) {
    488                         rt = v;
    489                 } else if (strcmp("created_at", k) == 0 && v->type == json_string) {
     492                } else if (strcmp("retweeted_status", k) == 0 && (rt = json_object(v))) {
     493                        // Handling below.
     494                } else if (strcmp("created_at", k) == 0 && json_type(v) == JSONString) {
    490495                        struct tm parsed;
    491496
    … …  
    493498                           this field. :-( Also assumes the timezone used
    494499                           is UTC since C time handling functions suck. */
    495                         if (strptime(v->u.string.ptr, TWITTER_TIME_FORMAT, &parsed) != NULL) {
     500                        if (strptime(json_string(v), TWITTER_TIME_FORMAT, &parsed) != NULL) {
    496501                                txs->created_at = mktime_utc(&parsed);
    497502                        }
    498                 } else if (strcmp("user", k) == 0 && v->type == json_object) {
    499                         txs->user = twitter_xt_get_user(v);
    500                 } else if (strcmp("id", k) == 0 && v->type == json_integer) {
    501                         txs->rt_id = txs->id = v->u.integer;
    502                 } else if (strcmp("in_reply_to_status_id", k) == 0 && v->type == json_integer) {
    503                         txs->reply_to = v->u.integer;
     503                } else if (strcmp("user", k) == 0 && json_type(v) == JSONObject) {
     504                        txs->user = twitter_xt_get_user(json_object(v));
     505                } else if (strcmp("id", k) == 0 && json_type(v) == JSONInteger) {
     506                        txs->rt_id = txs->id = json_integer(v);
     507                } else if (strcmp("in_reply_to_status_id", k) == 0 && json_type(v) == JSONInteger) {
     508                        txs->reply_to = json_integer(v);
    504509                }
    505510        }
    … …  
    530535 * Function to fill a twitter_xml_status struct (DM variant).
    531536 */
    532 static struct twitter_xml_status *twitter_xt_get_dm(const json_value *node)
     537static struct twitter_xml_status *twitter_xt_get_dm(const JSON_Object *node)
    533538{
    534539        struct twitter_xml_status *txs;
    535540
    536         if (node->type != json_object) {
     541        if (!node) {
    537542                return FALSE;
    538543        }
    … …  
    540545
    541546        JSON_O_FOREACH(node, k, v) {
    542                 if (strcmp("text", k) == 0 && v->type == json_string) {
    543                         txs->text = g_memdup(v->u.string.ptr, v->u.string.length + 1);
     547                if (strcmp("text", k) == 0 && (txs->text = g_strdup(json_string(v)))) {
    544548                        strip_html(txs->text);
    545                 } else if (strcmp("created_at", k) == 0 && v->type == json_string) {
     549                } else if (strcmp("created_at", k) == 0 && json_type(v) == JSONString) {
    546550                        struct tm parsed;
    547551
    … …  
    549553                           this field. :-( Also assumes the timezone used
    550554                           is UTC since C time handling functions suck. */
    551                         if (strptime(v->u.string.ptr, TWITTER_TIME_FORMAT, &parsed) != NULL) {
     555                        if (strptime(json_string(v), TWITTER_TIME_FORMAT, &parsed) != NULL) {
    552556                                txs->created_at = mktime_utc(&parsed);
    553557                        }
    554                 } else if (strcmp("sender", k) == 0 && v->type == json_object) {
    555                         txs->user = twitter_xt_get_user(v);
    556                 } else if (strcmp("id", k) == 0 && v->type == json_integer) {
    557                         txs->id = v->u.integer;
     558                } else if (strcmp("sender", k) == 0 && json_type(v) == JSONObject) {
     559                        txs->user = twitter_xt_get_user(json_object(v));
     560                } else if (strcmp("id", k) == 0 && json_type(v) == JSONInteger) {
     561                        txs->id = json_integer(v);
    558562                }
    559563        }
    … …  
    569573}
    570574
    571 static void expand_entities(char **text, const json_value *node)
    572 {
    573         json_value *entities, *quoted;
     575static void expand_entities(char **text, const JSON_Object *node)
     576{
     577        JSON_Object *entities, *quoted;
    574578        char *quote_url = NULL, *quote_text = NULL;
    575579
    576         if (!((entities = json_o_get(node, "entities")) && entities->type == json_object))
    577                 return;
    578         if ((quoted = json_o_get(node, "quoted_status")) && quoted->type == json_object) {
     580        if (!(entities = json_object_get_object(node, "entities")))
     581                return;
     582        if ((quoted = json_object_get_object(node, "quoted_status"))) {
    579583                /* New "retweets with comments" feature. Note that this info
    580584                 * seems to be included in the streaming API only! Grab the
    … …  
    592596                int i;
    593597
    594                 if (v->type != json_array) {
     598                if (json_type(v) != JSONArray) {
    595599                        continue;
    596600                }
    … …  
    599603                }
    600604
    601                 for (i = 0; i < v->u.array.length; i++) {
     605                for (i = 0; i < json_array_get_count(json_array(v)); i++) {
    602606                        const char *format = "%s%s <%s>%s";
    603 
    604                         if (v->u.array.values[i]->type != json_object) {
     607                        JSON_Object *r = json_array_get_object(json_array(v), i);
     608
     609                        if (!r) {
    605610                                continue;
    606611                        }
    607612
    608                         const char *kort = json_o_str(v->u.array.values[i], "url");
    609                         const char *disp = json_o_str(v->u.array.values[i], "display_url");
    610                         const char *full = json_o_str(v->u.array.values[i], "expanded_url");
     613                        const char *kort = json_object_get_string(r, "url");
     614                        const char *disp = json_object_get_string(r, "display_url");
     615                        const char *full = json_object_get_string(r, "expanded_url");
    611616                        char *pos, *new;
    612617
    … …  
    637642 *  - the next_cursor.
    638643 */
    639 static gboolean twitter_xt_get_status_list(struct im_connection *ic, const json_value *node,
     644static gboolean twitter_xt_get_status_list(struct im_connection *ic, const JSON_Value *node,
    640645                                           struct twitter_xml_list *txl)
    641646{
    … …  
    646651        txl->type = TXL_STATUS;
    647652
    648         if (node->type != json_array) {
     653        if (json_type(node) != JSONArray) {
    649654                return FALSE;
    650655        }
    … …  
    652657        // The root <statuses> node should hold the list of statuses <status>
    653658        // Walk over the nodes children.
    654         for (i = 0; i < node->u.array.length; i++) {
    655                 txs = twitter_xt_get_status(node->u.array.values[i]);
     659        for (i = 0; i < json_array_get_count(json_array(node)); i++) {
     660                txs = twitter_xt_get_status(json_array_get_object(json_array(node), i));
    656661                if (!txs) {
    657662                        continue;
    … …  
    859864}
    860865
    861 static gboolean twitter_stream_handle_object(struct im_connection *ic, json_value *o, gboolean from_filter);
     866static gboolean twitter_stream_handle_object(struct im_connection *ic, JSON_Object *o, gboolean from_filter);
    862867
    863868static void twitter_http_stream(struct http_request *req)
    … …  
    865870        struct im_connection *ic = req->data;
    866871        struct twitter_data *td;
    867         json_value *parsed;
     872        JSON_Value *parsed;
    868873        int len = 0;
    869874        char c, *nl;
    … …  
    903908                req->reply_body[len] = '\0';
    904909
    905                 if ((parsed = json_parse(req->reply_body, req->body_size))) {
     910                if ((parsed = json_parse_string(req->reply_body))) {
    906911                        from_filter = (req == td->filter_stream);
    907                         twitter_stream_handle_object(ic, parsed, from_filter);
     912                        twitter_stream_handle_object(ic, json_object(parsed), from_filter);
    908913                }
    909914                json_value_free(parsed);
    … …  
    919924}
    920925
    921 static gboolean twitter_stream_handle_event(struct im_connection *ic, json_value *o);
     926static gboolean twitter_stream_handle_event(struct im_connection *ic, JSON_Object *o);
    922927static gboolean twitter_stream_handle_status(struct im_connection *ic, struct twitter_xml_status *txs);
    923928
    924 static gboolean twitter_stream_handle_object(struct im_connection *ic, json_value *o, gboolean from_filter)
     929static gboolean twitter_stream_handle_object(struct im_connection *ic, JSON_Object *o, gboolean from_filter)
    925930{
    926931        struct twitter_data *td = ic->proto_data;
    927932        struct twitter_xml_status *txs;
    928         json_value *c;
     933        JSON_Object *c;
    929934
    930935        if ((txs = twitter_xt_get_status(o))) {
    … …  
    933938                txs_free(txs);
    934939                return ret;
    935         } else if ((c = json_o_get(o, "direct_message")) &&
     940        } else if ((c = json_object_get_object(o, "direct_message")) &&
    936941                   (txs = twitter_xt_get_dm(c))) {
    937942                if (g_strcasecmp(txs->user->screen_name, td->user) != 0) {
    … …  
    941946                txs_free(txs);
    942947                return TRUE;
    943         } else if ((c = json_o_get(o, "event")) && c->type == json_string) {
     948        } else if (json_object_get_string(o, "event")) {
    944949                twitter_stream_handle_event(ic, o);
    945950                return TRUE;
    946         } else if ((c = json_o_get(o, "disconnect")) && c->type == json_object) {
     951        } else if ((c = json_object_get_object(o, "disconnect"))) {
    947952                /* HACK: Because we're inside an event handler, we can't just
    948953                   disconnect here. Instead, just change the HTTP status string
    949954                   into a Twitter status string. */
    950                 char *reason = json_o_strdup(c, "reason");
     955                char *reason = g_strdup(json_object_get_string(c, "reason"));
    951956                if (reason) {
    952957                        g_free(td->stream->status_string);
    … …  
    987992}
    988993
    989 static gboolean twitter_stream_handle_event(struct im_connection *ic, json_value *o)
    990 {
    991         struct twitter_data *td = ic->proto_data;
    992         json_value *source = json_o_get(o, "source");
    993         json_value *target = json_o_get(o, "target");
    994         const char *type = json_o_str(o, "event");
    995 
    996         if (!type || !source || source->type != json_object
    997             || !target || target->type != json_object) {
     994static gboolean twitter_stream_handle_event(struct im_connection *ic, JSON_Object *o)
     995{
     996        struct twitter_data *td = ic->proto_data;
     997        JSON_Object *source = json_object_get_object(o, "source");
     998        JSON_Object *target = json_object_get_object(o, "target");
     999        const char *type = json_object_get_string(o, "event");
     1000
     1001        if (!type || !source || !target) {
    9981002                return FALSE;
    9991003        }
    … …  
    10921096        struct twitter_filter *tf;
    10931097        GList *users = NULL;
    1094         json_value *parsed;
    1095         json_value *id;
    1096         const char *name;
     1098        JSON_Value *parsed;
    10971099        GString *fstr;
    10981100        GSList *l;
    … …  
    11191121        }
    11201122
    1121         if (parsed->type != json_array) {
     1123        if (json_type(parsed) != JSONArray) {
    11221124                goto finish;
    11231125        }
    11241126
    1125         for (i = 0; i < parsed->u.array.length; i++) {
    1126                 id = json_o_get(parsed->u.array.values[i], "id");
    1127                 name = json_o_str(parsed->u.array.values[i], "screen_name");
    1128 
    1129                 if (!name || !id || id->type != json_integer) {
     1127        for (i = 0; i < json_array_get_count(json_array(parsed)); i++) {
     1128                JSON_Object *o = json_array_get_object(json_array(parsed), i);
     1129                jint id = json_object_get_integer(o, "id");
     1130                const char *name = json_object_get_string(o, "screen_name");
     1131
     1132                if (!name || !id) {
    11301133                        continue;
    11311134                }
    … …  
    11351138
    11361139                        if (g_strcasecmp(tf->text, name) == 0) {
    1137                                 tf->uid = id->u.integer;
     1140                                tf->uid = id;
    11381141                                users = g_list_delete_link(users, u);
    11391142                                break;
    … …  
    13761379        struct im_connection *ic = req->data;
    13771380        struct twitter_data *td;
    1378         json_value *parsed;
     1381        JSON_Value *parsed;
    13791382        struct twitter_xml_list *txl;
    13801383
    … …  
    13851388
    13861389        td = ic->proto_data;
     1390
     1391        txl = g_new0(struct twitter_xml_list, 1);
     1392        txl->list = NULL;
    13871393
    13881394        // The root <statuses> node should hold the list of statuses <status>
    … …  
    13901396                goto end;
    13911397        }
     1398        twitter_xt_get_status_list(ic, parsed, txl);
     1399        json_value_free(parsed);
     1400
     1401        td->home_timeline_obj = txl;
     1402
     1403end:
     1404        if (!g_slist_find(twitter_connections, ic)) {
     1405                return;
     1406        }
     1407
     1408        td->flags |= TWITTER_GOT_TIMELINE;
     1409
     1410        twitter_flush_timeline(ic);
     1411}
     1412
     1413/**
     1414 * Callback for getting mentions.
     1415 */
     1416static void twitter_http_get_mentions(struct http_request *req)
     1417{
     1418        struct im_connection *ic = req->data;
     1419        struct twitter_data *td;
     1420        JSON_Value *parsed;
     1421        struct twitter_xml_list *txl;
     1422
     1423        // Check if the connection is still active.
     1424        if (!g_slist_find(twitter_connections, ic)) {
     1425                return;
     1426        }
     1427
     1428        td = ic->proto_data;
    13921429
    13931430        txl = g_new0(struct twitter_xml_list, 1);
    13941431        txl->list = NULL;
    1395 
    1396         twitter_xt_get_status_list(ic, parsed, txl);
    1397         json_value_free(parsed);
    1398 
    1399         td->home_timeline_obj = txl;
    1400 
    1401 end:
    1402         if (!g_slist_find(twitter_connections, ic)) {
    1403                 return;
    1404         }
    1405 
    1406         td->flags |= TWITTER_GOT_TIMELINE;
    1407 
    1408         twitter_flush_timeline(ic);
    1409 }
    1410 
    1411 /**
    1412  * Callback for getting mentions.
    1413  */
    1414 static void twitter_http_get_mentions(struct http_request *req)
    1415 {
    1416         struct im_connection *ic = req->data;
    1417         struct twitter_data *td;
    1418         json_value *parsed;
    1419         struct twitter_xml_list *txl;
    1420 
    1421         // Check if the connection is still active.
    1422         if (!g_slist_find(twitter_connections, ic)) {
    1423                 return;
    1424         }
    1425 
    1426         td = ic->proto_data;
    14271432
    14281433        // The root <statuses> node should hold the list of statuses <status>
    … …  
    14301435                goto end;
    14311436        }
    1432 
    1433         txl = g_new0(struct twitter_xml_list, 1);
    1434         txl->list = NULL;
    1435 
    14361437        twitter_xt_get_status_list(ic, parsed, txl);
    14371438        json_value_free(parsed);
    … …  
    14571458        struct im_connection *ic = req->data;
    14581459        struct twitter_data *td;
    1459         json_value *parsed, *id;
     1460        JSON_Value *parsed;
     1461        jint id;
    14601462
    14611463        // Check if the connection is still active.
    … …  
    14711473        }
    14721474
    1473         if ((id = json_o_get(parsed, "id")) && id->type == json_integer) {
    1474                 td->last_status_id = id->u.integer;
     1475        if ((id = json_object_get_integer(json_object(parsed), "id"))) {
     1476                td->last_status_id = id;
    14751477        }
    14761478
    … …  
    15801582{
    15811583        struct im_connection *ic = req->data;
    1582         json_value *parsed, *id;
     1584        JSON_Value *parsed;
     1585        uint64_t id;
    15831586        const char *name;
    15841587
    … …  
    15921595        }
    15931596
    1594         /* for the parson branch:
    15951597        name = json_object_dotget_string(json_object(parsed), "user.screen_name");
    15961598        id = json_object_get_integer(json_object(parsed), "id");
    1597         */
    1598 
    1599         name = json_o_str(json_o_get(parsed, "user"), "screen_name");
    1600         id = json_o_get(parsed, "id");
    1601 
    1602         if (name && id && id->type == json_integer) {
    1603                 twitter_log(ic, "https://twitter.com/%s/status/%" G_GUINT64_FORMAT, name, id->u.integer);
     1599
     1600        if (name && id) {
     1601                twitter_log(ic, "https://twitter.com/%s/status/%" G_GUINT64_FORMAT, name, id);
    16041602        } else {
    16051603                twitter_log(ic, "Error: could not fetch tweet url.");
Note: See TracChangeset for help on using the changeset viewer.