Changeset 07dadda in lilv


Ignore:
Timestamp:
10/28/15 22:03:03 (22 months ago)
Author:
David Robillard <d@…>
Branches:
master
Children:
cfad5fc
Parents:
95979c0
Message:

Fix long lines

git-svn-id: http://svn.drobilla.net/lad/trunk/lilv@5800 a436a847-0d15-0410-975c-d299462d15a1

Location:
src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/lib.c

    r91dec7d r07dadda  
    5757        desc = ldf(bundle_path, features); 
    5858        if (!desc) { 
    59             LILV_ERRORF("Call to `lv2_lib_descriptor' in %s failed\n", lib_path); 
     59            LILV_ERRORF("Call to %s:lv2_lib_descriptor failed\n", lib_path); 
    6060            lilv_free(lib_path); 
    6161            return NULL; 
  • src/plugin.c

    ree7ad94 r07dadda  
    113113        p->world, subject, predicate, NULL); 
    114114    if (!sord_iter_end(stream)) { 
    115         ret = lilv_node_new_from_node(p->world, sord_iter_get_node(stream, SORD_OBJECT)); 
     115        ret = lilv_node_new_from_node(p->world, 
     116                                      sord_iter_get_node(stream, SORD_OBJECT)); 
    116117    } 
    117118    sord_iter_free(stream); 
     
    143144                                         bundle_uri_node); 
    144145 
    145     SordModel* prototypes = lilv_world_filter_model(p->world, 
    146                                                     p->world->model, 
    147                                                     p->plugin_uri->node, 
    148                                                     p->world->uris.lv2_prototype, 
    149                                                     NULL, NULL); 
     146    SordModel* prots = lilv_world_filter_model(p->world, 
     147                                               p->world->model, 
     148                                               p->plugin_uri->node, 
     149                                               p->world->uris.lv2_prototype, 
     150                                               NULL, NULL); 
    150151    SordModel* skel = sord_new(p->world->world, SORD_SPO, false); 
    151     SordIter*  iter = sord_begin(prototypes); 
     152    SordIter*  iter = sord_begin(prots); 
    152153    for (; !sord_iter_end(iter); sord_iter_next(iter)) { 
    153154        const SordNode* t         = sord_iter_get_node(iter, SORD_OBJECT); 
     
    177178    sord_iter_free(iter); 
    178179    sord_free(skel); 
    179     sord_free(prototypes); 
     180    sord_free(prots); 
    180181 
    181182    // Parse all the plugin's data files into RDF model 
     
    389390    if (!p->plugin_class) { 
    390391        // <plugin> a ?class 
    391         SordIter* results = lilv_world_query_internal(p->world, 
    392                                                       p->plugin_uri->node, 
    393                                                       p->world->uris.rdf_a, 
    394                                                       NULL); 
    395         FOREACH_MATCH(results) { 
    396             const SordNode* class_node = sord_iter_get_node(results, SORD_OBJECT); 
     392        SordIter* c = lilv_world_query_internal(p->world, 
     393                                                p->plugin_uri->node, 
     394                                                p->world->uris.rdf_a, 
     395                                                NULL); 
     396        FOREACH_MATCH(c) { 
     397            const SordNode* class_node = sord_iter_get_node(c, SORD_OBJECT); 
    397398            if (sord_node_get_type(class_node) != SORD_URI) { 
    398399                continue; 
     
    413414            lilv_node_free(klass); 
    414415        } 
    415         sord_iter_free(results); 
     416        sord_iter_free(c); 
    416417 
    417418        if (p->plugin_class == NULL) 
     
    867868} 
    868869 
     870static LilvNode* 
     871lilv_plugin_get_author_property(const LilvPlugin* plugin, const char* uri) 
     872{ 
     873    const SordNode* author = lilv_plugin_get_author(plugin); 
     874    if (author) { 
     875        SordWorld* sworld = plugin->world->world; 
     876        SordNode*  pred   = sord_new_uri(sworld, uri); 
     877        LilvNode*  ret    = lilv_plugin_get_one(plugin, author, pred); 
     878        sord_node_free(sworld, pred); 
     879        return ret; 
     880    } 
     881    return NULL; 
     882} 
     883 
    869884LILV_API LilvNode* 
    870885lilv_plugin_get_author_name(const LilvPlugin* plugin) 
    871886{ 
    872     const SordNode* author = lilv_plugin_get_author(plugin); 
    873     if (author) { 
    874         SordWorld* sworld    = plugin->world->world; 
    875         SordNode*  foaf_name = sord_new_uri(sworld, NS_FOAF "name"); 
    876         LilvNode*  ret       = lilv_plugin_get_one(plugin, author, foaf_name); 
    877         sord_node_free(sworld, foaf_name); 
    878         return ret; 
    879     } 
    880     return NULL; 
     887    return lilv_plugin_get_author_property(plugin, NS_FOAF "name"); 
    881888} 
    882889 
     
    884891lilv_plugin_get_author_email(const LilvPlugin* plugin) 
    885892{ 
    886     const SordNode* author = lilv_plugin_get_author(plugin); 
    887     if (author) { 
    888         SordWorld* sworld    = plugin->world->world; 
    889         SordNode*  foaf_mbox = sord_new_uri(sworld, NS_FOAF "mbox"); 
    890         LilvNode*  ret       = lilv_plugin_get_one(plugin, author, foaf_mbox); 
    891         sord_node_free(sworld, foaf_mbox); 
    892         return ret; 
    893     } 
    894     return NULL; 
     893    return lilv_plugin_get_author_property(plugin, NS_FOAF "mbox"); 
    895894} 
    896895 
     
    898897lilv_plugin_get_author_homepage(const LilvPlugin* plugin) 
    899898{ 
    900     const SordNode* author = lilv_plugin_get_author(plugin); 
    901     if (author) { 
    902         SordWorld* sworld        = plugin->world->world; 
    903         SordNode*  foaf_homepage = sord_new_uri(sworld, NS_FOAF "homepage"); 
    904         LilvNode*  ret           = lilv_plugin_get_one(plugin, author, foaf_homepage); 
    905         sord_node_free(sworld, foaf_homepage); 
    906         return ret; 
    907     } 
    908     return NULL; 
     899    return lilv_plugin_get_author_property(plugin, NS_FOAF "homepage"); 
    909900} 
    910901 
  • src/state.c

    r1bdcf38 r07dadda  
    6363    PortValue* values;      ///< Port values 
    6464    uint32_t   atom_Path;   ///< atom:Path URID 
    65     uint32_t   num_props;   ///< Number of state properties 
    66     uint32_t   num_values;  ///< Number of port values 
     65    uint32_t   n_props;     ///< Number of state properties 
     66    uint32_t   n_values;    ///< Number of port values 
    6767}; 
    6868 
     
    109109    if (value) { 
    110110        state->values = (PortValue*)realloc( 
    111             state->values, (++state->num_values) * sizeof(PortValue)); 
    112         PortValue* pv = &state->values[state->num_values - 1]; 
     111            state->values, (++state->n_values) * sizeof(PortValue)); 
     112        PortValue* pv = &state->values[state->n_values - 1]; 
    113113        pv->symbol = lilv_strdup(port_symbol); 
    114114        pv->value  = malloc(size); 
     
    142142    LilvState* const state = (LilvState*)handle; 
    143143    state->props = (Property*)realloc( 
    144         state->props, (++state->num_props) * sizeof(Property)); 
    145     Property* const prop = &state->props[state->num_props - 1]; 
     144        state->props, (++state->n_props) * sizeof(Property)); 
     145    Property* const prop = &state->props[state->n_props - 1]; 
    146146 
    147147    if ((flags & LV2_STATE_IS_POD) || type == state->atom_Path) { 
     
    171171    const Property         search_key = { NULL, 0, key, 0, 0 }; 
    172172    const Property* const  prop       = (Property*)bsearch( 
    173         &search_key, state->props, state->num_props, 
     173        &search_key, state->props, state->n_props, 
    174174        sizeof(Property), property_cmp); 
    175175 
     
    391391            free(state->props); 
    392392            state->props     = NULL; 
    393             state->num_props = 0; 
     393            state->n_props = 0; 
    394394        } else { 
    395             qsort(state->props, state->num_props, sizeof(Property), property_cmp); 
    396         } 
    397     } 
    398  
    399     qsort(state->values, state->num_values, sizeof(PortValue), value_cmp); 
     395            qsort(state->props, state->n_props, sizeof(Property), property_cmp); 
     396        } 
     397    } 
     398 
     399    qsort(state->values, state->n_values, sizeof(PortValue), value_cmp); 
    400400 
    401401    free(sfeatures); 
     
    408408                            void*                user_data) 
    409409{ 
    410     for (uint32_t i = 0; i < state->num_values; ++i) { 
     410    for (uint32_t i = 0; i < state->n_values; ++i) { 
    411411        const PortValue* val = &state->values[i]; 
    412412        set_value(val->symbol, user_data, val->value, val->size, val->type); 
     
    431431    LV2_Feature map_feature = { LV2_STATE__mapPath, &map_path }; 
    432432 
    433     const LV2_Feature** sfeatures = add_features(features, &map_feature, NULL); 
    434  
    435     const LV2_Descriptor*      desc  = instance ? instance->lv2_descriptor : NULL; 
    436     const LV2_State_Interface* iface = (desc && desc->extension_data) 
    437         ? (const LV2_State_Interface*)desc->extension_data(LV2_STATE__interface) 
    438         : NULL; 
    439  
    440     if (iface) { 
    441         iface->restore(instance->lv2_handle, retrieve_callback, 
    442                        (LV2_State_Handle)state, flags, sfeatures); 
    443     } 
    444  
    445     free(sfeatures); 
     433    if (instance) { 
     434        const LV2_Descriptor* desc = instance->lv2_descriptor; 
     435        if (desc->extension_data) { 
     436            const LV2_State_Interface* iface = (const LV2_State_Interface*) 
     437                desc->extension_data(LV2_STATE__interface); 
     438 
     439            const LV2_Feature** sfeatures = add_features( 
     440                features, &map_feature, NULL); 
     441 
     442            iface->restore(instance->lv2_handle, retrieve_callback, 
     443                           (LV2_State_Handle)state, flags, sfeatures); 
     444 
     445            free(sfeatures); 
     446        } 
     447    } 
     448 
    446449 
    447450    if (set_value) { 
     
    549552        SordIter* props = sord_search(model, state_node, 0, 0, 0); 
    550553        FOREACH_MATCH(props) { 
    551             const SordNode* p = sord_iter_get_node(props, SORD_PREDICATE); 
    552             const SordNode* o = sord_iter_get_node(props, SORD_OBJECT); 
     554            const SordNode* p   = sord_iter_get_node(props, SORD_PREDICATE); 
     555            const SordNode* o   = sord_iter_get_node(props, SORD_OBJECT); 
     556            const char*     key = (const char*)sord_node_get_string(p); 
    553557 
    554558            chunk.len = 0; 
     
    561565            Property        prop  = { NULL, 0, 0, 0, flags }; 
    562566 
    563             prop.key   = map->map(map->handle, (const char*)sord_node_get_string(p)); 
     567            prop.key   = map->map(map->handle, pred); 
    564568            prop.type  = atom->type; 
    565569            prop.size  = atom->size; 
     
    572576            if (prop.value) { 
    573577                state->props = (Property*)realloc( 
    574                     state->props, (++state->num_props) * sizeof(Property)); 
    575                 state->props[state->num_props - 1] = prop; 
     578                    state->props, (++state->n_props) * sizeof(Property)); 
     579                state->props[state->n_props - 1] = prop; 
    576580            } 
    577581        } 
     
    584588    sratom_free(sratom); 
    585589 
    586     qsort(state->props, state->num_props, sizeof(Property), property_cmp); 
    587     qsort(state->values, state->num_values, sizeof(PortValue), value_cmp); 
     590    qsort(state->props, state->n_props, sizeof(Property), property_cmp); 
     591    qsort(state->values, state->n_values, sizeof(PortValue), value_cmp); 
    588592 
    589593    return state; 
     
    701705    SerdWriter* writer = serd_writer_new( 
    702706        SERD_TURTLE, 
    703         (SerdStyle)(SERD_STYLE_RESOLVED|SERD_STYLE_ABBREVIATED|SERD_STYLE_CURIED), 
     707        (SerdStyle)(SERD_STYLE_RESOLVED | 
     708                    SERD_STYLE_ABBREVIATED| 
     709                    SERD_STYLE_CURIED), 
    704710        env, 
    705711        &base_uri, 
     
    907913 
    908914    // Write port values 
    909     for (uint32_t i = 0; i < state->num_values; ++i) { 
     915    for (uint32_t i = 0; i < state->n_values; ++i) { 
    910916        PortValue* const value = &state->values[i]; 
    911917 
     
    938944    const SerdNode state_node = serd_node_from_string(SERD_BLANK, 
    939945                                                      USTR("2state")); 
    940     if (state->num_props > 0) { 
     946    if (state->n_props > 0) { 
    941947        p = serd_node_from_string(SERD_URI, USTR(LV2_STATE__state)); 
    942948        serd_writer_write_statement(writer, SERD_ANON_O_BEGIN, NULL, 
    943949                                    &subject, &p, &state_node, NULL, NULL); 
    944950    } 
    945     for (uint32_t i = 0; i < state->num_props; ++i) { 
     951    for (uint32_t i = 0; i < state->n_props; ++i) { 
    946952        Property*   prop = &state->props[i]; 
    947953        const char* key  = unmap->unmap(unmap->handle, prop->key); 
     
    959965        } 
    960966    } 
    961     if (state->num_props > 0) { 
     967    if (state->n_props > 0) { 
    962968        serd_writer_end_anon(writer, &state_node); 
    963969    } 
     
    11171123    if (file) { 
    11181124        // Remove state file 
    1119         char* file_path = lilv_file_uri_parse( 
     1125        char* path = lilv_file_uri_parse( 
    11201126            (const char*)sord_node_get_string(file), NULL); 
    1121         if (unlink(file_path)) { 
    1122             LILV_ERRORF("Failed to remove %s (%s)\n", file_path, strerror(errno)); 
    1123         } 
    1124         lilv_free(file_path); 
     1127        if (unlink(path)) { 
     1128            LILV_ERRORF("Failed to remove %s (%s)\n", path, strerror(errno)); 
     1129        } 
     1130        lilv_free(path); 
    11251131    } 
    11261132 
     
    11631169{ 
    11641170    if (state) { 
    1165         for (uint32_t i = 0; i < state->num_props; ++i) { 
     1171        for (uint32_t i = 0; i < state->n_props; ++i) { 
    11661172            free(state->props[i].value); 
    11671173        } 
    1168         for (uint32_t i = 0; i < state->num_values; ++i) { 
     1174        for (uint32_t i = 0; i < state->n_values; ++i) { 
    11691175            free(state->values[i].value); 
    11701176            free(state->values[i].symbol); 
     
    11921198        || (b->label && !a->label) 
    11931199        || (a->label && b->label && strcmp(a->label, b->label)) 
    1194         || a->num_props != b->num_props 
    1195         || a->num_values != b->num_values) { 
     1200        || a->n_props != b->n_props 
     1201        || a->n_values != b->n_values) { 
    11961202        return false; 
    11971203    } 
    11981204 
    1199     for (uint32_t i = 0; i < a->num_values; ++i) { 
     1205    for (uint32_t i = 0; i < a->n_values; ++i) { 
    12001206        PortValue* const av = &a->values[i]; 
    12011207        PortValue* const bv = &b->values[i]; 
     
    12071213    } 
    12081214 
    1209     for (uint32_t i = 0; i < a->num_props; ++i) { 
     1215    for (uint32_t i = 0; i < a->n_props; ++i) { 
    12101216        Property* const ap = &a->props[i]; 
    12111217        Property* const bp = &b->props[i]; 
     
    12311237lilv_state_get_num_properties(const LilvState* state) 
    12321238{ 
    1233     return state->num_props; 
     1239    return state->n_props; 
    12341240} 
    12351241 
  • src/util.c

    re57faf2 r07dadda  
    4343    typedef BOOLEAN (WINAPI* PFUNC)(LPCTSTR, LPCTSTR, DWORD); 
    4444 
    45     PFUNC pfn = (PFUNC)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "CreateSymbolicLinkA"); 
     45    PFUNC pfn = (PFUNC)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), 
     46                                      "CreateSymbolicLinkA"); 
    4647    return pfn ? pfn(linkpath, targetpath, flags) : 0; 
    4748} 
Note: See TracChangeset for help on using the changeset viewer.