Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 7fa8589 in mainline


Ignore:
Timestamp:
2020-01-09T01:04:58Z (9 months ago)
Author:
Matthieu Riolo <matthieu.riolo@…>
Children:
bcd7775
Parents:
76c8209
git-author:
Matthieu Riolo <matthieu.riolo@…> (2020-01-05 20:21:10)
git-committer:
Matthieu Riolo <matthieu.riolo@…> (2020-01-09 01:04:58)
Message:

Removing unneeded casts from errno_t to errno_t

Files:
18 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/ipc/sysipc.c

    r76c8209 r7fa8589  
    192192        spinlock_unlock(&answer->forget_lock);
    193193
    194         if ((errno_t) ipc_get_retval(&answer->data) == EHANGUP) {
     194        if (ipc_get_retval(&answer->data) == EHANGUP) {
    195195                phone_t *phone = answer->caller_phone;
    196196                mutex_lock(&phone->lock);
     
    238238static void process_answer(call_t *call)
    239239{
    240         if (((errno_t) ipc_get_retval(&call->data) == EHANGUP) &&
     240        if ((ipc_get_retval(&call->data) == EHANGUP) &&
    241241            (call->flags & IPC_CALL_FORWARDED))
    242242                ipc_set_retval(&call->data, EFORWARD);
  • uspace/lib/c/generic/async/server.c

    r76c8209 r7fa8589  
    13951395        async_wait_for(msg, &rc);
    13961396
    1397         return (errno_t) rc;
     1397        return rc;
    13981398}
    13991399
     
    16401640        async_wait_for(msg, &rc);
    16411641
    1642         return (errno_t) rc;
     1642        return rc;
    16431643}
    16441644
  • uspace/lib/c/generic/clipboard.c

    r76c8209 r7fa8589  
    108108                clip_exchange_end(exch);
    109109
    110                 return (errno_t) rc;
     110                return rc;
    111111        } else {
    112112                async_exch_t *exch = clip_exchange_begin();
     
    120120                        async_wait_for(req, &rc_orig);
    121121                        if (rc_orig == EOK)
    122                                 return (errno_t) rc;
     122                                return rc;
    123123                        else
    124                                 return (errno_t) rc_orig;
     124                                return rc_orig;
    125125                }
    126126
    127127                async_wait_for(req, &rc);
    128128
    129                 return (errno_t) rc;
     129                return rc;
    130130        }
    131131}
     
    153153
    154154                if (rc != EOK)
    155                         return (errno_t) rc;
     155                        return rc;
    156156
    157157                char *sbuf;
     
    176176                        clip_exchange_end(exch);
    177177
    178                         if ((errno_t) rc == EOVERFLOW) {
     178                        if (rc == EOVERFLOW) {
    179179                                /*
    180180                                 * The data in the clipboard has changed since
     
    188188                                async_wait_for(req, &rc_orig);
    189189                                if (rc_orig == EOK)
    190                                         return (errno_t) rc;
     190                                        return rc;
    191191                                else
    192                                         return (errno_t) rc_orig;
     192                                        return rc_orig;
    193193                        }
    194194
  • uspace/lib/c/generic/device/clock_dev.c

    r76c8209 r7fa8589  
    6767
    6868        async_wait_for(req, &rc);
    69         return (errno_t)rc;
     69        return rc;
    7070}
    7171
     
    9898
    9999        async_wait_for(req, &rc);
    100         return (errno_t)rc;
     100        return rc;
    101101}
    102102
  • uspace/lib/c/generic/device/led_dev.c

    r76c8209 r7fa8589  
    5151        async_wait_for(req, &rc);
    5252
    53         return (errno_t) rc;
     53        return rc;
    5454}
    5555
  • uspace/lib/c/generic/inet/tcp.c

    r76c8209 r7fa8589  
    240240        return EOK;
    241241error:
    242         return (errno_t) rc;
     242        return rc;
    243243}
    244244
     
    360360error:
    361361        free(lst);
    362         return (errno_t) rc;
     362        return rc;
    363363}
    364364
  • uspace/lib/c/generic/inet/udp.c

    r76c8209 r7fa8589  
    200200error:
    201201        free(assoc);
    202         return (errno_t) rc;
     202        return rc;
    203203}
    204204
  • uspace/lib/c/generic/io/logctl.c

    r76c8209 r7fa8589  
    8585                return rc;
    8686
    87         rc = (errno_t) async_req_1_0(exchange,
     87        rc = async_req_1_0(exchange,
    8888            LOGGER_CONTROL_SET_DEFAULT_LEVEL, new_level);
    8989
     
    119119                return rc;
    120120
    121         return (errno_t) reg_msg_rc;
     121        return reg_msg_rc;
    122122}
    123123
     
    145145                return rc;
    146146
    147         return (errno_t) reg_msg_rc;
     147        return reg_msg_rc;
    148148}
    149149
  • uspace/lib/c/generic/loader.c

    r76c8209 r7fa8589  
    102102        if (rc != EOK) {
    103103                async_forget(req);
    104                 return (errno_t) rc;
     104                return rc;
    105105        }
    106106
    107107        async_wait_for(req, &rc);
    108         return (errno_t) rc;
     108        return rc;
    109109}
    110110
     
    140140        if (rc != EOK) {
    141141                async_forget(req);
    142                 return (errno_t) rc;
     142                return rc;
    143143        }
    144144
    145145        async_wait_for(req, &rc);
    146         return (errno_t) rc;
     146        return rc;
    147147}
    148148
     
    174174        if (rc != EOK) {
    175175                async_forget(req);
    176                 return (errno_t) rc;
     176                return rc;
    177177        }
    178178
    179179        async_wait_for(req, &rc);
    180         return (errno_t) rc;
     180        return rc;
    181181}
    182182
     
    259259        if (rc != EOK) {
    260260                async_forget(req);
    261                 return (errno_t) rc;
     261                return rc;
    262262        }
    263263
    264264        async_wait_for(req, &rc);
    265         return (errno_t) rc;
     265        return rc;
    266266}
    267267
     
    296296        }
    297297
    298         return (errno_t) rc;
     298        return rc;
    299299}
    300300
  • uspace/lib/c/generic/loc.c

    r76c8209 r7fa8589  
    314314errno_t loc_service_unregister(service_id_t sid)
    315315{
    316         async_exch_t *exch;
    317         errno_t retval;
    318 
    319         exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    320         retval = async_req_1_0(exch, LOC_SERVICE_UNREGISTER, sid);
    321         loc_exchange_end(exch);
    322 
    323         return (errno_t)retval;
     316        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
     317        errno_t rc = async_req_1_0(exch, LOC_SERVICE_UNREGISTER, sid);
     318        loc_exchange_end(exch);
     319        return rc;
    324320}
    325321
  • uspace/lib/c/generic/vfs/vfs.c

    r76c8209 r7fa8589  
    742742                loc_null_destroy(null_id);
    743743
    744         return (errno_t) rc;
     744        return rc;
    745745}
    746746
     
    11881188
    11891189        if (rc_orig != EOK)
    1190                 return (errno_t) rc_orig;
     1190                return rc_orig;
    11911191        return rc;
    11921192}
     
    12781278
    12791279        if (rc_orig != EOK)
    1280                 return (errno_t) rc_orig;
     1280                return rc_orig;
    12811281
    12821282        if (rc != EOK)
    1283                 return (errno_t) rc;
     1283                return rc;
    12841284
    12851285        *handle = (int) ipc_get_arg1(&answer);
  • uspace/lib/drv/generic/remote_ieee80211.c

    r76c8209 r7fa8589  
    7979
    8080        if (res != EOK)
    81                 return (errno_t) res;
     81                return res;
    8282
    8383        return rc;
     
    144144
    145145                if (rc_orig == EOK)
    146                         return (errno_t) rc;
    147 
    148                 return (errno_t) rc_orig;
     146                        return rc;
     147
     148                return rc_orig;
    149149        }
    150150
     
    159159
    160160                if (rc_orig == EOK)
    161                         return (errno_t) rc;
    162 
    163                 return (errno_t) rc_orig;
     161                        return rc;
     162
     163                return rc_orig;
    164164        }
    165165
     
    182182        rc = dhcp_discover(link_id);
    183183
    184         return (errno_t) rc;
     184        return rc;
    185185}
    186186
  • uspace/lib/drv/generic/remote_usbdiag.c

    r76c8209 r7fa8589  
    8989        async_wait_for(req, &retval);
    9090
    91         return (errno_t) retval;
     91        return retval;
    9292}
    9393
     
    123123        async_wait_for(req, &retval);
    124124
    125         return (errno_t) retval;
     125        return retval;
    126126}
    127127
  • uspace/lib/drv/generic/remote_usbhc.c

    r76c8209 r7fa8589  
    138138
    139139        if (opening_request_rc)
    140                 return (errno_t) opening_request_rc;
     140                return opening_request_rc;
    141141
    142142        usb_pipe_desc_t dest;
     
    174174        async_wait_for(opening_request, &opening_request_rc);
    175175
    176         return (errno_t) opening_request_rc;
     176        return opening_request_rc;
    177177}
    178178
     
    223223                *transferred = ipc_get_arg1(&call);
    224224
    225         return (errno_t) opening_request_rc;
     225        return opening_request_rc;
    226226}
    227227
  • uspace/lib/drv/generic/remote_usbhid.c

    r76c8209 r7fa8589  
    182182                /* Prefer return code of the opening request. */
    183183                if (opening_request_rc != EOK)
    184                         return (errno_t) opening_request_rc;
     184                        return opening_request_rc;
    185185                else
    186                         return (errno_t) data_request_rc;
     186                        return data_request_rc;
    187187        }
    188188
    189189        if (opening_request_rc != EOK)
    190                 return (errno_t) opening_request_rc;
     190                return opening_request_rc;
    191191
    192192        size_t act_size = ipc_get_arg2(&data_request_call);
     
    267267                /* Prefer return code of the opening request. */
    268268                if (opening_request_rc != EOK)
    269                         return (errno_t) opening_request_rc;
     269                        return opening_request_rc;
    270270                else
    271                         return (errno_t) data_request_rc;
     271                        return data_request_rc;
    272272        }
    273273
    274274        if (opening_request_rc != EOK)
    275                 return (errno_t) opening_request_rc;
     275                return opening_request_rc;
    276276
    277277        size_t act_size = ipc_get_arg2(&data_request_call);
  • uspace/lib/usbvirt/src/ipc_hc.c

    r76c8209 r7fa8589  
    104104                /* Prefer the return code of the opening request. */
    105105                if (opening_request_rc != EOK)
    106                         return (errno_t) opening_request_rc;
     106                        return opening_request_rc;
    107107                else
    108                         return (errno_t) data_request_rc;
     108                        return data_request_rc;
    109109        }
    110110
    111111        if (opening_request_rc != EOK)
    112                 return (errno_t) opening_request_rc;
     112                return opening_request_rc;
    113113
    114114        if (data_transferred_size != NULL)
     
    174174        async_wait_for(opening_request, &opening_request_rc);
    175175
    176         return (errno_t) opening_request_rc;
     176        return opening_request_rc;
    177177}
    178178
     
    241241                /* Prefer the return code of the opening request. */
    242242                if (opening_request_rc != EOK)
    243                         return (errno_t) opening_request_rc;
     243                        return opening_request_rc;
    244244                else
    245                         return (errno_t) data_request_rc;
     245                        return data_request_rc;
    246246        }
    247247
    248248        if (opening_request_rc != EOK)
    249                 return (errno_t) opening_request_rc;
     249                return opening_request_rc;
    250250
    251251        if (act_size != NULL)
     
    311311        async_wait_for(opening_request, &opening_request_rc);
    312312
    313         return (errno_t) opening_request_rc;
     313        return opening_request_rc;
    314314}
    315315
  • uspace/srv/fs/locfs/locfs_ops.c

    r76c8209 r7fa8589  
    596596
    597597                /* Do not propagate EHANGUP back to VFS. */
    598                 if ((errno_t) rc == EHANGUP)
     598                if (rc == EHANGUP)
    599599                        rc = ENOTSUP;
    600600
     
    660660
    661661                /* Do not propagate EHANGUP back to VFS. */
    662                 if ((errno_t) rc == EHANGUP)
     662                if (rc == EHANGUP)
    663663                        rc = ENOTSUP;
    664664
  • uspace/srv/vfs/vfs_ops.c

    r76c8209 r7fa8589  
    444444        chunk->size = ipc_get_arg1(answer);
    445445
    446         return (errno_t) rc;
     446        return rc;
    447447}
    448448
     
    740740        vfs_exchange_release(exch);
    741741
    742         return (errno_t) rc;
     742        return rc;
    743743}
    744744
Note: See TracChangeset for help on using the changeset viewer.