Changeset 8565a42 in mainline for uspace/app/bdsh


Ignore:
Timestamp:
2018-03-02T20:34:50Z (8 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a1a81f69, d5e5fd1
Parents:
3061bc1 (diff), 34e1206 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)
git-committer:
GitHub <noreply@…> (2018-03-02 20:34:50)
Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

Location:
uspace/app/bdsh
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/bdsh/cmds/builtin_cmds.c

    r3061bc1 r8565a42  
    107107
    108108        cmd += builtin;
    109        
     109
    110110        iostate_t *old_iostate = get_iostate();
    111111        set_iostate(new_iostate);
    112        
     112
    113113        if (NULL != cmd->entry) {
    114114                rc = ((int)cmd->entry(argv, usr));
    … …  
    116116                rc = CL_ENOENT;
    117117        }
    118        
     118
    119119        set_iostate(old_iostate);
    120120

  • uspace/app/bdsh/cmds/mod_cmds.c

    r3061bc1 r8565a42  
    129129
    130130        mod += module;
    131        
     131
    132132        iostate_t *old_iostate = get_iostate();
    133133        set_iostate(new_iostate);
    … …  
    138138                rc = CL_ENOENT;
    139139        }
    140        
     140
    141141        set_iostate(old_iostate);
    142142

  • uspace/app/bdsh/cmds/modules/cat/cat.c

    r3061bc1 r8565a42  
    110110        console_set_pos(console, 0, console_rows-1);
    111111        console_set_color(console, COLOR_WHITE, COLOR_BLUE, 0);
    112        
     112
    113113        printf("ENTER/SPACE/PAGE DOWN - next page, "
    114114               "ESC/Q - quit, C - continue unpaged");
    115115        fflush(stdout);
    116        
     116
    117117        console_set_style(console, STYLE_NORMAL);
    118118}
    … …  
    122122        cons_event_t ev;
    123123        kbd_event_t *kev;
    124        
     124
    125125        while (true) {
    126126                if (!console_get_event(console, &ev)) {
    … …  
    129129                if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS) {
    130130                        kev = &ev.ev.key;
    131                        
     131
    132132                        if (kev->key == KC_ESCAPE || kev->key == KC_Q) {
    133133                                should_quit = true;
    … …  
    190190
    191191        bool reading_stdin = dash_represents_stdin && (str_cmp(fname, "-") == 0);
    192        
     192
    193193        if (reading_stdin) {
    194194                fd = fileno(stdin);
    … …  
    201201                }
    202202        }
    203        
     203
    204204        if (fd < 0) {
    205205                printf("Unable to open %s\n", fname);
    … …  
    255255                        }
    256256                }
    257                
     257
    258258                rc = vfs_read(fd, &pos, buff + copied_bytes, bytes_to_read,
    259259                    &bytes);
    … …  
    283283                                        paged_char(c);
    284284                                }
    285                                
     285
    286286                        }
    287287                        count += bytes;
    288288                        reads++;
    289289                }
    290                
     290
    291291                if (reading_stdin)
    292292                        fflush(stdout);
    … …  
    317317        sysarg_t rows, cols;
    318318        errno_t rc;
    319        
     319
    320320        /*
    321321         * reset global state
    … …  
    392392        if (buffer < 4)
    393393                buffer = CAT_DEFAULT_BUFLEN;
    394        
     394
    395395        if (more) {
    396396                rc = console_get_size(console, &cols, &rows);

  • uspace/app/bdsh/cmds/modules/cmp/cmp.c

    r3061bc1 r8565a42  
    120120        unsigned int argc;
    121121        int c, opt_ind;
    122        
     122
    123123        argc = cli_count_args(argv);
    124124

  • uspace/app/bdsh/cmds/modules/cp/cp.c

    r3061bc1 r8565a42  
    196196                str_cpy(src_path, src_len + 1, src);
    197197                str_rtrim(src_path, '/');
    198                
     198
    199199                /* Get the last component name from the src path */
    200200                src_fname = get_last_path_component(src_path);
    201                
     201
    202202                /* Initialize dest_path with the dest argument */
    203203                str_cpy(dest_path, PATH_MAX, dest);
    … …  
    206206                        /* e.g. cp file_name /data */
    207207                        /* e.g. cp file_name /data/ */
    208                        
     208
    209209                        /* dest is a directory,
    210210                         * append the src filename to it.

  • uspace/app/bdsh/cmds/modules/kcon/kcon.c

    r3061bc1 r8565a42  
    4343{
    4444        printf("`kcon' switches to the kernel debug console.\n");
    45        
     45
    4646        if (level != HELP_SHORT)
    4747                printf("Usage: %s\n", cmdname);
    48        
     48
    4949        return;
    5050}
    … …  
    5454{
    5555        unsigned int argc = cli_count_args(argv);
    56        
     56
    5757        if (argc != 1) {
    5858                printf("%s - incorrect number of arguments. Try `%s --help'\n",
    … …  
    6060                return CMD_FAILURE;
    6161        }
    62        
     62
    6363        if (console_kcon())
    6464                return CMD_SUCCESS;

  • uspace/app/bdsh/cmds/modules/ls/ls.c

    r3061bc1 r8565a42  
    111111        struct dir_elem_t const *da = a;
    112112        struct dir_elem_t const *db = b;
    113        
     113
    114114        if ((da->s.is_directory && db->s.is_file) ||
    115115            ((da->s.is_directory == db->s.is_directory) &&
    … …  
    141141        struct dir_elem_t *tosort;
    142142        struct dirent *dp;
    143        
     143
    144144        if (!dirp)
    145145                return -1;
    … …  
    150150                return -1;
    151151        }
    152        
     152
    153153        tosort = (struct dir_elem_t *) malloc(alloc_blocks * sizeof(*tosort));
    154154        if (!tosort) {
    … …  
    157157                return -1;
    158158        }
    159        
     159
    160160        while ((dp = readdir(dirp))) {
    161161                if (nbdirs + 1 > alloc_blocks) {
    162162                        alloc_blocks += alloc_blocks;
    163                        
     163
    164164                        tmp = (struct dir_elem_t *) realloc(tosort,
    165165                            alloc_blocks * sizeof(struct dir_elem_t));
    … …  
    170170                        tosort = tmp;
    171171                }
    172                
     172
    173173                /* fill the name field */
    174174                tosort[nbdirs].name = (char *) malloc(str_size(dp->d_name) + 1);
    … …  
    189189                }
    190190        }
    191        
     191
    192192        if (ls.sort)
    193193                qsort(&tosort[0], nbdirs, sizeof(struct dir_elem_t), ls_cmp);
    194        
     194
    195195        for (i = 0; i < nbdirs; i++)
    196196                ls_print(&tosort[i]);
    … …  
    214214                }
    215215        }
    216        
     216
    217217out:
    218218        for(i = 0; i < nbdirs; i++)
    … …  
    239239        DIR *subdirp;
    240240        struct dir_elem_t *dir_list;
    241        
     241
    242242        const char * const trailing_slash = "/";
    243243
    … …  
    294294                }
    295295        }
    296    
     296
    297297        ret = CMD_SUCCESS;
    298298
    … …  
    355355
    356356        argc = cli_count_args(argv);
    357        
     357
    358358        for (c = 0, optreset = 1, optind = 0, opt_ind = 0; c != -1;) {
    359359                c = getopt_long(argc, argv, "hur", long_options, &opt_ind);

  • uspace/app/bdsh/cmds/modules/mkfile/mkfile.c

    r3061bc1 r8565a42  
    171171        if (create_sparse && file_size > 0) {
    172172                const char byte = 0x00;
    173                
     173
    174174                pos = file_size - 1;
    175175                rc = vfs_write(fd, &pos, &byte, sizeof(char), &nwritten);

  • uspace/app/bdsh/cmds/modules/printf/TODO

    r3061bc1 r8565a42  
    1111 * Add width/precision options for number printings
    1212 * Add more format flags (%f %b ...)
    13  

  • uspace/app/bdsh/cmds/modules/printf/printf.c

    r3061bc1 r8565a42  
    5555        }
    5656
    57        
     57
    5858        return;
    5959}

  • uspace/app/bdsh/cmds/modules/rm/rm.c

    r3061bc1 r8565a42  
    189189
    190190        closedir(dirp);
    191        
     191
    192192        return ret;
    193193}

  • uspace/app/bdsh/cmds/modules/touch/touch.c

    r3061bc1 r8565a42  
    6969                    cmdname);
    7070        }
    71        
     71
    7272        return;
    7373}
    … …  
    8585        int fd = -1;
    8686        char *buff = NULL;
    87        
     87
    8888        DIR *dirp;
    89        
     89
    9090        for (c = 0, optreset = 1, optind = 0, longind = 0; c != -1; ) {
    9191                c = getopt_long(argc, argv, "c", long_options, &longind);
    … …  
    9696                }
    9797        }
    98        
     98
    9999        if (argc - optind < 1) {
    100100                printf("%s: Incorrect number of arguments. Try `help %s extended'\n",
    … …  
    102102                return CMD_FAILURE;
    103103        }
    104        
     104
    105105        for (i = optind; argv[i] != NULL; i++) {
    106106                buff = str_dup(argv[i]);
    … …  
    110110                        continue;
    111111                }
    112                
     112
    113113                dirp = opendir(buff);
    114114                if (dirp) {
    … …  
    119119                        continue;
    120120                }
    121                
     121
    122122                /* Check whether file exists if -c (--no-create) option is given */
    123123                if ((!no_create) ||
    … …  
    128128                        }
    129129                }
    130                
     130
    131131                if (fd < 0) {
    132132                        cli_error(CL_EFAIL, "Could not update or create `%s'", buff);
    … …  
    138138                        fd = -1;
    139139                }
    140                
     140
    141141                free(buff);
    142142        }
    143        
     143
    144144        if (ret)
    145145                return CMD_FAILURE;

  • uspace/app/bdsh/compl.c

    r3061bc1 r8565a42  
    9595        char *dirname = NULL;
    9696        errno_t retval;
    97        
     97
    9898        token_t *tokens = calloc(WORD_MAX, sizeof(token_t));
    9999        if (tokens == NULL) {
    … …  
    101101                goto error;
    102102        }
    103        
     103
    104104        size_t pref_size;
    105105        char *rpath_sep;
    … …  
    108108        ssize_t current_token;
    109109        size_t tokens_length;
    110        
     110
    111111        cs = calloc(1, sizeof(compl_t));
    112112        if (!cs) {
    … …  
    114114                goto error;
    115115        }
    116        
     116
    117117        /* Convert text buffer to string */
    118118        stext = wstr_to_astr(text);
    … …  
    121121                goto error;
    122122        }
    123        
     123
    124124        /* Tokenize the input string */
    125125        retval = tok_init(&tok, stext, tokens, WORD_MAX);
    … …  
    127127                goto error;
    128128        }
    129        
     129
    130130        retval = tok_tokenize(&tok, &tokens_length);
    131131        if (retval != EOK) {
    132132                goto error;
    133133        }
    134        
     134
    135135        /* Find the current token */
    136136        for (current_token = 0; current_token < (ssize_t) tokens_length;
    … …  
    138138                token_t *t = &tokens[current_token];
    139139                size_t end = t->char_start + t->char_length;
    140                
     140
    141141                /*
    142142                 * Check if the caret lies inside the token or immediately
    … …  
    147147                }
    148148        }
    149        
     149
    150150        if (tokens_length == 0)
    151151                current_token = -1;
    152        
     152
    153153        if ((current_token >= 0) && (tokens[current_token].type != TOKTYPE_SPACE))
    154154                *cstart = tokens[current_token].char_start;
    155155        else
    156156                *cstart = pos;
    157        
     157
    158158        /*
    159159         * Extract the prefix being completed
    … …  
    183183        if ((prev_token >= 0) && (tokens[prev_token].type == TOKTYPE_SPACE))
    184184                prev_token--;
    185        
     185
    186186        /*
    187187         * It is a command if it is the first token or if it immediately
    … …  
    236236
    237237        cs->prefix_len = str_length(cs->prefix);
    238        
     238
    239239        tok_fini(&tok);
    240240
    … …  
    244244error:
    245245        /* Error cleanup */
    246        
     246
    247247        tok_fini(&tok);
    248248
    … …  
    258258        if ((cs != NULL) && (cs->prefix != NULL))
    259259                free(cs->prefix);
    260        
     260
    261261        if (dirname != NULL)
    262262                free(dirname);
    263        
     263
    264264        if (prefix != NULL)
    265265                free(prefix);
    266        
     266
    267267        if (stext != NULL)
    268268                free(stext);
    269        
     269
    270270        if (cs != NULL)
    271271                free(cs);
    272        
     272
    273273        if (tokens != NULL)
    274274                free(tokens);

  • uspace/app/bdsh/exec.c

    r3061bc1 r8565a42  
    105105        tmp = str_dup(find_command(cmd));
    106106        free(found);
    107        
     107
    108108        files[0] = io->stdin;
    109109        files[1] = io->stdout;
    110110        files[2] = io->stderr;
    111        
     111
    112112        for (i = 0; i < 3 && files[i] != NULL; i++) {
    113113                vfs_fhandle(files[i], &file_handles[i]);
    … …  
    123123                return 1;
    124124        }
    125        
     125
    126126        rc = task_wait(&twait, &texit, &retval);
    127127        if (rc != EOK) {

  • uspace/app/bdsh/input.c

    r3061bc1 r8565a42  
    7171                return ENOMEM;
    7272        token_t *tokens = tokens_buf;
    73        
     73
    7474        char *cmd[WORD_MAX];
    7575        errno_t rc = EOK;
    … …  
    8989                goto finit;
    9090        }
    91        
     91
    9292        size_t tokens_length;
    9393        rc = tok_tokenize(&tok, &tokens_length);
    … …  
    9595                goto finit;
    9696        }
    97        
     97
    9898        if (tokens_length > 0 && tokens[0].type == TOKTYPE_SPACE) {
    9999                tokens++;
    100100                tokens_length--;
    101101        }
    102        
     102
    103103        if (tokens_length > 0 && tokens[tokens_length-1].type == TOKTYPE_SPACE) {
    104104                tokens_length--;
    105105        }
    106        
     106
    107107        /* Until full support for pipes is implemented, allow for a simple case:
    108108         * [from <file> |] command [| to <file>]
    … …  
    121121                }
    122122        }
    123        
     123
    124124        unsigned int cmd_token_start = 0;
    125125        unsigned int cmd_token_end = tokens_length;
    126        
     126
    127127        processed_pipes = 0;
    128        
     128
    129129        /* Check if the first part (from <file> |) is present */
    130130        if (pipe_count > 0 && (pipe_pos[0] == 3 || pipe_pos[0] == 4) && str_cmp(tokens[0].text, "from") == 0) {
    … …  
    134134                processed_pipes++;
    135135        }
    136        
     136
    137137        /* Check if the second part (| to <file>) is present */
    138138        if ((pipe_count - processed_pipes) > 0 &&
    … …  
    146146                processed_pipes++;
    147147        }
    148        
     148
    149149        if (processed_pipes != pipe_count) {
    150150                print_pipe_usage();
    … …  
    152152                goto finit;
    153153        }
    154        
     154
    155155        /* Convert tokens of the command to string array */
    156156        unsigned int cmd_pos = 0;
    … …  
    161161        }
    162162        cmd[cmd_pos++] = NULL;
    163        
     163
    164164        if (cmd[0] == NULL) {
    165165                print_pipe_usage();
    … …  
    167167                goto finit;
    168168        }
    169        
     169
    170170        iostate_t new_iostate = {
    171171                .stdin = stdin,
    … …  
    173173                .stderr = stderr
    174174        };
    175        
     175
    176176        FILE *from = NULL;
    177177        FILE *to = NULL;
    178        
     178
    179179        if (redir_from) {
    180180                from = fopen(redir_from, "r");
    … …  
    186186                new_iostate.stdin = from;
    187187        }
    188        
    189        
     188
     189
    190190        if (redir_to) {
    191191                to = fopen(redir_to, "w");
    … …  
    203203                rc = EINVAL;
    204204        }
    205        
     205
    206206finit_with_files:
    207207        if (from != NULL) {
    … …  
    211211                fclose(to);
    212212        }
    213        
     213
    214214finit:
    215215        if (NULL != usr->line) {
    … …  
    230230        printf("from filename | command ... | to filename\n");
    231231        printf("command ... | to filename\n");
    232        
     232
    233233}
    234234
    … …  
    236236{
    237237        int id = 0;
    238        
     238
    239239        /* We have rubbish */
    240240        if (NULL == cmd[0]) {
    241241                return CL_ENOENT;
    242242        }
    243        
     243
    244244        /* Is it a builtin command ? */
    245245        if ((id = (is_builtin(cmd[0]))) > -1) {
    246246                return run_builtin(id, cmd, usr, new_iostate);
    247247        }
    248        
     248
    249249        /* Is it a module ? */
    250250        if ((id = (is_module(cmd[0]))) > -1) {
    … …  
    260260        char *str;
    261261        errno_t rc;
    262        
     262
    263263        tinput_set_prompt(tinput, usr->prompt);
    264264

  • uspace/app/bdsh/scli.c

    r3061bc1 r8565a42  
    9999{
    100100        errno_t ret = 0;
    101        
     101
    102102        stdiostate.stdin = stdin;
    103103        stdiostate.stdout = stdout;

  • uspace/app/bdsh/tok.c

    r3061bc1 r8565a42  
    5959        tok->in_char_offset = 0;
    6060        tok->last_in_char_offset = 0;
    61        
     61
    6262        tok->outtok = out_tokens;
    6363        tok->outtok_offset = 0;
    6464        tok->outtok_size = max_tokens;
    65        
     65
    6666        /* Prepare a buffer where all the token strings will be stored */
    6767        size_t len = str_size(input) + max_tokens + 1;
    6868        char *tmp = malloc(len);
    69        
     69
    7070        if (tmp == NULL) {
    7171                return ENOMEM;
    7272        }
    73        
     73
    7474        tok->outbuf = tmp;
    7575        tok->outbuf_offset = 0;
    7676        tok->outbuf_size = len;
    7777        tok->outbuf_last_start = 0;
    78        
     78
    7979        return EOK;
    8080}
    … …  
    9393        errno_t rc;
    9494        wchar_t next_char;
    95        
     95
    9696        /* Read the input line char by char and append tokens */
    9797        while ((next_char = tok_look_char(tok)) != 0) {
    … …  
    113113                        }
    114114                        tok_push_token(tok);
    115                        
     115
    116116                }
    117117                else if (next_char == '|') {
    … …  
    125125                                }
    126126                        }
    127                        
     127
    128128                        tok_start_token(tok, TOKTYPE_PIPE);
    129                        
     129
    130130                        rc = tok_push_char(tok, tok_get_char(tok));
    131131                        if (rc != EOK) {
    132132                                return rc;
    133133                        }
    134                        
     134
    135135                        rc = tok_push_token(tok);
    136136                        if (rc != EOK) {
    … …  
    163163                }
    164164        }
    165        
     165
    166166        /* Push the last token */
    167167        if (tok_pending_chars(tok)) {
    … …  
    171171                }
    172172        }
    173        
     173
    174174        *tokens_length = tok->outtok_offset;
    175        
     175
    176176        return EOK;
    177177}
    … …  
    182182        errno_t rc;
    183183        wchar_t next_char;
    184        
     184
    185185        while ((next_char = tok_look_char(tok)) != 0) {
    186186                if (next_char == '\'') {
    … …  
    193193                                        return rc;
    194194                                }
    195                                
     195
    196196                                /* Swallow the additional one in the input */
    197197                                tok_get_char(tok);
    … …  
    209209                }
    210210        }
    211        
     211
    212212        /* If we are here, the string run to the end without being closed */
    213213        return EINVAL;
    … …  
    249249                return EOVERFLOW;
    250250        }
    251        
     251
    252252        if (tok->outbuf_offset >= tok->outbuf_size) {
    253253                return EOVERFLOW;
    254254        }
    255        
     255
    256256        tok->outbuf[tok->outbuf_offset++] = 0;
    257257        token_t *tokinfo = &tok->outtok[tok->outtok_offset++];
    … …  
    263263        tokinfo->char_length = tok->in_char_offset - tok->last_in_char_offset;
    264264        tok->outbuf_last_start = tok->outbuf_offset;
    265        
     265
    266266        /* We have consumed the first char of the next token already */
    267267        tok->last_in_offset = tok->in_offset;
    268268        tok->last_in_char_offset = tok->in_char_offset;
    269        
     269
    270270        return EOK;
    271271}

  • uspace/app/bdsh/tok.h

    r3061bc1 r8565a42  
    5151        size_t in_char_offset;
    5252        size_t last_in_char_offset;
    53        
     53
    5454        char *outbuf;
    5555        size_t outbuf_offset;
    5656        size_t outbuf_size;
    5757        size_t outbuf_last_start;
    58        
     58
    5959        token_t *outtok;
    6060        token_type_t current_type;
Note: See TracChangeset for help on using the changeset viewer.