Changeset a35b458 in mainline for uspace/app/vcalc/vcalc.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/app/vcalc/vcalc.c

    r3061bc1 ra35b458  
    8585typedef struct {
    8686        link_t link;
    87        
     87
    8888        stack_item_type_t type;
    8989        union {
    … …  
    104104{
    105105        assert(is_digit(c));
    106        
     106
    107107        return (c - '0');
    108108}
    … …  
    149149        if (!item)
    150150                return false;
    151        
     151
    152152        link_initialize(&item->link);
    153153        item->type = ITEM_VALUE;
    154        
     154
    155155        if (value_neg)
    156156                item->data.value = -value;
    157157        else
    158158                item->data.value = value;
    159        
     159
    160160        list_prepend(&item->link, stack);
    161        
     161
    162162        return true;
    163163}
    … …  
    168168        if (!item)
    169169                return false;
    170        
     170
    171171        link_initialize(&item->link);
    172172        item->type = ITEM_OPERATOR;
    173173        item->data.operator = operator;
    174174        list_prepend(&item->link, stack);
    175        
     175
    176176        return true;
    177177}
    … …  
    182182        if (!link)
    183183                return false;
    184        
     184
    185185        stack_item_t *item = list_get_instance(link, stack_item_t, link);
    186186        if (item->type != ITEM_VALUE)
    187187                return false;
    188        
     188
    189189        *value = item->data.value;
    190        
     190
    191191        list_remove(link);
    192192        free(item);
    193        
     193
    194194        return true;
    195195}
    … …  
    200200        if (!link)
    201201                return false;
    202        
     202
    203203        stack_item_t *item = list_get_instance(link, stack_item_t, link);
    204204        if (item->type != ITEM_OPERATOR)
    205205                return false;
    206        
     206
    207207        *operator = item->data.operator;
    208        
     208
    209209        list_remove(link);
    210210        free(item);
    211        
     211
    212212        return true;
    213213}
    … …  
    220220                        stack_item_t *item = list_get_instance(link, stack_item_t,
    221221                            link);
    222                        
     222
    223223                        list_remove(link);
    224224                        free(item);
    … …  
    242242                if (b == 0)
    243243                        return false;
    244                
     244
    245245                *value = a / b;
    246246                break;
    … …  
    248248                return false;
    249249        }
    250        
     250
    251251        return true;
    252252}
    … …  
    277277                        break;
    278278                }
    279                
     279
    280280                if (!list_empty(stack)) {
    281281                        operator_t operator;
    … …  
    285285                                break;
    286286                        }
    287                        
     287
    288288                        int64_t value_a;
    289289                        if (!stack_pop_value(stack, &value_a)) {
    … …  
    292292                                break;
    293293                        }
    294                        
     294
    295295                        if (!compute(value_a, operator, *value, value)) {
    296296                                *state = STATE_ERROR;
    … …  
    298298                                break;
    299299                        }
    300                        
     300
    301301                        if (!stack_push_value(stack, *value, false)) {
    302302                                *state = STATE_ERROR;
    … …  
    322322                expr = NULL;
    323323        }
    324        
     324
    325325        switch (error_type) {
    326326        case ERROR_SYNTAX:
    … …  
    338338{
    339339        const char *subexpr = (const char *) widget_get_data(widget);
    340        
     340
    341341        if (expr != NULL) {
    342342                char *new_expr;
    343                
     343
    344344                asprintf(&new_expr, "%s%s", expr, subexpr);
    345345                free(expr);
    … …  
    347347        } else
    348348                expr = str_dup(subexpr);
    349        
     349
    350350        display_update();
    351351}
    … …  
    357357                expr = NULL;
    358358        }
    359        
     359
    360360        display_update();
    361361}
    … …  
    365365        if (expr == NULL)
    366366                return;
    367        
     367
    368368        list_t stack;
    369369        list_initialize(&stack);
    370        
     370
    371371        error_type_t error_type = ERROR_SYNTAX;
    372372        size_t i = 0;
    … …  
    375375        bool value_neg = false;
    376376        operator_t last_operator = OPERATOR_NONE;
    377        
     377
    378378        while ((state != STATE_FINISH) && (state != STATE_ERROR)) {
    379379                switch (state) {
    … …  
    394394                                state = STATE_ERROR;
    395395                        break;
    396                
     396
    397397                case STATE_DIGIT:
    398398                        if (is_digit(expr[i])) {
    … …  
    403403                                state = STATE_ERROR;
    404404                        break;
    405                
     405
    406406                case STATE_VALUE:
    407407                        if (is_digit(expr[i])) {
    … …  
    414414                                        break;
    415415                                }
    416                                
     416
    417417                                value = 0;
    418418                                value_neg = false;
    419                                
     419
    420420                                operator_t operator = get_operator(expr[i]);
    421                                
     421
    422422                                if (get_priority(operator) <= get_priority(last_operator)) {
    423423                                        evaluate(&stack, &value, &state, &error_type);
    424424                                        if (state == STATE_ERROR)
    425425                                                break;
    426                                        
     426
    427427                                        if (!stack_push_value(&stack, value, value_neg)) {
    428428                                                state = STATE_ERROR;
    … …  
    430430                                        }
    431431                                }
    432                                
     432
    433433                                if (!stack_push_operator(&stack, operator)) {
    434434                                        state = STATE_ERROR;
    435435                                        break;
    436436                                }
    437                                
     437
    438438                                last_operator = operator;
    439439                                i++;
    … …  
    444444                                        break;
    445445                                }
    446                                
     446
    447447                                state = STATE_FINISH;
    448448                        } else
    449449                                state = STATE_ERROR;
    450450                        break;
    451                
     451
    452452                default:
    453453                        state = STATE_ERROR;
    454454                }
    455455        }
    456        
     456
    457457        evaluate(&stack, &value, &state, &error_type);
    458458        stack_cleanup(&stack);
    459        
     459
    460460        if (state == STATE_ERROR) {
    461461                display_error(error_type);
    462462                return;
    463463        }
    464        
     464
    465465        free(expr);
    466466        asprintf(&expr, "%" PRId64, value);
    … …  
    474474                return 1;
    475475        }
    476        
     476
    477477        window_t *main_window = window_open(argv[1], NULL,
    478478            WINDOW_MAIN | WINDOW_DECORATED | WINDOW_RESIZEABLE, NAME);
    … …  
    481481                return 2;
    482482        }
    483        
     483
    484484        pixel_t grd_bg = PIXEL(255, 240, 240, 240);
    485        
     485
    486486        pixel_t btn_bg = PIXEL(255, 0, 0, 0);
    487487        pixel_t btn_fg = PIXEL(200, 200, 200, 200);
    488        
     488
    489489        pixel_t lbl_bg = PIXEL(255, 240, 240, 240);
    490490        pixel_t lbl_fg = PIXEL(255, 0, 0, 0);
    491        
     491
    492492        grid_t *grid = create_grid(window_root(main_window), NULL, 4, 5, grd_bg);
    493        
     493
    494494        display = create_label(NULL, NULL, NULL_DISPLAY, 16, lbl_bg, lbl_fg);
    495        
     495
    496496        button_t *btn_1 = create_button(NULL, "1", "1", 16, btn_bg, btn_fg,
    497497            lbl_fg);
    … …  
    514514        button_t *btn_0 = create_button(NULL, "0", "0", 16, btn_bg, btn_fg,
    515515            lbl_fg);
    516        
     516
    517517        button_t *btn_add = create_button(NULL, "+", "+", 16, btn_bg, btn_fg,
    518518            lbl_fg);
    … …  
    523523        button_t *btn_div = create_button(NULL, "/", "/", 16, btn_bg, btn_fg,
    524524            lbl_fg);
    525        
     525
    526526        button_t *btn_eval = create_button(NULL, NULL, "=", 16, btn_bg, btn_fg,
    527527            lbl_fg);
    528528        button_t *btn_c = create_button(NULL, NULL, "C", 16, btn_bg, btn_fg,
    529529            lbl_fg);
    530        
     530
    531531        if ((!grid) || (!display) || (!btn_1) || (!btn_2) || (!btn_3) ||
    532532            (!btn_4) || (!btn_5) || (!btn_6) || (!btn_7) || (!btn_8) ||
    … …  
    537537                return 3;
    538538        }
    539        
     539
    540540        sig_connect(&btn_1->clicked, &btn_1->widget, on_btn_click);
    541541        sig_connect(&btn_2->clicked, &btn_2->widget, on_btn_click);
    … …  
    548548        sig_connect(&btn_9->clicked, &btn_9->widget, on_btn_click);
    549549        sig_connect(&btn_0->clicked, &btn_0->widget, on_btn_click);
    550        
     550
    551551        sig_connect(&btn_add->clicked, &btn_add->widget, on_btn_click);
    552552        sig_connect(&btn_sub->clicked, &btn_sub->widget, on_btn_click);
    553553        sig_connect(&btn_div->clicked, &btn_div->widget, on_btn_click);
    554554        sig_connect(&btn_mul->clicked, &btn_mul->widget, on_btn_click);
    555        
     555
    556556        sig_connect(&btn_eval->clicked, &btn_eval->widget, on_eval_click);
    557557        sig_connect(&btn_c->clicked, &btn_c->widget, on_c_click);
    558        
     558
    559559        grid->add(grid, &display->widget, 0, 0, 4, 1);
    560        
     560
    561561        grid->add(grid, &btn_1->widget, 0, 1, 1, 1);
    562562        grid->add(grid, &btn_2->widget, 1, 1, 1, 1);
    563563        grid->add(grid, &btn_3->widget, 2, 1, 1, 1);
    564564        grid->add(grid, &btn_add->widget, 3, 1, 1, 1);
    565        
     565
    566566        grid->add(grid, &btn_4->widget, 0, 2, 1, 1);
    567567        grid->add(grid, &btn_5->widget, 1, 2, 1, 1);
    568568        grid->add(grid, &btn_6->widget, 2, 2, 1, 1);
    569569        grid->add(grid, &btn_sub->widget, 3, 2, 1, 1);
    570        
     570
    571571        grid->add(grid, &btn_7->widget, 0, 3, 1, 1);
    572572        grid->add(grid, &btn_8->widget, 1, 3, 1, 1);
    573573        grid->add(grid, &btn_9->widget, 2, 3, 1, 1);
    574574        grid->add(grid, &btn_mul->widget, 3, 3, 1, 1);
    575        
     575
    576576        grid->add(grid, &btn_c->widget, 0, 4, 1, 1);
    577577        grid->add(grid, &btn_0->widget, 1, 4, 1, 1);
    578578        grid->add(grid, &btn_eval->widget, 2, 4, 1, 1);
    579579        grid->add(grid, &btn_div->widget, 3, 4, 1, 1);
    580        
     580
    581581        window_resize(main_window, 0, 0, 400, 400, WINDOW_PLACEMENT_ANY);
    582582        window_exec(main_window);
    583        
     583
    584584        task_retval(0);
    585585        async_manager();
    586        
     586
    587587        return 0;
    588588}
Note: See TracChangeset for help on using the changeset viewer.