Changeset a35b458 in mainline for uspace/lib/c/generic/loc.c


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/loc.c

    r3061bc1 ra35b458  
    6060                ipc_call_t call;
    6161                ipc_callid_t callid = async_get_call(&call);
    62                
     62
    6363                if (!IPC_GET_IMETHOD(call)) {
    6464                        /* TODO: Handle hangup */
    6565                        return;
    6666                }
    67                
     67
    6868                switch (IPC_GET_IMETHOD(call)) {
    6969                case LOC_EVENT_CAT_CHANGE:
    … …  
    7171                        loc_cat_change_cb_t cb_fun = cat_change_cb;
    7272                        fibril_mutex_unlock(&loc_callback_mutex);
    73                        
     73
    7474                        async_answer_0(callid, EOK);
    75                        
     75
    7676                        if (cb_fun != NULL)
    7777                                (*cb_fun)();
    78                        
     78
    7979                        break;
    8080                default:
    … …  
    8989{
    9090        fibril_mutex_lock(mtx);
    91        
     91
    9292        if ((*dst == NULL) && (src != NULL))
    9393                *dst = src;
    94        
     94
    9595        fibril_mutex_unlock(mtx);
    9696}
    … …  
    108108                async_exch_t *exch =
    109109                    loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    110                
     110
    111111                ipc_call_t answer;
    112112                aid_t req = async_send_0(exch, LOC_CALLBACK_CREATE, &answer);
    113                
     113
    114114                port_id_t port;
    115115                errno_t rc = async_create_callback_port(exch, INTERFACE_LOC_CB, 0, 0,
    116116                    loc_cb_conn, NULL, &port);
    117                
     117
    118118                loc_exchange_end(exch);
    119                
     119
    120120                if (rc != EOK)
    121121                        return rc;
    122                
     122
    123123                errno_t retval;
    124124                async_wait_for(req, &retval);
    125125                if (retval != EOK)
    126126                        return retval;
    127                
     127
    128128                loc_callback_created = true;
    129129        }
    130        
     130
    131131        return EOK;
    132132}
    … …  
    144144        case INTERFACE_LOC_SUPPLIER:
    145145                fibril_mutex_lock(&loc_supp_block_mutex);
    146                
     146
    147147                while (loc_supp_block_sess == NULL) {
    148148                        clone_session(&loc_supplier_mutex, loc_supplier_sess,
    149149                            &loc_supp_block_sess);
    150                        
     150
    151151                        if (loc_supp_block_sess == NULL)
    152152                                loc_supp_block_sess =
    … …  
    154154                                    INTERFACE_LOC_SUPPLIER, 0);
    155155                }
    156                
     156
    157157                fibril_mutex_unlock(&loc_supp_block_mutex);
    158                
     158
    159159                clone_session(&loc_supplier_mutex, loc_supp_block_sess,
    160160                    &loc_supplier_sess);
    161                
     161
    162162                return async_exchange_begin(loc_supp_block_sess);
    163163        case INTERFACE_LOC_CONSUMER:
    164164                fibril_mutex_lock(&loc_cons_block_mutex);
    165                
     165
    166166                while (loc_cons_block_sess == NULL) {
    167167                        clone_session(&loc_consumer_mutex, loc_consumer_sess,
    168168                            &loc_cons_block_sess);
    169                        
     169
    170170                        if (loc_cons_block_sess == NULL)
    171171                                loc_cons_block_sess =
    … …  
    173173                                    INTERFACE_LOC_CONSUMER, 0);
    174174                }
    175                
     175
    176176                fibril_mutex_unlock(&loc_cons_block_mutex);
    177                
     177
    178178                clone_session(&loc_consumer_mutex, loc_cons_block_sess,
    179179                    &loc_consumer_sess);
    180                
     180
    181181                return async_exchange_begin(loc_cons_block_sess);
    182182        default:
    … …  
    197197        case INTERFACE_LOC_SUPPLIER:
    198198                fibril_mutex_lock(&loc_supplier_mutex);
    199                
     199
    200200                if (loc_supplier_sess == NULL)
    201201                        loc_supplier_sess =
    202202                            service_connect(SERVICE_LOC,
    203203                            INTERFACE_LOC_SUPPLIER, 0);
    204                
     204
    205205                fibril_mutex_unlock(&loc_supplier_mutex);
    206                
     206
    207207                if (loc_supplier_sess == NULL)
    208208                        return NULL;
    209                
     209
    210210                return async_exchange_begin(loc_supplier_sess);
    211211        case INTERFACE_LOC_CONSUMER:
    212212                fibril_mutex_lock(&loc_consumer_mutex);
    213                
     213
    214214                if (loc_consumer_sess == NULL)
    215215                        loc_consumer_sess =
    216216                            service_connect(SERVICE_LOC,
    217217                            INTERFACE_LOC_CONSUMER, 0);
    218                
     218
    219219                fibril_mutex_unlock(&loc_consumer_mutex);
    220                
     220
    221221                if (loc_consumer_sess == NULL)
    222222                        return NULL;
    223                
     223
    224224                return async_exchange_begin(loc_consumer_sess);
    225225        default:
    … …  
    242242{
    243243        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    244        
     244
    245245        ipc_call_t answer;
    246246        aid_t req = async_send_2(exch, LOC_SERVER_REGISTER, 0, 0, &answer);
    247247        errno_t retval = async_data_write_start(exch, name, str_size(name));
    248        
     248
    249249        if (retval != EOK) {
    250250                async_forget(req);
    … …  
    252252                return retval;
    253253        }
    254        
     254
    255255        async_connect_to_me(exch, 0, 0, 0);
    256256
    … …  
    262262        async_wait_for(req, &retval);
    263263        loc_exchange_end(exch);
    264        
     264
    265265        return retval;
    266266}
    … …  
    275275{
    276276        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    277        
     277
    278278        ipc_call_t answer;
    279279        aid_t req = async_send_0(exch, LOC_SERVICE_REGISTER, &answer);
    280280        errno_t retval = async_data_write_start(exch, fqsn, str_size(fqsn));
    281        
     281
    282282        if (retval != EOK) {
    283283                async_forget(req);
    … …  
    285285                return retval;
    286286        }
    287        
     287
    288288        /*
    289289         * First wait for the answer and then end the exchange. The opposite
    … …  
    293293        async_wait_for(req, &retval);
    294294        loc_exchange_end(exch);
    295        
     295
    296296        if (retval != EOK) {
    297297                if (sid != NULL)
    298298                        *sid = -1;
    299                
    300                 return retval;
    301         }
    302        
     299
     300                return retval;
     301        }
     302
    303303        if (sid != NULL)
    304304                *sid = (service_id_t) IPC_GET_ARG1(answer);
    305        
     305
    306306        return retval;
    307307}
    … …  
    315315        async_exch_t *exch;
    316316        errno_t retval;
    317        
     317
    318318        exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    319319        retval = async_req_1_0(exch, LOC_SERVICE_UNREGISTER, sid);
    320320        loc_exchange_end(exch);
    321        
     321
    322322        return (errno_t)retval;
    323323}
    … …  
    327327{
    328328        async_exch_t *exch;
    329        
     329
    330330        if (flags & IPC_FLAG_BLOCKING)
    331331                exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    … …  
    335335                        return errno;
    336336        }
    337        
     337
    338338        ipc_call_t answer;
    339339        aid_t req = async_send_2(exch, LOC_SERVICE_GET_ID, flags, 0,
    340340            &answer);
    341341        errno_t retval = async_data_write_start(exch, fqdn, str_size(fqdn));
    342        
    343         loc_exchange_end(exch);
    344        
     342
     343        loc_exchange_end(exch);
     344
    345345        if (retval != EOK) {
    346346                async_forget(req);
    347347                return retval;
    348348        }
    349        
     349
    350350        async_wait_for(req, &retval);
    351        
     351
    352352        if (retval != EOK) {
    353353                if (handle != NULL)
    354354                        *handle = (service_id_t) -1;
    355                
    356                 return retval;
    357         }
    358        
     355
     356                return retval;
     357        }
     358
    359359        if (handle != NULL)
    360360                *handle = (service_id_t) IPC_GET_ARG1(answer);
    361        
     361
    362362        return retval;
    363363}
    … …  
    380380        size_t act_size;
    381381        errno_t dretval;
    382        
     382
    383383        *name = NULL;
    384384        exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    385        
     385
    386386        ipc_call_t answer;
    387387        aid_t req = async_send_1(exch, method, id, &answer);
    … …  
    389389            &dreply);
    390390        async_wait_for(dreq, &dretval);
    391        
    392         loc_exchange_end(exch);
    393        
     391
     392        loc_exchange_end(exch);
     393
    394394        if (dretval != EOK) {
    395395                async_forget(req);
    396396                return dretval;
    397397        }
    398        
     398
    399399        errno_t retval;
    400400        async_wait_for(req, &retval);
    401        
     401
    402402        if (retval != EOK)
    403403                return retval;
    404        
     404
    405405        act_size = IPC_GET_ARG2(dreply);
    406406        assert(act_size <= LOC_NAME_MAXLEN);
    … …  
    410410        if (*name == NULL)
    411411                return ENOMEM;
    412        
     412
    413413        return EOK;
    414414}
    … …  
    460460{
    461461        async_exch_t *exch;
    462        
     462
    463463        if (flags & IPC_FLAG_BLOCKING)
    464464                exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    … …  
    468468                        return errno;
    469469        }
    470        
     470
    471471        ipc_call_t answer;
    472472        aid_t req = async_send_2(exch, LOC_NAMESPACE_GET_ID, flags, 0,
    473473            &answer);
    474474        errno_t retval = async_data_write_start(exch, name, str_size(name));
    475        
    476         loc_exchange_end(exch);
    477        
     475
     476        loc_exchange_end(exch);
     477
    478478        if (retval != EOK) {
    479479                async_forget(req);
    480480                return retval;
    481481        }
    482        
     482
    483483        async_wait_for(req, &retval);
    484        
     484
    485485        if (retval != EOK) {
    486486                if (handle != NULL)
    487487                        *handle = (service_id_t) -1;
    488                
    489                 return retval;
    490         }
    491        
     488
     489                return retval;
     490        }
     491
    492492        if (handle != NULL)
    493493                *handle = (service_id_t) IPC_GET_ARG1(answer);
    494        
     494
    495495        return retval;
    496496}
    … …  
    509509{
    510510        async_exch_t *exch;
    511        
     511
    512512        if (flags & IPC_FLAG_BLOCKING)
    513513                exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    … …  
    517517                        return errno;
    518518        }
    519        
     519
    520520        ipc_call_t answer;
    521521        aid_t req = async_send_0(exch, LOC_CATEGORY_GET_ID,
    522522            &answer);
    523523        errno_t retval = async_data_write_start(exch, name, str_size(name));
    524        
    525         loc_exchange_end(exch);
    526        
     524
     525        loc_exchange_end(exch);
     526
    527527        if (retval != EOK) {
    528528                async_forget(req);
    529529                return retval;
    530530        }
    531        
     531
    532532        async_wait_for(req, &retval);
    533        
     533
    534534        if (retval != EOK) {
    535535                if (cat_id != NULL)
    536536                        *cat_id = (category_id_t) -1;
    537                
    538                 return retval;
    539         }
    540        
     537
     538                return retval;
     539        }
     540
    541541        if (cat_id != NULL)
    542542                *cat_id = (category_id_t) IPC_GET_ARG1(answer);
    543        
     543
    544544        return retval;
    545545}
    … …  
    549549{
    550550        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    551        
     551
    552552        sysarg_t type;
    553553        errno_t retval = async_req_1_1(exch, LOC_ID_PROBE, handle, &type);
    554        
    555         loc_exchange_end(exch);
    556        
     554
     555        loc_exchange_end(exch);
     556
    557557        if (retval != EOK)
    558558                return LOC_OBJECT_NONE;
    559        
     559
    560560        return (loc_object_type_t) type;
    561561}
    … …  
    565565{
    566566        async_sess_t *sess;
    567        
     567
    568568        if (flags & IPC_FLAG_BLOCKING)
    569569                sess = service_connect_blocking(SERVICE_LOC, iface, handle);
    570570        else
    571571                sess = service_connect(SERVICE_LOC, iface, handle);
    572        
     572
    573573        return sess;
    574574}
    … …  
    580580{
    581581        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_CONSUMER);
    582        
     582
    583583        sysarg_t null_id;
    584584        errno_t retval = async_req_0_1(exch, LOC_NULL_CREATE, &null_id);
    585        
    586         loc_exchange_end(exch);
    587        
     585
     586        loc_exchange_end(exch);
     587
    588588        if (retval != EOK)
    589589                return -1;
    590        
     590
    591591        return (int) null_id;
    592592}
    … …  
    605605        if (retval != EOK)
    606606                return 0;
    607        
     607
    608608        return count;
    609609}
    … …  
    619619        async_exch_t *exch;
    620620        errno_t retval;
    621        
     621
    622622        exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    623623        retval = async_req_2_0(exch, LOC_SERVICE_ADD_TO_CAT, svc_id, cat_id);
    624624        loc_exchange_end(exch);
    625        
     625
    626626        return retval;
    627627}
    … …  
    635635        if (retval != EOK)
    636636                return 0;
    637        
     637
    638638        return count;
    639639}
    … …  
    644644        size_t size = loc_count_namespaces_internal(exch);
    645645        loc_exchange_end(exch);
    646        
     646
    647647        return size;
    648648}
    … …  
    653653        size_t size = loc_count_services_internal(exch, ns_handle);
    654654        loc_exchange_end(exch);
    655        
     655
    656656        return size;
    657657}
    … …  
    664664                size_t count = loc_count_namespaces_internal(exch);
    665665                loc_exchange_end(exch);
    666                
     666
    667667                if (count == 0)
    668668                        return 0;
    669                
     669
    670670                loc_sdesc_t *devs = (loc_sdesc_t *) calloc(count, sizeof(loc_sdesc_t));
    671671                if (devs == NULL)
    672672                        return 0;
    673                
     673
    674674                exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
    675                
     675
    676676                ipc_call_t answer;
    677677                aid_t req = async_send_0(exch, LOC_GET_NAMESPACES, &answer);
    678678                errno_t rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t));
    679                
     679
    680680                loc_exchange_end(exch);
    681                
     681
    682682                if (rc == EOVERFLOW) {
    683683                        /*
    … …  
    688688                        continue;
    689689                }
    690                
     690
    691691                if (rc != EOK) {
    692692                        async_forget(req);
    … …  
    694694                        return 0;
    695695                }
    696                
     696
    697697                errno_t retval;
    698698                async_wait_for(req, &retval);
    699                
     699
    700700                if (retval != EOK)
    701701                        return 0;
    702                
     702
    703703                *data = devs;
    704704                return count;
    … …  
    713713                size_t count = loc_count_services_internal(exch, ns_handle);
    714714                loc_exchange_end(exch);
    715                
     715
    716716                if (count == 0)
    717717                        return 0;
    718                
     718
    719719                loc_sdesc_t *devs = (loc_sdesc_t *) calloc(count, sizeof(loc_sdesc_t));
    720720                if (devs == NULL)
    721721                        return 0;
    722                
     722
    723723                exch = loc_exchange_begin(INTERFACE_LOC_CONSUMER);
    724                
     724
    725725                ipc_call_t answer;
    726726                aid_t req = async_send_1(exch, LOC_GET_SERVICES, ns_handle, &answer);
    727727                errno_t rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t));
    728                
     728
    729729                loc_exchange_end(exch);
    730                
     730
    731731                if (rc == EOVERFLOW) {
    732732                        /*
    … …  
    737737                        continue;
    738738                }
    739                
     739
    740740                if (rc != EOK) {
    741741                        async_forget(req);
    … …  
    743743                        return 0;
    744744                }
    745                
     745
    746746                errno_t retval;
    747747                async_wait_for(req, &retval);
    748                
     748
    749749                if (retval != EOK)
    750750                        return 0;
    751                
     751
    752752                *data = devs;
    753753                return count;
    … …  
    763763        aid_t req = async_send_1(exch, method, arg1, &answer);
    764764        errno_t rc = async_data_read_start(exch, id_buf, buf_size);
    765        
    766         loc_exchange_end(exch);
    767        
     765
     766        loc_exchange_end(exch);
     767
    768768        if (rc != EOK) {
    769769                async_forget(req);
    770770                return rc;
    771771        }
    772        
     772
    773773        errno_t retval;
    774774        async_wait_for(req, &retval);
    775        
    776         if (retval != EOK) {
    777                 return retval;
    778         }
    779        
     775
     776        if (retval != EOK) {
     777                return retval;
     778        }
     779
    780780        *act_size = IPC_GET_ARG1(answer);
    781781        return EOK;
    … …  
    797797        *data = NULL;
    798798        *count = 0;
    799        
     799
    800800        size_t act_size = 0;
    801801        errno_t rc = loc_category_get_ids_once(method, arg1, NULL, 0,
    … …  
    803803        if (rc != EOK)
    804804                return rc;
    805        
     805
    806806        size_t alloc_size = act_size;
    807807        service_id_t *ids = malloc(alloc_size);
    808808        if (ids == NULL)
    809809                return ENOMEM;
    810        
     810
    811811        while (true) {
    812812                rc = loc_category_get_ids_once(method, arg1, ids, alloc_size,
    … …  
    814814                if (rc != EOK)
    815815                        return rc;
    816                
     816
    817817                if (act_size <= alloc_size)
    818818                        break;
    819                
     819
    820820                alloc_size = act_size;
    821821                ids = realloc(ids, alloc_size);
    … …  
    823823                        return ENOMEM;
    824824        }
    825        
     825
    826826        *count = act_size / sizeof(category_id_t);
    827827        *data = ids;
    … …  
    866866                return EIO;
    867867        }
    868        
     868
    869869        cat_change_cb = cb_fun;
    870870        fibril_mutex_unlock(&loc_callback_mutex);
    871        
     871
    872872        return EOK;
    873873}
Note: See TracChangeset for help on using the changeset viewer.