Changeset 18b6a88 in mainline for uspace/srv


Ignore:
Timestamp:
2018-04-15T09:35:04Z (8 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
c1f44ca
Parents:
8ebe212
Message:

More ccheck fixes, sometimes with manual intervention.

Location:
uspace/srv
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/exfat/exfat_directory.c

    r8ebe212 r18b6a88  
    455455                if (i == df.file.count - 2) {
    456456                        chars = ds.stream.name_size -
    457                             EXFAT_NAME_PART_LEN*(df.file.count - 2);
     457                            EXFAT_NAME_PART_LEN * (df.file.count - 2);
    458458                }
    459459
  • uspace/srv/fs/exfat/exfat_fat.c

    r8ebe212 r18b6a88  
    142142                         */
    143143                        return block_get(block, nodep->idx->service_id, DATA_FS(bs) +
    144                         (nodep->lastc_cached_value-EXFAT_CLST_FIRST)*SPC(bs) +
     144                            (nodep->lastc_cached_value - EXFAT_CLST_FIRST) * SPC(bs) +
    145145                            (bn % SPC(bs)), flags);
    146146                }
     
    201201        if (!fragmented) {
    202202                rc = block_get(block, service_id, DATA_FS(bs) +
    203                     (fcl - EXFAT_CLST_FIRST)*SPC(bs) + bn, flags);
     203                    (fcl - EXFAT_CLST_FIRST) * SPC(bs) + bn, flags);
    204204        } else {
    205205                max_clusters = bn / SPC(bs);
     
    514514        block_t *b;
    515515        errno_t rc;
    516         blocks = ROUND_UP(nodep->size, BPS(bs))/BPS(bs);
     516        blocks = ROUND_UP(nodep->size, BPS(bs)) / BPS(bs);
    517517        count = BPS(bs);
    518518
  • uspace/srv/fs/exfat/exfat_idx.c

    r8ebe212 r18b6a88  
    119119static inline size_t pos_key_hash(void *key)
    120120{
    121         pos_key_t *pos = (pos_key_t*)key;
     121        pos_key_t *pos = (pos_key_t *)key;
    122122
    123123        size_t hash = 0;
     
    141141static bool pos_key_equal(void *key, const ht_link_t *item)
    142142{
    143         pos_key_t *pos = (pos_key_t*)key;
     143        pos_key_t *pos = (pos_key_t *)key;
    144144        exfat_idx_t *fidx = hash_table_get_inst(item, exfat_idx_t, uph_link);
    145145
    146         return pos->service_id == fidx->service_id
    147                 && pos->pdi == fidx->pdi
    148                 && pos->pfc == fidx->pfc;
     146        return pos->service_id == fidx->service_id &&
     147            pos->pdi == fidx->pdi &&
     148            pos->pfc == fidx->pfc;
    149149}
    150150
     
    170170static size_t idx_key_hash(void *key_arg)
    171171{
    172         idx_key_t *key = (idx_key_t*)key_arg;
     172        idx_key_t *key = (idx_key_t *)key_arg;
    173173        return hash_combine(key->service_id, key->index);
    174174}
     
    183183{
    184184        exfat_idx_t *fidx = hash_table_get_inst(item, exfat_idx_t, uih_link);
    185         idx_key_t *key = (idx_key_t*)key_arg;
     185        idx_key_t *key = (idx_key_t *)key_arg;
    186186
    187187        return key->index == fidx->index && key->service_id == fidx->service_id;
     
    509509static bool rm_pos_service_id(ht_link_t *item, void *arg)
    510510{
    511         service_id_t service_id = *(service_id_t*)arg;
     511        service_id_t service_id = *(service_id_t *)arg;
    512512        exfat_idx_t *fidx = hash_table_get_inst(item, exfat_idx_t, uph_link);
    513513
     
    521521static bool rm_idx_service_id(ht_link_t *item, void *arg)
    522522{
    523         service_id_t service_id = *(service_id_t*)arg;
     523        service_id_t service_id = *(service_id_t *)arg;
    524524        exfat_idx_t *fidx = hash_table_get_inst(item, exfat_idx_t, uih_link);
    525525
  • uspace/srv/fs/exfat/exfat_ops.c

    r8ebe212 r18b6a88  
    248248                fn = FS_NODE(nodep);
    249249        } else {
    250 skip_cache:
     250        skip_cache:
    251251                /* Try to allocate a new node structure. */
    252252                fibril_mutex_unlock(&ffn_mutex);
     
    533533                            (BPS(di.bs) / sizeof(exfat_dentry_t));
    534534                        exfat_idx_t *idx = exfat_idx_get_by_pos(service_id,
    535                                 parentp->firstc, di.bnum * DPS(di.bs) + o);
     535                            parentp->firstc, di.bnum * DPS(di.bs) + o);
    536536                        if (!idx) {
    537537                                /*
     
    706706                if (nodep->fragmented)
    707707                        rc = exfat_free_clusters(bs, nodep->idx->service_id,
    708                                 nodep->firstc);
     708                            nodep->firstc);
    709709                else
    710710                        rc = exfat_bitmap_free_clusters(bs, nodep,
     
    805805
    806806        exfat_directory_t di;
    807         rc = exfat_directory_open(parentp,&di);
     807        rc = exfat_directory_open(parentp, &di);
    808808        if (rc != EOK)
    809809                goto error;
     
    10621062        rc = exfat_node_get_new_by_pos(&rootp, service_id, EXFAT_ROOT_PAR,
    10631063            EXFAT_ROOT_POS);
    1064         if (rc!=EOK) {
     1064        if (rc != EOK) {
    10651065                (void) block_cache_fini(service_id);
    10661066                block_fini(service_id);
     
    11831183                        block_fini(service_id);
    11841184                        exfat_idx_fini_by_service_id(service_id);
    1185                     return ENOTSUP;
     1185                        return ENOTSUP;
    11861186                }
    11871187        }
     
    14091409                (void) exfat_directory_close(&di);
    14101410
    1411 err:
     1411        err:
    14121412                (void) exfat_node_put(fn);
    14131413                async_answer_0(chandle, rc);
    14141414                return rc;
    14151415
    1416 miss:
     1416        miss:
    14171417                rc = exfat_directory_close(&di);
    14181418                if (rc != EOK)
     
    14231423                return rc != EOK ? rc : ENOENT;
    14241424
    1425 hit:
     1425        hit:
    14261426                pos = di.pos;
    14271427                rc = exfat_directory_close(&di);
  • uspace/srv/fs/fat/fat_fat.c

    r8ebe212 r18b6a88  
    249249        for (o = nodep->size; o < pos && o < boundary;
    250250            o = ALIGN_DOWN(o + BPS(bs), BPS(bs))) {
    251                 int flags = (o % BPS(bs) == 0) ?
     251                int flags = (o % BPS(bs) == 0) ?
    252252                    BLOCK_FLAGS_NOREAD : BLOCK_FLAGS_NONE;
    253253                rc = fat_block_get(&b, bs, nodep, o / BPS(bs), flags);
     
    324324                        * first byte of next sector
    325325                        */
    326                         byte2 = ((uint8_t*) b1->data)[0];
     326                        byte2 = ((uint8_t *) b1->data)[0];
    327327
    328328                        rc = block_put(b1);
     
    469469                return rc;
    470470
    471         byte1 = ((uint8_t*) b->data)[offset % BPS(bs)];
     471        byte1 = ((uint8_t *) b->data)[offset % BPS(bs)];
    472472        bool border = false;
    473473        /* This cluster access spans a sector boundary. */
     
    495495                }
    496496        } else
    497                 byte2 = ((uint8_t*) b->data)[(offset % BPS(bs)) + 1];
     497                byte2 = ((uint8_t *) b->data)[(offset % BPS(bs)) + 1];
    498498
    499499        if (IS_ODD(clst)) {
  • uspace/srv/fs/fat/fat_idx.c

    r8ebe212 r18b6a88  
    119119static inline size_t pos_key_hash(void *key)
    120120{
    121         pos_key_t *pos = (pos_key_t*)key;
     121        pos_key_t *pos = (pos_key_t *)key;
    122122
    123123        size_t hash = 0;
     
    141141static bool pos_key_equal(void *key, const ht_link_t *item)
    142142{
    143         pos_key_t *pos = (pos_key_t*)key;
     143        pos_key_t *pos = (pos_key_t *)key;
    144144        fat_idx_t *fidx = hash_table_get_inst(item, fat_idx_t, uph_link);
    145145
    146         return pos->service_id == fidx->service_id
    147                 && pos->pdi == fidx->pdi
    148                 && pos->pfc == fidx->pfc;
     146        return pos->service_id == fidx->service_id &&
     147            pos->pdi == fidx->pdi &&
     148            pos->pfc == fidx->pfc;
    149149}
    150150
     
    170170static size_t idx_key_hash(void *key_arg)
    171171{
    172         idx_key_t *key = (idx_key_t*)key_arg;
     172        idx_key_t *key = (idx_key_t *)key_arg;
    173173        return hash_combine(key->service_id, key->index);
    174174}
     
    183183{
    184184        fat_idx_t *fidx = hash_table_get_inst(item, fat_idx_t, uih_link);
    185         idx_key_t *key = (idx_key_t*)key_arg;
     185        idx_key_t *key = (idx_key_t *)key_arg;
    186186
    187187        return key->index == fidx->index && key->service_id == fidx->service_id;
     
    508508static bool rm_pos_service_id(ht_link_t *item, void *arg)
    509509{
    510         service_id_t service_id = *(service_id_t*)arg;
     510        service_id_t service_id = *(service_id_t *)arg;
    511511        fat_idx_t *fidx = hash_table_get_inst(item, fat_idx_t, uph_link);
    512512
     
    520520static bool rm_idx_service_id(ht_link_t *item, void *arg)
    521521{
    522         service_id_t service_id = *(service_id_t*)arg;
     522        service_id_t service_id = *(service_id_t *)arg;
    523523        fat_idx_t *fidx = hash_table_get_inst(item, fat_idx_t, uih_link);
    524524
  • uspace/srv/fs/fat/fat_ops.c

    r8ebe212 r18b6a88  
    241241                fn = FS_NODE(nodep);
    242242        } else {
    243 skip_cache:
     243        skip_cache:
    244244                /* Try to allocate a new node structure. */
    245245                fibril_mutex_unlock(&ffn_mutex);
     
    12891289                        goto miss;
    12901290
    1291 err:
     1291        err:
    12921292                (void) fat_node_put(fn);
    12931293                async_answer_0(chandle, rc);
    12941294                return rc;
    12951295
    1296 miss:
     1296        miss:
    12971297                rc = fat_directory_close(&di);
    12981298                if (rc != EOK)
     
    13031303                return rc != EOK ? rc : ENOENT;
    13041304
    1305 hit:
     1305        hit:
    13061306                pos = di.pos;
    13071307                rc = fat_directory_close(&di);
  • uspace/srv/fs/locfs/locfs_ops.c

    r8ebe212 r18b6a88  
    7373static size_t services_key_hash(void *key)
    7474{
    75         return *(service_id_t*)key;
     75        return *(service_id_t *)key;
    7676}
    7777
     
    8585{
    8686        service_t *dev = hash_table_get_inst(item, service_t, link);
    87         return (dev->service_id == *(service_id_t*)key);
     87        return (dev->service_id == *(service_id_t *)key);
    8888}
    8989
     
    234234                fibril_mutex_lock(&services_mutex);
    235235                ht_link_t *lnk;
    236 restart:
     236        restart:
    237237                lnk = hash_table_find(&services, &node->service_id);
    238238                if (lnk == NULL) {
  • uspace/srv/fs/mfs/mfs_dentry.c

    r8ebe212 r18b6a88  
    171171        /* Search the directory entry to be removed */
    172172        unsigned i;
    173         for (i = 0; i < mnode->ino_i->i_size / sbi->dirsize ; ++i) {
     173        for (i = 0; i < mnode->ino_i->i_size / sbi->dirsize; ++i) {
    174174                r = mfs_read_dentry(mnode, &d_info, i);
    175175                if (r != EOK)
  • uspace/srv/fs/mfs/mfs_ops.c

    r8ebe212 r18b6a88  
    103103open_nodes_key_hash(void *key)
    104104{
    105         node_key_t *node_key = (node_key_t*)key;
     105        node_key_t *node_key = (node_key_t *)key;
    106106        return hash_combine(node_key->service_id, node_key->index);
    107107}
     
    117117open_nodes_key_equal(void *key, const ht_link_t *item)
    118118{
    119         node_key_t *node_key = (node_key_t*)key;
     119        node_key_t *node_key = (node_key_t *)key;
    120120        struct mfs_node *mnode = hash_table_get_inst(item, struct mfs_node, link);
    121121
    122         return node_key->service_id == mnode->instance->service_id
    123                 && node_key->index == mnode->ino_i->index;
     122        return node_key->service_id == mnode->instance->service_id &&
     123            node_key->index == mnode->ino_i->index;
    124124}
    125125
     
    361361        if (sbi)
    362362                free(sbi);
    363         if(instance)
     363        if (instance)
    364364                free(instance);
    365365        return rc;
     
    871871                async_answer_0(chandle, rc != EOK ? rc : ENOENT);
    872872                return rc;
    873 found:
     873        found:
    874874                async_data_read_finalize(chandle, d_info.d_name,
    875875                    str_size(d_info.d_name) + 1);
     
    11021102static bool
    11031103check_magic_number(uint16_t magic, bool *native,
    1104                 mfs_version_t *version, bool *longfilenames)
     1104    mfs_version_t *version, bool *longfilenames)
    11051105{
    11061106        bool rc = true;
  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    r8ebe212 r18b6a88  
    238238static bool rm_service_id_nodes(ht_link_t *item, void *arg)
    239239{
    240         service_id_t sid = *(service_id_t*)arg;
     240        service_id_t sid = *(service_id_t *)arg;
    241241        tmpfs_node_t *node = hash_table_get_inst(item, tmpfs_node_t, nh_link);
    242242
  • uspace/srv/hid/compositor/compositor.c

    r8ebe212 r18b6a88  
    488488                                                if (y_bnd_ghost == y_dmg_ghost) {
    489489                                                        for (sysarg_t x = x_dmg_ghost - vp->pos.x;
    490                                                                     x < x_dmg_ghost - vp->pos.x + w_dmg_ghost; ++x) {
     490                                                            x < x_dmg_ghost - vp->pos.x + w_dmg_ghost; ++x) {
    491491                                                                ghost_color = surface_get_pixel(vp->surface,
    492492                                                                    x, y_dmg_ghost - vp->pos.y);
     
    498498                                                if (y_bnd_ghost + h_bnd_ghost == y_dmg_ghost + h_dmg_ghost) {
    499499                                                        for (sysarg_t x = x_dmg_ghost - vp->pos.x;
    500                                                                     x < x_dmg_ghost - vp->pos.x + w_dmg_ghost; ++x) {
     500                                                            x < x_dmg_ghost - vp->pos.x + w_dmg_ghost; ++x) {
    501501                                                                ghost_color = surface_get_pixel(vp->surface,
    502502                                                                    x, y_dmg_ghost - vp->pos.y + h_dmg_ghost - 1);
     
    508508                                                if (x_bnd_ghost == x_dmg_ghost) {
    509509                                                        for (sysarg_t y = y_dmg_ghost - vp->pos.y;
    510                                                                     y < y_dmg_ghost - vp->pos.y + h_dmg_ghost; ++y) {
     510                                                            y < y_dmg_ghost - vp->pos.y + h_dmg_ghost; ++y) {
    511511                                                                ghost_color = surface_get_pixel(vp->surface,
    512512                                                                    x_dmg_ghost - vp->pos.x, y);
     
    518518                                                if (x_bnd_ghost + w_bnd_ghost == x_dmg_ghost + w_dmg_ghost) {
    519519                                                        for (sysarg_t y = y_dmg_ghost - vp->pos.y;
    520                                                                     y < y_dmg_ghost - vp->pos.y + h_dmg_ghost; ++y) {
     520                                                            y < y_dmg_ghost - vp->pos.y + h_dmg_ghost; ++y) {
    521521                                                                ghost_color = surface_get_pixel(vp->surface,
    522522                                                                    x_dmg_ghost - vp->pos.x + w_dmg_ghost - 1, y);
     
    562562                                                while (count-- != 0) {
    563563                                                        *dst = (*src & 0xff000000) ? *src : *dst;
    564                                                         ++dst; ++src;
     564                                                        ++dst;
     565                                                        ++src;
    565566                                                }
    566567                                        }
     
    13471348                        if (fy > 0) {
    13481349#if ANIMATE_WINDOW_TRANSFORMS == 0
    1349                                 if (scale) win->fy *= fy;
     1350                                if (scale)
     1351                                        win->fy *= fy;
    13501352#endif
    13511353#if ANIMATE_WINDOW_TRANSFORMS == 1
     
    14491451
    14501452        if (w_i == 0 || h_i == 0) {
    1451                 rect1->x = x_u; rect2->x = 0; rect3->x = 0; rect4->x = 0;
    1452                 rect1->y = y_u; rect2->y = 0; rect3->y = 0; rect4->y = 0;
    1453                 rect1->w = w_u; rect2->w = 0; rect3->w = 0; rect4->w = 0;
    1454                 rect1->h = h_u; rect2->h = 0; rect3->h = 0; rect4->h = 0;
     1453                rect1->x = x_u;
     1454                rect2->x = 0;
     1455                rect3->x = 0;
     1456                rect4->x = 0;
     1457
     1458                rect1->y = y_u;
     1459                rect2->y = 0;
     1460                rect3->y = 0;
     1461                rect4->y = 0;
     1462
     1463                rect1->w = w_u;
     1464                rect2->w = 0;
     1465                rect3->w = 0;
     1466                rect4->w = 0;
     1467
     1468                rect1->h = h_u;
     1469                rect2->h = 0;
     1470                rect3->h = 0;
     1471                rect4->h = 0;
    14551472        } else {
    14561473                rect1->x = x_u;
     
    14771494#endif
    14781495
    1479 static errno_t comp_abs_move(input_t *input, unsigned x , unsigned y,
     1496static errno_t comp_abs_move(input_t *input, unsigned x, unsigned y,
    14801497    unsigned max_x, unsigned max_y)
    14811498{
     
    15261543        sysarg_t cursor_height;
    15271544        surface_get_resolution(pointer->cursor.states[pointer->state],
    1528              &cursor_width, &cursor_height);
     1545            &cursor_width, &cursor_height);
    15291546
    15301547        if (pointer->pos.x + dx < viewport_bound_rect.x)
     
    17881805
    17891806#if ANIMATE_WINDOW_TRANSFORMS == 0
    1790                 comp_damage(dmg_rect1.x, dmg_rect1.y, dmg_rect1.w, dmg_rect1.h);
    1791                 comp_damage(dmg_rect2.x, dmg_rect2.y, dmg_rect2.w, dmg_rect2.h);
    1792                 comp_damage(dmg_rect3.x, dmg_rect3.y, dmg_rect3.w, dmg_rect3.h);
    1793                 comp_damage(dmg_rect4.x, dmg_rect4.y, dmg_rect4.w, dmg_rect4.h);
     1807        comp_damage(dmg_rect1.x, dmg_rect1.y, dmg_rect1.w, dmg_rect1.h);
     1808        comp_damage(dmg_rect2.x, dmg_rect2.y, dmg_rect2.w, dmg_rect2.h);
     1809        comp_damage(dmg_rect3.x, dmg_rect3.y, dmg_rect3.w, dmg_rect3.h);
     1810        comp_damage(dmg_rect4.x, dmg_rect4.y, dmg_rect4.w, dmg_rect4.h);
    17941811#endif
    17951812
     
    18261843    keymod_t mods, wchar_t c)
    18271844{
    1828         bool win_transform = (mods & KM_ALT) && (
    1829             key == KC_W || key == KC_S || key == KC_A || key == KC_D ||
     1845        bool win_transform = (mods & KM_ALT) &&
     1846            (key == KC_W || key == KC_S || key == KC_A || key == KC_D ||
    18301847            key == KC_Q || key == KC_E || key == KC_R || key == KC_F);
    1831         bool win_resize = (mods & KM_ALT) && (
    1832             key == KC_T || key == KC_G || key == KC_B || key == KC_N);
    1833         bool win_opacity = (mods & KM_ALT) && (
    1834             key == KC_C || key == KC_V);
     1848        bool win_resize = (mods & KM_ALT) &&
     1849            (key == KC_T || key == KC_G || key == KC_B || key == KC_N);
     1850        bool win_opacity = (mods & KM_ALT) && (key == KC_C || key == KC_V);
    18351851        bool win_close = (mods & KM_ALT) && (key == KC_X);
    18361852        bool win_switch = (mods & KM_ALT) && (key == KC_TAB);
    1837         bool viewport_move = (mods & KM_ALT) && (
    1838             key == KC_I || key == KC_K || key == KC_J || key == KC_L);
    1839         bool viewport_change = (mods & KM_ALT) && (
    1840             key == KC_O || key == KC_P);
     1853        bool viewport_move = (mods & KM_ALT) &&
     1854            (key == KC_I || key == KC_K || key == KC_J || key == KC_L);
     1855        bool viewport_change = (mods & KM_ALT) && (key == KC_O || key == KC_P);
    18411856        bool kconsole_switch = (key == KC_PAUSE) || (key == KC_BREAK);
    18421857        bool filter_switch = (mods & KM_ALT) && (key == KC_Y);
     
    21202135                if (filter_index == 0) {
    21212136                        filter = filter_nearest;
    2122                 }
    2123                 else {
     2137                } else {
    21242138                        filter = filter_bilinear;
    21252139                }
  • uspace/srv/hid/rfb/rfb.c

    r8ebe212 r18b6a88  
    8383
    8484/** Receive count characters (with buffering) */
    85 __attribute__((warn_unused_result))
    86 static errno_t recv_chars(tcp_conn_t *conn, char *c, size_t count)
     85static errno_t __attribute__((warn_unused_result))
     86recv_chars(tcp_conn_t *conn, char *c, size_t count)
    8787{
    8888        for (size_t i = 0; i < count; i++) {
     
    217217}
    218218
    219 __attribute__((warn_unused_result))
    220 static errno_t recv_message(tcp_conn_t *conn, char type, void *buf, size_t size)
     219static errno_t __attribute__((warn_unused_result))
     220recv_message(tcp_conn_t *conn, char type, void *buf, size_t size)
    221221{
    222222        memcpy(buf, &type, 1);
    223         return recv_chars(conn, ((char *) buf) + 1, size -1);
     223        return recv_chars(conn, ((char *) buf) + 1, size - 1);
    224224}
    225225
     
    236236                if (free && first_free_index == -1) {
    237237                        first_free_index = i;
    238                 }
    239                 else if (!free && RED(rfb->palette[i]) == RED(pixel) &&
     238                } else if (!free && RED(rfb->palette[i]) == RED(pixel) &&
    240239                    GREEN(rfb->palette[i]) == GREEN(pixel) &&
    241240                    BLUE(rfb->palette[i]) == BLUE(pixel)) {
     
    268267                uint8_t pix8 = pix;
    269268                memcpy(buf, &pix8, 1);
    270         }
    271         else if (pf->bpp == 16) {
     269        } else if (pf->bpp == 16) {
    272270                uint16_t pix16 = pix;
    273271                if (pf->big_endian) {
    274272                        pix16 = host2uint16_t_be(pix16);
    275                 }
    276                 else {
     273                } else {
    277274                        pix16 = host2uint16_t_le(pix16);
    278275                }
    279276                memcpy(buf, &pix16, 2);
    280         }
    281         else if (pf->bpp == 32) {
     277        } else if (pf->bpp == 32) {
    282278                if (pf->big_endian) {
    283279                        pix = host2uint32_t_be(pix);
    284                 }
    285                 else {
     280                } else {
    286281                        pix = host2uint32_t_le(pix);
    287282                }
     
    294289        if (rfb->pixel_format.true_color) {
    295290                rfb_encode_true_color(&rfb->pixel_format, buf, pixel);
    296         }
    297         else {
     291        } else {
    298292                rfb_encode_index(rfb, buf, pixel);
    299293        }
     
    366360
    367361typedef enum {
    368         COMP_NONE, COMP_SKIP_START, COMP_SKIP_END
     362        COMP_NONE,
     363        COMP_SKIP_START,
     364        COMP_SKIP_END
    369365} cpixel_compress_type_t;
    370366
     
    387383                if (pixel_format->big_endian) {
    388384                        mask = host2uint32_t_be(mask);
    389                 }
    390                 else {
     385                } else {
    391386                        mask = host2uint32_t_le(mask);
    392387                }
     
    396391                        ctx->compress_type = COMP_SKIP_START;
    397392                        ctx->size = 3;
    398                 }
    399                 else if (mask_data[3] == 0) {
     393                } else if (mask_data[3] == 0) {
    400394                        ctx->compress_type = COMP_SKIP_END;
    401395                        ctx->size = 3;
     
    509503        size_t buf_size = sizeof(rfb_framebuffer_update_t) +
    510504            sizeof(rfb_rectangle_t) * 1 +
    511             rfb_rect_encode_raw(rfb, &rfb->damage_rect, NULL)
    512             ;
     505            rfb_rect_encode_raw(rfb, &rfb->damage_rect, NULL);
    513506
    514507        void *buf = malloc(buf_size);
     
    534527                rect->enctype = RFB_ENCODING_TRLE;
    535528                pos += rfb_rect_encode_trle(rfb, rect, pos);
    536         }
    537         else {
     529        } else {
    538530                rect->enctype = RFB_ENCODING_RAW;
    539531                pos += rfb_rect_encode_raw(rfb, rect, pos);
     
    583575                    pixel_format->g_max, pixel_format->g_shift, pixel_format->b_max,
    584576                    pixel_format->b_shift);
    585         }
    586         else {
     577        } else {
    587578                if (rfb->palette == NULL) {
    588579                        rfb->palette = malloc(sizeof(pixel_t) * 256);
     
    675666        server_init->width = rfb->width;
    676667        server_init->height = rfb->height;
    677         server_init->pixel_format = rfb->pixel_format,
     668        server_init->pixel_format = rfb->pixel_format;
    678669        server_init->name_length = name_length;
    679670        rfb_server_init_to_be(server_init, server_init);
  • uspace/srv/net/udp/service.c

    r8ebe212 r18b6a88  
    359359 * @param icall         Async request data
    360360 */
    361 static
    362 void udp_assoc_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     361static void
     362udp_assoc_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    363363    ipc_call_t *icall)
    364364{
Note: See TracChangeset for help on using the changeset viewer.