Changeset a35b458 in mainline for uspace/srv/hid/output/output.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/srv/hid/output/output.c

    r3061bc1 ra35b458  
    4444typedef struct {
    4545        link_t link;
    46        
     46
    4747        size_t size;
    4848        unsigned int flags;
    … …  
    5656{
    5757        assert(ops->get_dimensions);
    58        
     58
    5959        outdev_t *dev = (outdev_t *) malloc(sizeof(outdev_t));
    6060        if (dev == NULL)
    6161                return NULL;
    62        
     62
    6363        link_initialize(&dev->link);
    64        
     64
    6565        dev->ops = *ops;
    6666        dev->data = data;
    67        
     67
    6868        ops->get_dimensions(dev, &dev->cols, &dev->rows);
    6969        dev->backbuf = chargrid_create(dev->cols, dev->rows,
    … …  
    7373                return NULL;
    7474        }
    75        
     75
    7676        list_append(&dev->link, &outdevs);
    7777        return dev;
    … …  
    8181{
    8282        errno_t ret = EOK;
    83        
     83
    8484        list_foreach(outdevs, link, outdev_t, dev) {
    8585                assert(dev->ops.yield);
    86                
     86
    8787                errno_t rc = dev->ops.yield(dev);
    8888                if (rc != EOK)
    8989                        ret = rc;
    9090        }
    91        
     91
    9292        async_answer_0(iid, ret);
    9393}
    … …  
    9696{
    9797        errno_t ret = EOK;
    98        
     98
    9999        list_foreach(outdevs, link, outdev_t, dev) {
    100100                assert(dev->ops.claim);
    101                
     101
    102102                errno_t rc = dev->ops.claim(dev);
    103103                if (rc != EOK)
    104104                        ret = rc;
    105105        }
    106        
     106
    107107        async_answer_0(iid, ret);
    108108}
    … …  
    112112        sysarg_t cols = MAX_COLS;
    113113        sysarg_t rows = MAX_ROWS;
    114        
     114
    115115        list_foreach(outdevs, link, outdev_t, dev) {
    116116                cols = min(cols, dev->cols);
    117117                rows = min(rows, dev->rows);
    118118        }
    119        
     119
    120120        async_answer_2(iid, EOK, cols, rows);
    121121}
    … …  
    124124{
    125125        console_caps_t caps = 0;
    126        
     126
    127127        list_foreach(outdevs, link, outdev_t, dev) {
    128128                assert(dev->ops.get_caps);
    129                
     129
    130130                caps |= dev->ops.get_caps(dev);
    131131        }
    132        
     132
    133133        async_answer_1(iid, EOK, caps);
    134134}
    … …  
    143143                }
    144144        }
    145        
     145
    146146        if (frontbuf == NULL) {
    147147                async_answer_0(iid, ENOENT);
    148148                return NULL;
    149149        }
    150        
     150
    151151        return frontbuf;
    152152}
    … …  
    159159                return;
    160160        }
    161        
     161
    162162        link_initialize(&frontbuf->link);
    163        
     163
    164164        ipc_callid_t callid;
    165165        if (!async_share_out_receive(&callid, &frontbuf->size,
    … …  
    169169                return;
    170170        }
    171        
     171
    172172        errno_t rc = async_share_out_finalize(callid, &frontbuf->data);
    173173        if ((rc != EOK) || (frontbuf->data == AS_MAP_FAILED)) {
    … …  
    176176                return;
    177177        }
    178        
     178
    179179        list_append(&frontbuf->link, &frontbufs);
    180180        async_answer_1(iid, EOK, (sysarg_t) frontbuf);
    … …  
    186186        if (frontbuf == NULL)
    187187                return;
    188        
     188
    189189        list_remove(&frontbuf->link);
    190190        as_area_destroy(frontbuf->data);
    191191        free(frontbuf);
    192        
     192
    193193        async_answer_0(iid, EOK);
    194194}
    … …  
    199199        if (frontbuf == NULL)
    200200                return;
    201        
     201
    202202        chargrid_t *buf = (chargrid_t *) frontbuf->data;
    203203        bool visible = chargrid_get_cursor_visibility(buf);
    204        
     204
    205205        sysarg_t col;
    206206        sysarg_t row;
    207207        chargrid_get_cursor(buf, &col, &row);
    208        
     208
    209209        list_foreach(outdevs, link, outdev_t, dev) {
    210210                assert(dev->ops.cursor_update);
    211                
     211
    212212                sysarg_t prev_col;
    213213                sysarg_t prev_row;
    214214                chargrid_get_cursor(dev->backbuf, &prev_col, &prev_row);
    215                
     215
    216216                chargrid_set_cursor(dev->backbuf, col, row);
    217217                chargrid_set_cursor_visibility(dev->backbuf, visible);
    218                
     218
    219219                dev->ops.cursor_update(dev, prev_col, prev_row, col, row,
    220220                    visible);
    … …  
    222222
    223223        }
    224        
     224
    225225        async_answer_0(iid, EOK);
    226226}
    … …  
    233233                    (console_style_t) IPC_GET_ARG1(*icall);
    234234        }
    235        
     235
    236236        async_answer_0(iid, EOK);
    237237}
    … …  
    248248                    (console_color_attr_t) IPC_GET_ARG3(*icall);
    249249        }
    250        
     250
    251251        async_answer_0(iid, EOK);
    252252}
    … …  
    259259                dev->attrs.val.rgb.fgcolor = IPC_GET_ARG2(*icall);
    260260        }
    261        
     261
    262262        async_answer_0(iid, EOK);
    263263}
    … …  
    266266{
    267267        assert(dev->ops.char_update);
    268        
     268
    269269        sysarg_t top_row = chargrid_get_top_row(buf);
    270        
     270
    271271        if (dev->top_row == top_row)
    272272                return false;
    273        
     273
    274274        dev->top_row = top_row;
    275        
     275
    276276        for (sysarg_t y = 0; y < dev->rows; y++) {
    277277                for (sysarg_t x = 0; x < dev->cols; x++) {
    … …  
    281281                            chargrid_charfield_at(dev->backbuf, x, y);
    282282                        bool update = false;
    283                        
     283
    284284                        if (front_field->ch != back_field->ch) {
    285285                                back_field->ch = front_field->ch;
    286286                                update = true;
    287287                        }
    288                        
     288
    289289                        if (!attrs_same(front_field->attrs, back_field->attrs)) {
    290290                                back_field->attrs = front_field->attrs;
    291291                                update = true;
    292292                        }
    293                        
     293
    294294                        front_field->flags &= ~CHAR_FLAG_DIRTY;
    295                        
     295
    296296                        if (update)
    297297                                dev->ops.char_update(dev, x, y);
    298298                }
    299299        }
    300        
     300
    301301        return true;
    302302}
    … …  
    307307        if (frontbuf == NULL)
    308308                return;
    309        
     309
    310310        chargrid_t *buf = (chargrid_t *) frontbuf->data;
    311        
     311
    312312        list_foreach(outdevs, link, outdev_t, dev) {
    313313                assert(dev->ops.char_update);
    314                
     314
    315315                if (srv_update_scroll(dev, buf))
    316316                        continue;
    317                
     317
    318318                for (sysarg_t y = 0; y < dev->rows; y++) {
    319319                        for (sysarg_t x = 0; x < dev->cols; x++) {
    … …  
    323323                                    chargrid_charfield_at(dev->backbuf, x, y);
    324324                                bool update = false;
    325                                
     325
    326326                                if ((front_field->flags & CHAR_FLAG_DIRTY) ==
    327327                                    CHAR_FLAG_DIRTY) {
    … …  
    330330                                                update = true;
    331331                                        }
    332                                        
     332
    333333                                        if (!attrs_same(front_field->attrs,
    334334                                            back_field->attrs)) {
    … …  
    336336                                                update = true;
    337337                                        }
    338                                        
     338
    339339                                        front_field->flags &= ~CHAR_FLAG_DIRTY;
    340340                                }
    341                                
     341
    342342                                if (update)
    343343                                        dev->ops.char_update(dev, x, y);
    344344                        }
    345345                }
    346                
     346
    347347                dev->ops.flush(dev);
    348348        }
    349        
    350        
     349
     350
    351351        async_answer_0(iid, EOK);
    352352}
    … …  
    357357        if (frontbuf == NULL)
    358358                return;
    359        
     359
    360360        chargrid_t *buf = (chargrid_t *) frontbuf->data;
    361        
     361
    362362        list_foreach(outdevs, link, outdev_t, dev) {
    363363                assert(dev->ops.char_update);
    364                
     364
    365365                if (srv_update_scroll(dev, buf))
    366366                        continue;
    367                
     367
    368368                sysarg_t col = IPC_GET_ARG2(*icall);
    369369                sysarg_t row = IPC_GET_ARG3(*icall);
    370                
     370
    371371                sysarg_t cols = IPC_GET_ARG4(*icall);
    372372                sysarg_t rows = IPC_GET_ARG5(*icall);
    373                
     373
    374374                for (sysarg_t y = 0; y < rows; y++) {
    375375                        for (sysarg_t x = 0; x < cols; x++) {
    … …  
    378378                                charfield_t *back_field =
    379379                                    chargrid_charfield_at(dev->backbuf, col + x, row + y);
    380                                
     380
    381381                                back_field->ch = front_field->ch;
    382382                                back_field->attrs = front_field->attrs;
    … …  
    395395        /* Accept the connection */
    396396        async_answer_0(iid, EOK);
    397        
     397
    398398        while (true) {
    399399                ipc_call_t call;
    400400                ipc_callid_t callid = async_get_call(&call);
    401                
     401
    402402                if (!IPC_GET_IMETHOD(call)) {
    403403                        async_answer_0(callid, EOK);
    404404                        break;
    405405                }
    406                
     406
    407407                switch (IPC_GET_IMETHOD(call)) {
    408408                case OUTPUT_YIELD:
    … …  
    418418                        srv_get_caps(callid, &call);
    419419                        break;
    420                
     420
    421421                case OUTPUT_FRONTBUF_CREATE:
    422422                        srv_frontbuf_create(callid, &call);
    … …  
    425425                        srv_frontbuf_destroy(callid, &call);
    426426                        break;
    427                        
     427
    428428                case OUTPUT_CURSOR_UPDATE:
    429429                        srv_cursor_update(callid, &call);
    … …  
    444444                        srv_damage(callid, &call);
    445445                        break;
    446                        
     446
    447447                default:
    448448                        async_answer_0(callid, EINVAL);
    … …  
    462462                return 1;
    463463        }
    464        
     464
    465465        printf("%s: HelenOS output service\n", NAME);
    466        
     466
    467467        /* Register server */
    468468        async_set_fallback_port_handler(client_connection, NULL);
    … …  
    472472                return rc;
    473473        }
    474        
     474
    475475        service_id_t service_id;
    476476        rc = loc_service_register(argv[1], &service_id);
    … …  
    479479                return rc;
    480480        }
    481        
     481
    482482        if (!config_key_exists("console")) {
    483483                ega_init();
    484484        }
    485        
     485
    486486        chardev_init();
    487        
     487
    488488        printf("%s: Accepting connections\n", NAME);
    489489        task_retval(0);
    490490        async_manager();
    491        
     491
    492492        /* Never reached */
    493493        return 0;
Note: See TracChangeset for help on using the changeset viewer.