Changeset 1433ecda in mainline for uspace/app/sbi


Ignore:
Timestamp:
2018-04-04T15:42:37Z (8 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2c4e1cc
Parents:
47b2d7e3
Message:

Fix cstyle: make ccheck-fix and commit only files where all the changes are good.

Location:
uspace/app/sbi/src
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/sbi/src/ancr.c

    r47b2d7e3 r1433ecda  
    160160        gf_class = builtin_get_gf_class(prog->builtin);
    161161
    162         if (csi != gf_class){
     162        if (csi != gf_class) {
    163163                /* Implicit inheritance from grandfather class. */
    164164                base_csi = gf_class;

  • uspace/app/sbi/src/builtin.c

    r47b2d7e3 r1433ecda  
    8484
    8585        builtin_code_snippet(bi,
    86                 "class Object is\n"
    87                 "end\n");
     86            "class Object is\n"
     87            "end\n");
    8888        bi->gf_class = builtin_find_lvl0(bi, "Object");
    8989

  • uspace/app/sbi/src/builtin/bi_char.c

    r47b2d7e3 r1433ecda  
    6969static void bi_char_get_as_string(run_t *run)
    7070{
    71         rdata_var_t *self_value_var;
    72         bigint_t *cval;
    73         char *str;
    74         int char_val;
    75         errno_t rc;
     71        rdata_var_t *self_value_var;
     72        bigint_t *cval;
     73        char *str;
     74        int char_val;
     75        errno_t rc;
    7676
    7777#ifdef DEBUG_RUN_TRACE

  • uspace/app/sbi/src/builtin/bi_int.c

    r47b2d7e3 r1433ecda  
    6969static void bi_int_get_as_string(run_t *run)
    7070{
    71         rdata_var_t *self_value_var;
    72         bigint_t *ival;
    73         char *str;
     71        rdata_var_t *self_value_var;
     72        bigint_t *ival;
     73        char *str;
    7474
    7575        /* Extract self.Value */

  • uspace/app/sbi/src/builtin/bi_string.c

    r47b2d7e3 r1433ecda  
    7171static void bi_string_length(run_t *run)
    7272{
    73         rdata_var_t *self_value_var;
    74         const char *str;
    75         size_t str_l;
     73        rdata_var_t *self_value_var;
     74        const char *str;
     75        size_t str_l;
    7676
    7777        rdata_int_t *rint;
    … …  
    114114static void bi_string_slice(run_t *run)
    115115{
    116         rdata_var_t *self_value_var;
    117         const char *str;
    118         const char *slice;
    119         size_t str_l;
     116        rdata_var_t *self_value_var;
     117        const char *str;
     118        const char *slice;
     119        size_t str_l;
    120120
    121121        rdata_var_t *start_var;

  • uspace/app/sbi/src/builtin/bi_task.c

    r47b2d7e3 r1433ecda  
    5050{
    5151        builtin_code_snippet(bi,
    52                 "class Task is\n"
    53                         "fun Exec(args : string[], packed), static, builtin;\n"
    54                 "end\n");
     52            "class Task is\n"
     53            "fun Exec(args : string[], packed), static, builtin;\n"
     54            "end\n");
    5555}
    5656
    … …  
    116116        cmd[dim] = NULL;
    117117
    118         if (os_exec((char * const *)cmd) != EOK) {
     118        if (os_exec((char *const *)cmd) != EOK) {
    119119                printf("Error: Exec failed.\n");
    120120                exit(1);

  • uspace/app/sbi/src/lex.c

    r47b2d7e3 r1433ecda  
    423423
    424424        switch (bp[0]) {
    425         case ',': lex->current.lclass = lc_comma; ++bp; break;
    426         case ':': lex->current.lclass = lc_colon; ++bp; break;
    427         case ';': lex->current.lclass = lc_scolon; ++bp; break;
    428 
    429         case '.': lex->current.lclass = lc_period; ++bp; break;
    430         case '/': lex->current.lclass = lc_slash; ++bp; break;
    431         case '(': lex->current.lclass = lc_lparen; ++bp; break;
    432         case ')': lex->current.lclass = lc_rparen; ++bp; break;
    433         case '[': lex->current.lclass = lc_lsbr; ++bp; break;
    434         case ']': lex->current.lclass = lc_rsbr; ++bp; break;
     425        case ',':
     426                lex->current.lclass = lc_comma;
     427                ++bp;
     428                break;
     429        case ':':
     430                lex->current.lclass = lc_colon;
     431                ++bp;
     432                break;
     433        case ';':
     434                lex->current.lclass = lc_scolon;
     435                ++bp;
     436                break;
     437
     438        case '.':
     439                lex->current.lclass = lc_period;
     440                ++bp;
     441                break;
     442        case '/':
     443                lex->current.lclass = lc_slash;
     444                ++bp;
     445                break;
     446        case '(':
     447                lex->current.lclass = lc_lparen;
     448                ++bp;
     449                break;
     450        case ')':
     451                lex->current.lclass = lc_rparen;
     452                ++bp;
     453                break;
     454        case '[':
     455                lex->current.lclass = lc_lsbr;
     456                ++bp;
     457                break;
     458        case ']':
     459                lex->current.lclass = lc_rsbr;
     460                ++bp;
     461                break;
    435462
    436463        case '=':
    437464                if (bp[1] == '=') {
    438                         lex->current.lclass = lc_equal; bp += 2; break;
    439                 }
    440                 lex->current.lclass = lc_assign; ++bp; break;
     465                        lex->current.lclass = lc_equal;
     466                        bp += 2;
     467                        break;
     468                }
     469                lex->current.lclass = lc_assign;
     470                ++bp;
     471                break;
    441472
    442473        case '!':
    443474                if (bp[1] == '=') {
    444                         lex->current.lclass = lc_notequal; bp += 2; break;
     475                        lex->current.lclass = lc_notequal;
     476                        bp += 2;
     477                        break;
    445478                }
    446479                goto invalid;
    … …  
    448481        case '+':
    449482                if (bp[1] == '=') {
    450                         lex->current.lclass = lc_increase; bp += 2; break;
    451                 }
    452                 lex->current.lclass = lc_plus; ++bp; break;
     483                        lex->current.lclass = lc_increase;
     484                        bp += 2;
     485                        break;
     486                }
     487                lex->current.lclass = lc_plus;
     488                ++bp;
     489                break;
    453490
    454491        case '-':
    455                 lex->current.lclass = lc_minus; ++bp; break;
     492                lex->current.lclass = lc_minus;
     493                ++bp;
     494                break;
    456495
    457496        case '*':
    458                 lex->current.lclass = lc_mult; ++bp; break;
     497                lex->current.lclass = lc_mult;
     498                ++bp;
     499                break;
    459500
    460501        case '<':
    461502                if (bp[1] == '=') {
    462                         lex->current.lclass = lc_lt_equal; bp += 2; break;
    463                 }
    464                 lex->current.lclass = lc_lt; ++bp; break;
     503                        lex->current.lclass = lc_lt_equal;
     504                        bp += 2;
     505                        break;
     506                }
     507                lex->current.lclass = lc_lt;
     508                ++bp;
     509                break;
    465510
    466511        case '>':
    467512                if (bp[1] == '=') {
    468                         lex->current.lclass = lc_gt_equal; bp += 2; break;
    469                 }
    470                 lex->current.lclass = lc_gt; ++bp; break;
     513                        lex->current.lclass = lc_gt_equal;
     514                        bp += 2;
     515                        break;
     516                }
     517                lex->current.lclass = lc_gt;
     518                ++bp;
     519                break;
    471520
    472521        default:
    … …  
    680729                } else {
    681730                        strlit_buf[didx] = bp[sidx];
    682                         ++sidx; ++didx;
     731                        ++sidx;
     732                        ++didx;
    683733                }
    684734        }

  • uspace/app/sbi/src/os/helenos.c

    r47b2d7e3 r1433ecda  
    255255        int retval;
    256256
    257         rc = task_spawnv(&tid, &twait, cmd[0], (char const * const *) cmd);
     257        rc = task_spawnv(&tid, &twait, cmd[0], (char const *const *) cmd);
    258258        if (rc != EOK) {
    259259                printf("Error: Failed spawning '%s' (%s).\n", cmd[0],

  • uspace/app/sbi/src/os/os.h

    r47b2d7e3 r1433ecda  
    3939void os_input_disp_help(void);
    4040errno_t os_input_line(const char *prompt, char **ptr);
    41 errno_t os_exec(char * const cmd[]);
     41errno_t os_exec(char *const cmd[]);
    4242
    4343void os_store_ef_path(char *path);

  • uspace/app/sbi/src/p_expr.c

    r47b2d7e3 r1433ecda  
    220220
    221221                switch (lcur_lc(parse)) {
    222                 case lc_equal: bc = bo_equal; break;
    223                 case lc_notequal: bc = bo_notequal; break;
    224                 case lc_lt: bc = bo_lt; break;
    225                 case lc_gt: bc = bo_gt; break;
    226                 case lc_lt_equal: bc = bo_lt_equal; break;
    227                 case lc_gt_equal: bc = bo_gt_equal; break;
    228                 default: assert(b_false);
     222                case lc_equal:
     223                        bc = bo_equal;
     224                        break;
     225                case lc_notequal:
     226                        bc = bo_notequal;
     227                        break;
     228                case lc_lt:
     229                        bc = bo_lt;
     230                        break;
     231                case lc_gt:
     232                        bc = bo_gt;
     233                        break;
     234                case lc_lt_equal:
     235                        bc = bo_lt_equal;
     236                        break;
     237                case lc_gt_equal:
     238                        bc = bo_gt_equal;
     239                        break;
     240                default:
     241                        assert(b_false);
    229242                }
    230243
    … …  
    267280
    268281                switch (lcur_lc(parse)) {
    269                 case lc_plus: bc = bo_plus; break;
    270                 case lc_minus: bc = bo_minus; break;
    271                 default: assert(b_false);
     282                case lc_plus:
     283                        bc = bo_plus;
     284                        break;
     285                case lc_minus:
     286                        bc = bo_minus;
     287                        break;
     288                default:
     289                        assert(b_false);
    272290                }
    273291
    … …  
    310328
    311329                switch (lcur_lc(parse)) {
    312                 case lc_mult: bc = bo_mult; break;
    313                 default: assert(b_false);
     330                case lc_mult:
     331                        bc = bo_mult;
     332                        break;
     333                default:
     334                        assert(b_false);
    314335                }
    315336
    … …  
    353374
    354375                switch (lcur_lc(parse)) {
    355                 case lc_plus: uc = uo_plus; break;
    356                 case lc_minus: uc = uo_minus; break;
    357                 case lc_not: uc = uo_not; break;
    358                 default: assert(b_false);
     376                case lc_plus:
     377                        uc = uo_plus;
     378                        break;
     379                case lc_minus:
     380                        uc = uo_minus;
     381                        break;
     382                case lc_not:
     383                        uc = uo_not;
     384                        break;
     385                default:
     386                        assert(b_false);
    359387                }
    360388
    … …  
    711739
    712740        switch (lcur_lc(parse)) {
    713         case lc_false: value = b_false; break;
    714         case lc_true: value = b_true; break;
    715         default: assert(b_false);
     741        case lc_false:
     742                value = b_false;
     743                break;
     744        case lc_true:
     745                value = b_true;
     746                break;
     747        default:
     748                assert(b_false);
    716749        }
    717750

  • uspace/app/sbi/src/parse.c

    r47b2d7e3 r1433ecda  
    183183
    184184        switch (dclass) {
    185         case lc_class: cc = csi_class; break;
    186         case lc_struct: cc = csi_struct; break;
    187         case lc_interface: cc = csi_interface; break;
    188         default: assert(b_false);
     185        case lc_class:
     186                cc = csi_class;
     187                break;
     188        case lc_struct:
     189                cc = csi_struct;
     190                break;
     191        case lc_interface:
     192                cc = csi_interface;
     193                break;
     194        default:
     195                assert(b_false);
    189196        }
    190197
    … …  
    774781
    775782        switch (lcur_lc(parse)) {
    776         case lc_builtin: sac = sac_builtin; break;
    777         case lc_static: sac = sac_static; break;
     783        case lc_builtin:
     784                sac = sac_builtin;
     785                break;
     786        case lc_static:
     787                sac = sac_static;
     788                break;
    778789        default:
    779790                cspan_print(lcur_span(parse));
    … …  
    887898
    888899        if (lcur_lc(parse) == lc_colon) {
    889                 lskip(parse);
     900                lskip(parse);
    890901                sig->rtype = parse_texpr(parse);
    891902        } else {
    … …  
    16471658        if (lcur(parse)->lclass != lc) {
    16481659                lem_print_coords(lcur(parse));
    1649                 printf(" Error: expected '"); lclass_print(lc);
    1650                 printf("', got '"); lem_print(lcur(parse));
     1660                printf(" Error: expected '");
     1661                lclass_print(lc);
     1662                printf("', got '");
     1663                lem_print(lcur(parse));
    16511664                printf("'.\n");
    16521665                parse_raise_error(parse);

  • uspace/app/sbi/src/rdata.c

    r47b2d7e3 r1433ecda  
    822822static void rdata_array_copy(rdata_array_t *src, rdata_array_t **dest)
    823823{
    824         (void) src; (void) dest;
     824        (void) src;
     825        (void) dest;
    825826        printf("Unimplemented: Copy array.\n");
    826827        exit(1);
    … …  
    834835static void rdata_object_copy(rdata_object_t *src, rdata_object_t **dest)
    835836{
    836         (void) src; (void) dest;
     837        (void) src;
     838        (void) dest;
    837839        printf("Unimplemented: Copy object.\n");
    838840        abort();

  • uspace/app/sbi/src/run.c

    r47b2d7e3 r1433ecda  
    134134
    135135#ifdef DEBUG_RUN_TRACE
    136         printf("Found function '"); symbol_print_fqn(main_fun_sym);
     136        printf("Found function '");
     137        symbol_print_fqn(main_fun_sym);
    137138        printf("'.\n");
    138139#endif

  • uspace/app/sbi/src/run_texpr.c

    r47b2d7e3 r1433ecda  
    283283
    284284        switch (tliteral->tlc) {
    285         case tlc_bool: tpc = tpc_bool; break;
    286         case tlc_char: tpc = tpc_char; break;
    287         case tlc_int: tpc = tpc_int; break;
    288         case tlc_string: tpc = tpc_string; break;
    289         case tlc_resource: tpc = tpc_resource; break;
     285        case tlc_bool:
     286                tpc = tpc_bool;
     287                break;
     288        case tlc_char:
     289                tpc = tpc_char;
     290                break;
     291        case tlc_int:
     292                tpc = tpc_int;
     293                break;
     294        case tlc_string:
     295                tpc = tpc_string;
     296                break;
     297        case tlc_resource:
     298                tpc = tpc_resource;
     299                break;
    290300        }
    291301

  • uspace/app/sbi/src/stree.c

    r47b2d7e3 r1433ecda  
    11511151
    11521152        switch (csimbr->cc) {
    1153         case csimbr_csi: mbr_name = csimbr->u.csi->name; break;
    1154         case csimbr_ctor: mbr_name = csimbr->u.ctor->name; break;
    1155         case csimbr_deleg: mbr_name = csimbr->u.deleg->name; break;
    1156         case csimbr_enum: mbr_name = csimbr->u.enum_d->name; break;
    1157         case csimbr_fun: mbr_name = csimbr->u.fun->name; break;
    1158         case csimbr_var: mbr_name = csimbr->u.var->name; break;
    1159         case csimbr_prop: mbr_name = csimbr->u.prop->name; break;
     1153        case csimbr_csi:
     1154                mbr_name = csimbr->u.csi->name;
     1155                break;
     1156        case csimbr_ctor:
     1157                mbr_name = csimbr->u.ctor->name;
     1158                break;
     1159        case csimbr_deleg:
     1160                mbr_name = csimbr->u.deleg->name;
     1161                break;
     1162        case csimbr_enum:
     1163                mbr_name = csimbr->u.enum_d->name;
     1164                break;
     1165        case csimbr_fun:
     1166                mbr_name = csimbr->u.fun->name;
     1167                break;
     1168        case csimbr_var:
     1169                mbr_name = csimbr->u.var->name;
     1170                break;
     1171        case csimbr_prop:
     1172                mbr_name = csimbr->u.prop->name;
     1173                break;
    11601174        }
    11611175

  • uspace/app/sbi/src/stype.c

    r47b2d7e3 r1433ecda  
    165165
    166166                switch (csimbr->cc) {
    167                 case csimbr_csi: stype_csi(stype, csimbr->u.csi); break;
    168                 case csimbr_ctor: stype_ctor(stype, csimbr->u.ctor); break;
    169                 case csimbr_deleg: stype_deleg(stype, csimbr->u.deleg); break;
    170                 case csimbr_enum: stype_enum(stype, csimbr->u.enum_d); break;
    171                 case csimbr_fun: stype_fun(stype, csimbr->u.fun); break;
    172                 case csimbr_var: stype_var(stype, csimbr->u.var); break;
    173                 case csimbr_prop: stype_prop(stype, csimbr->u.prop); break;
     167                case csimbr_csi:
     168                        stype_csi(stype, csimbr->u.csi);
     169                        break;
     170                case csimbr_ctor:
     171                        stype_ctor(stype, csimbr->u.ctor);
     172                        break;
     173                case csimbr_deleg:
     174                        stype_deleg(stype, csimbr->u.deleg);
     175                        break;
     176                case csimbr_enum:
     177                        stype_enum(stype, csimbr->u.enum_d);
     178                        break;
     179                case csimbr_fun:
     180                        stype_fun(stype, csimbr->u.fun);
     181                        break;
     182                case csimbr_var:
     183                        stype_var(stype, csimbr->u.var);
     184                        break;
     185                case csimbr_prop:
     186                        stype_prop(stype, csimbr->u.prop);
     187                        break;
    174188                }
    175189
    … …  
    891905#endif
    892906        switch (stat->sc) {
    893         case st_vdecl: stype_vdecl(stype, stat->u.vdecl_s); break;
    894         case st_if: stype_if(stype, stat->u.if_s); break;
    895         case st_switch: stype_switch(stype, stat->u.switch_s); break;
    896         case st_while: stype_while(stype, stat->u.while_s); break;
    897         case st_for: stype_for(stype, stat->u.for_s); break;
    898         case st_raise: stype_raise(stype, stat->u.raise_s); break;
    899         case st_break: stype_break(stype, stat->u.break_s); break;
    900         case st_return: stype_return(stype, stat->u.return_s); break;
    901         case st_exps: stype_exps(stype, stat->u.exp_s, want_value); break;
    902         case st_wef: stype_wef(stype, stat->u.wef_s); break;
     907        case st_vdecl:
     908                stype_vdecl(stype, stat->u.vdecl_s);
     909                break;
     910        case st_if:
     911                stype_if(stype, stat->u.if_s);
     912                break;
     913        case st_switch:
     914                stype_switch(stype, stat->u.switch_s);
     915                break;
     916        case st_while:
     917                stype_while(stype, stat->u.while_s);
     918                break;
     919        case st_for:
     920                stype_for(stype, stat->u.for_s);
     921                break;
     922        case st_raise:
     923                stype_raise(stype, stat->u.raise_s);
     924                break;
     925        case st_break:
     926                stype_break(stype, stat->u.break_s);
     927                break;
     928        case st_return:
     929                stype_return(stype, stat->u.return_s);
     930                break;
     931        case st_exps:
     932                stype_exps(stype, stat->u.exp_s, want_value);
     933                break;
     934        case st_wef:
     935                stype_wef(stype, stat->u.wef_s);
     936                break;
    903937        }
    904938}
    … …  
    16921726        printf(" Error: ");
    16931727        switch (convc) {
    1694         case convc_implicit: printf("Cannot implicitly convert '"); break;
    1695         case convc_as: printf("Cannot use 'as' to convert '"); break;
     1728        case convc_implicit:
     1729                printf("Cannot implicitly convert '");
     1730                break;
     1731        case convc_as:
     1732                printf("Cannot use 'as' to convert '");
     1733                break;
    16961734        }
    16971735
    … …  
    18211859                            &b_ti);
    18221860                } else if (src_csi->base_csi != NULL &&
    1823                         src->u.tobject->csi->cc == csi_class) {
     1861                    src->u.tobject->csi->cc == csi_class) {
    18241862                        /* No explicit reference. Use grandfather class. */
    1825                         b_ti = tdata_item_new(tic_tobject);
     1863                        b_ti = tdata_item_new(tic_tobject);
    18261864                        b_ti->u.tobject = tdata_object_new();
    18271865                        b_ti->u.tobject->csi = src_csi->base_csi;
    … …  
    18401878                /* Recurse to compute the rest of the path. */
    18411879                res_ti = stype_tobject_find_pred(stype, bs_ti, dest);
    1842                 if (b_ti->tic == tic_ignore) {
     1880                if (b_ti->tic == tic_ignore) {
    18431881                        /* An error occured. */
    18441882                        return NULL;
    … …  
    22172255#endif
    22182256                return varg;
    2219 }
     2257        }
    22202258
    22212259        /* Setter argument */

  • uspace/app/sbi/src/symbol.c

    r47b2d7e3 r1433ecda  
    9898 */
    9999stree_symbol_t *symbol_lookup_in_csi(stree_program_t *prog, stree_csi_t *scope,
    100         stree_ident_t *name)
     100    stree_ident_t *name)
    101101{
    102102        stree_symbol_t *symbol;
    … …  
    209209
    210210                switch (modm->mc) {
    211                 case mc_csi: mbr_name = modm->u.csi->name; break;
    212                 case mc_enum: mbr_name = modm->u.enum_d->name; break;
     211                case mc_csi:
     212                        mbr_name = modm->u.csi->name;
     213                        break;
     214                case mc_enum:
     215                        mbr_name = modm->u.enum_d->name;
     216                        break;
    213217                }
    214218
    … …  
    338342                        }
    339343                }
    340                 node = list_next(&prog->module->members, node);
     344                node = list_next(&prog->module->members, node);
    341345        }
    342346
    … …  
    393397                }
    394398
    395                 node = list_next(&csi->members, node);
     399                node = list_next(&csi->members, node);
    396400        }
    397401
    … …  
    650654
    651655        switch (symbol->sc) {
    652         case sc_csi: ident = symbol->u.csi->name; break;
    653         case sc_ctor: ident = symbol->u.ctor->name; break;
    654         case sc_deleg: ident = symbol->u.deleg->name; break;
    655         case sc_enum: ident = symbol->u.enum_d->name; break;
    656         case sc_fun: ident = symbol->u.fun->name; break;
    657         case sc_var: ident = symbol->u.var->name; break;
    658         case sc_prop: ident = symbol->u.prop->name; break;
     656        case sc_csi:
     657                ident = symbol->u.csi->name;
     658                break;
     659        case sc_ctor:
     660                ident = symbol->u.ctor->name;
     661                break;
     662        case sc_deleg:
     663                ident = symbol->u.deleg->name;
     664                break;
     665        case sc_enum:
     666                ident = symbol->u.enum_d->name;
     667                break;
     668        case sc_fun:
     669                ident = symbol->u.fun->name;
     670                break;
     671        case sc_var:
     672                ident = symbol->u.var->name;
     673                break;
     674        case sc_prop:
     675                ident = symbol->u.prop->name;
     676                break;
    659677        }
    660678

  • uspace/app/sbi/src/tdata.c

    r47b2d7e3 r1433ecda  
    500500{
    501501        switch (tprimitive->tpc) {
    502         case tpc_bool: printf("bool"); break;
    503         case tpc_char: printf("char"); break;
    504         case tpc_int: printf("int"); break;
    505         case tpc_nil: printf("nil"); break;
    506         case tpc_string: printf("string"); break;
    507         case tpc_resource: printf("resource"); break;
     502        case tpc_bool:
     503                printf("bool");
     504                break;
     505        case tpc_char:
     506                printf("char");
     507                break;
     508        case tpc_int:
     509                printf("int");
     510                break;
     511        case tpc_nil:
     512                printf("nil");
     513                break;
     514        case tpc_string:
     515                printf("string");
     516                break;
     517        case tpc_resource:
     518                printf("resource");
     519                break;
    508520        }
    509521}
Note: See TracChangeset for help on using the changeset viewer.