Changeset 1b20da0 in mainline for uspace/app


Ignore:
Timestamp:
2018-02-28T17:52:03Z (8 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:
3061bc1
Parents:
df6ded8
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:26:03)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:52:03)
Message:

style: Remove trailing whitespace on non-empty lines, in certain file types.

Command used: tools/srepl '\([^[:space:]]\)\s\+$' '\1' -- *.c *.h *.py *.sh *.s *.S *.ag

Location:
uspace/app
Files:
32 edited

Legend:

Unmodified
Added
Removed

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

    rdf6ded8 r1b20da0  
    231231                        /* e.g. cp file_name existing_file */
    232232
    233                         /* dest already exists, 
     233                        /* dest already exists,
    234234                         * if force is set we will try to remove it.
    235235                         * if interactive is set user input is required.
    … …  
    414414                vfs_put(fd1);
    415415                vfs_put(fd2);
    416                 return -1;     
     416                return -1;
    417417        }
    418418
    … …  
    486486        for (c = 0, optreset = 1, optind = 0, opt_ind = 0; c != -1;) {
    487487                c = getopt_long(argc, argv, "hvVfirb:", long_options, &opt_ind);
    488                 switch (c) { 
     488                switch (c) {
    489489                case 'h':
    490490                        help_cmd_cp(1);

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

    rdf6ded8 r1b20da0  
    129129 *                              0 otherwise.
    130130 */
    131 static signed int ls_scan_dir(const char *d, DIR *dirp, 
     131static signed int ls_scan_dir(const char *d, DIR *dirp,
    132132    struct dir_elem_t **dir_list_ptr)
    133133{
    … …  
    198198        /* Populate the directory list. */
    199199        if (ls.recursive) {
    200                 tmp = (struct dir_elem_t *) realloc(*dir_list_ptr, 
     200                tmp = (struct dir_elem_t *) realloc(*dir_list_ptr,
    201201                    nbdirs * sizeof(struct dir_elem_t));
    202202                if (!tmp) {
    203203                        cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
    204204                        goto out;
    205                 } 
     205                }
    206206                *dir_list_ptr = tmp;
    207207
    … …  
    253253        }
    254254
    255         nbdirs = ls_scan_dir(path, dirp, &dir_list); 
     255        nbdirs = ls_scan_dir(path, dirp, &dir_list);
    256256        if (nbdirs == -1) {
    257257                ret = CMD_FAILURE;
    … …  
    292292                        ret = CMD_FAILURE;
    293293                        goto out;
    294                 }       
     294                }
    295295        }
    296296   
    297         ret = CMD_SUCCESS; 
     297        ret = CMD_SUCCESS;
    298298
    299299out:
    … …  
    405405                if (ls.recursive)
    406406                        ret = ls_recursive(de.name, dirp);
    407                 else 
     407                else
    408408                        ret = ls_scan_dir(de.name, dirp, NULL);
    409409

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

    rdf6ded8 r1b20da0  
    6060
    6161/** Print a formatted data with lib printf.
    62  * 
     62 *
    6363 * Currently available format flags are:
    6464 * '%d' - integer.
    6565 * '%u' - unsigned integer.
    6666 * '%s' - null-terminated string.
    67  ***** 
     67 *****
    6868 * @param ch  formatted flag.
    6969 * @param arg string with data to print.
    … …  
    8888
    8989/** Process a control character.
    90  * 
     90 *
    9191 * Currently available characters are:
    9292 * '\n' - new line.
    93  ***** 
     93 *****
    9494 * @param ch  Control character.
    9595 */
    … …  
    107107
    108108
    109 /** Prints formatted data. 
     109/** Prints formatted data.
    110110 *
    111111 * Accepted format flags:
    … …  
    143143
    144144                case '\\':
    145                         if (esc_flag) 
     145                        if (esc_flag)
    146146                                goto emit;
    147147                        esc_flag = true;
    … …  
    149149
    150150                case '%':
    151                         if (esc_flag) 
     151                        if (esc_flag)
    152152                                goto emit;
    153153                        ch = str_decode(fmt, &pos, fmt_sz);
    154                         if (!ch) { 
     154                        if (!ch) {
    155155                                putchar('%');
    156156                                break;
    … …  
    170170                                break;
    171171                        }
    172                         putchar(ch);   
     172                        putchar(ch);
    173173                        break;
    174174
    … …  
    177177                        esc_flag = false;
    178178                }
    179         }       
     179        }
    180180
    181181        return CMD_SUCCESS;

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

    rdf6ded8 r1b20da0  
    9292
    9393                int ndigits = endptr - nptr;
    94                 for (; ndigits < 6; ndigits++) 
     94                for (; ndigits < 6; ndigits++)
    9595                        frac_seconds *= 10;
    9696                for (; ndigits > 6; ndigits--)

  • uspace/app/bdsh/input.c

    rdf6ded8 r1b20da0  
    107107        /* Until full support for pipes is implemented, allow for a simple case:
    108108         * [from <file> |] command [| to <file>]
    109          * 
     109         *
    110110         * First find the pipes and check that there are no more
    111111         */

  • uspace/app/bdsh/tok.c

    rdf6ded8 r1b20da0  
    4545
    4646/** Initialize the token parser
    47  * 
     47 *
    4848 * @param tok the tokenizer structure to initialize
    4949 * @param input the input string to tokenize
    … …  
    5353errno_t tok_init(tokenizer_t *tok, char *input, token_t *out_tokens,
    5454    size_t max_tokens)
    55 {       
     55{
    5656        tok->in = input;
    5757        tok->in_offset = 0;

  • uspace/app/df/df.c

    rdf6ded8 r1b20da0  
    185185        } else {
    186186                /* Block size / Blocks / Used blocks / Available blocks / Used% / Mounted on */
    187                 printf(" %10" PRIu32 " %9" PRIu64 " %11" PRIu64 " %11" PRIu64 " %4u%% %s\n", 
     187                printf(" %10" PRIu32 " %9" PRIu64 " %11" PRIu64 " %11" PRIu64 " %4u%% %s\n",
    188188                    st->f_bsize, st->f_blocks, used_blocks, st->f_bfree,
    189189                    perc_used, mountpoint);

  • uspace/app/edit/edit.c

    rdf6ded8 r1b20da0  
    8484        keymod_t keymod;
    8585
    86         /** 
     86        /**
    8787         * Ideal column where the caret should try to get. This is used
    8888         * for maintaining the same column during vertical movement.
    … …  
    12261226
    12271227/** Find beginning of a word to the left of spt */
    1228 static spt_t pt_find_word_left(spt_t spt) 
     1228static spt_t pt_find_word_left(spt_t spt)
    12291229{
    12301230        do {
    … …  
    12351235
    12361236/** Find beginning of a word to the right of spt */
    1237 static spt_t pt_find_word_right(spt_t spt) 
     1237static spt_t pt_find_word_right(spt_t spt)
    12381238{
    12391239        do {
    … …  
    12431243}
    12441244
    1245 static void caret_move_word_left(bool select) 
     1245static void caret_move_word_left(bool select)
    12461246{
    12471247        spt_t pt;
    … …  
    12511251}
    12521252
    1253 static void caret_move_word_right(bool select) 
     1253static void caret_move_word_right(bool select)
    12541254{
    12551255        spt_t pt;

  • uspace/app/mkbd/main.c

    rdf6ded8 r1b20da0  
    151151        while (field != NULL) {
    152152                if (field->value != 0) {
    153                         const char *key_str = 
     153                        const char *key_str =
    154154                            usbhid_multimedia_usage_to_str(field->usage);
    155155                        printf("Pressed key: %s\n", key_str);
    … …  
    158158                field = usb_hid_report_get_sibling(
    159159                    report, field, path, USB_HID_PATH_COMPARE_END
    160                     | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY, 
     160                    | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
    161161                    USB_HID_REPORT_TYPE_INPUT);
    162162        }
    … …  
    281281        while (true) {
    282282                /** @todo Try blocking call. */
    283                 rc = usbhid_dev_get_event(dev_sess, event, size, &actual_size, 
     283                rc = usbhid_dev_get_event(dev_sess, event, size, &actual_size,
    284284                    &event_nr, 0);
    285285                if (rc != EOK) {

  • uspace/app/mkexfat/exfat.h

    rdf6ded8 r1b20da0  
    7979
    8080typedef struct {
    81         uint8_t         count; /* Always zero */ 
     81        uint8_t         count; /* Always zero */
    8282        uint16_t        checksum;
    8383        uint16_t        flags;

  • uspace/app/mkexfat/mkexfat.c

    rdf6ded8 r1b20da0  
    330330                goto exit;
    331331
    332         /* Write the Main extended boot sectors backup to disk */ 
     332        /* Write the Main extended boot sectors backup to disk */
    333333        rc = ebs_write(service_id, cfg,
    334334            EBS_BACKUP_SECTOR_START, &vbr_checksum);

  • uspace/app/mkfat/fat_dentry.h

    rdf6ded8 r1b20da0  
    3030/** @addtogroup fs
    3131 * @{
    32  */ 
     32 */
    3333
    3434#ifndef FAT_FAT_DENTRY_H_

  • uspace/app/mkmfs/mkmfs.c

    rdf6ded8 r1b20da0  
    167167        }
    168168
    169         if (sb.block_size < MFS_MIN_BLOCKSIZE || 
     169        if (sb.block_size < MFS_MIN_BLOCKSIZE ||
    170170            sb.block_size > MFS_MAX_BLOCKSIZE) {
    171171                printf(NAME ":Error! Invalid block size.\n");
    … …  
    175175                printf(NAME ":Error! Invalid block size.\n");
    176176                exit(0);
    177         } else if (sb.block_size > MFS_BLOCKSIZE && 
     177        } else if (sb.block_size > MFS_BLOCKSIZE &&
    178178            sb.fs_version != 3) {
    179179                printf(NAME ":Error! Block size > 1024 is "
    … …  
    470470        if (sb->fs_version == 1) {
    471471                /* Valid only for MFS V1 */
    472                 sb->n_zones = sb->dev_nblocks > UINT16_MAX ? 
     472                sb->n_zones = sb->dev_nblocks > UINT16_MAX ?
    473473                    UINT16_MAX : sb->dev_nblocks;
    474474                ind = MFS_BLOCKSIZE / sizeof(uint16_t);
    … …  
    524524
    525525        /* Compute first data zone position */
    526         sb->first_data_zone = 2 + sb->itable_size + 
     526        sb->first_data_zone = 2 + sb->itable_size +
    527527            sb->zbmap_blocks + sb->ibmap_blocks;
    528528

  • uspace/app/rcubench/rcubench.c

    rdf6ded8 r1b20da0  
    135135        }
    136136       
    137         /* 
     137        /*
    138138         * Run the last thread in place so that we create multiple threads
    139139         * only when needed. Otherwise libc would immediately upgrade
    … …  
    193193}
    194194
    195 static bool parse_cmd_line(int argc, char **argv, bench_t *bench, 
     195static bool parse_cmd_line(int argc, char **argv, bench_t *bench,
    196196        const char **err)
    197197{
    … …  
    225225                *err = "Err: Invalid number of iterations";
    226226                return false;
    227         } 
     227        }
    228228       
    229229        /* Determine thread count. */
    … …  
    236236                *err = "Err: Invalid number of threads";
    237237                return false;
    238         } 
     238        }
    239239       
    240240        return true;
    … …  
    275275        }
    276276       
    277         print_res("Completed %" PRIu64 " iterations in %" PRId64  " usecs (%" PRIu64 
    278                 " secs); %" PRIu64 " iters/sec\n", 
    279                 total_iters, duration, secs, iters_per_sec);   
     277        print_res("Completed %" PRIu64 " iterations in %" PRId64  " usecs (%" PRIu64
     278                " secs); %" PRIu64 " iters/sec\n",
     279                total_iters, duration, secs, iters_per_sec);
    280280
    281281        close_results();

  • uspace/app/rcutest/rcutest.c

    rdf6ded8 r1b20da0  
    186186/*--------------------------------------------------------------------*/
    187187
    188 static bool run_tests(test_info_t *info, bool (*include_filter)(test_desc_t *)) 
     188static bool run_tests(test_info_t *info, bool (*include_filter)(test_desc_t *))
    189189{
    190190        size_t failed_cnt = 0;
    … …  
    214214        if (failed_cnt) {
    215215                printf("%zu tests failed\n", failed_cnt);
    216         } 
     216        }
    217217       
    218218        return 0 == failed_cnt;
    … …  
    364364        if (!info.exited_cs || info.failed) {
    365365                printf("Error: rcu_sync() returned before the reader exited its CS.\n");
    366                 /* 
    367                  * Sleep some more so we don't free info on stack while the reader 
     366                /*
     367                 * Sleep some more so we don't free info on stack while the reader
    368368                 * is using it.
    369369                 */
    … …  
    440440        }
    441441       
    442         /* 
     442        /*
    443443         * synching is set when rcu_sync() is about to be entered so wait
    444444         * some more to make sure it really does start executing.
    … …  
    459459        memory_barrier();
    460460       
    461         /* 
    462          * Preexisting reader should have exited by now, so rcu_synchronize() 
     461        /*
     462         * Preexisting reader should have exited by now, so rcu_synchronize()
    463463         * must have returned.
    464464         */
    … …  
    529529       
    530530        if (info.failed) {
    531                 /* 
    532                  * Sleep some more so we don't free info on stack while readers 
     531                /*
     532                 * Sleep some more so we don't free info on stack while readers
    533533                 * are using it.
    534534                 */
    … …  
    608608                printf("Error: rcu_deregister_fibril did not unlock the CS.\n");
    609609                return false;
    610         }       
     610        }
    611611       
    612612        return true;
    … …  
    672672                }
    673673               
    674                 /* 
     674                /*
    675675                 * Check if the most recently started rcu_sync of the already
    676676                 * finished rcu_syncs did not happen to start after this reader
    … …  
    713713static bool seq_test(test_info_t *test_info)
    714714{
    715         size_t reader_cnt = test_info->thread_cnt; 
    716         size_t updater_cnt = test_info->thread_cnt; 
     715        size_t reader_cnt = test_info->thread_cnt;
     716        size_t updater_cnt = test_info->thread_cnt;
    717717               
    718718        seq_test_info_t info = {
    … …  
    820820                test_desc_t *t = &test_desc[i];
    821821               
    822                 if (!t->func) 
     822                if (!t->func)
    823823                        continue;
    824824               
    … …  
    870870                        info->thread_cnt = 1;
    871871                        printf("Err: Invalid number of threads '%s'; using 1.\n", argv[2]);
    872                 } 
     872                }
    873873        } else {
    874874                info->thread_cnt = 1;

  • uspace/app/redir/redir.c

    rdf6ded8 r1b20da0  
    158158        setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
    159159
    160         task_wait_t wait;       
     160        task_wait_t wait;
    161161        task_id_t id = spawn(&wait, argc - i, argv + i);
    162162       

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

    rdf6ded8 r1b20da0  
    258258 *
    259259 * Unlink node from the list it is currently in.
    260  * 
     260 *
    261261 * @param n     Node to unlink from its current list.
    262262 */

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

    rdf6ded8 r1b20da0  
    4848 * The string functions are in fact standard C, but would not work under
    4949 * HelenOS.
    50  * 
     50 *
    5151 * XXX String functions used here only work with 8-bit text encoding.
    5252 */

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

    rdf6ded8 r1b20da0  
    15001500}
    15011501
    1502 /** Signal a parse error, start bailing out from parser. 
     1502/** Signal a parse error, start bailing out from parser.
    15031503 *
    15041504 * @param parse         Parser object.

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

    rdf6ded8 r1b20da0  
    8080}
    8181
    82 /** Process sources of the library. 
     82/** Process sources of the library.
    8383 *
    8484 * Processes all source files in the library. The list of library source files

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

    rdf6ded8 r1b20da0  
    14331433        rdata_value_t *value;
    14341434
    1435         /* 
     1435        /*
    14361436         * This can happen when trying to use output of a function which
    14371437         * does not return a value.
    … …  
    18861886                break;
    18871887        case tic_tvref:
    1888                 /* 
     1888                /*
    18891889                 * XXX Need to obtain run-time value of type argument to
    18901890                 * initialize variable properly.

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

    rdf6ded8 r1b20da0  
    695695/** Allocate new .
    696696 *
    697  * @return      New 
     697 * @return      New
    698698 */
    699699stree_access_t *stree_access_new(void)

  • uspace/app/taskdump/fibrildump.c

    rdf6ded8 r1b20da0  
    4747static stacktrace_ops_t fibrildump_st_ops = {
    4848        .read_uintptr = fibrildump_read_uintptr
    49 }; 
     49};
    5050
    5151static errno_t fibrildump_read_uintptr(void *arg, uintptr_t addr, uintptr_t *data)
    … …  
    8181        errno_t rc;
    8282
    83         /* 
     83        /*
    8484         * If we for whatever reason could not obtain symbols table from the binary,
    8585         * we cannot dump fibrils.

  • uspace/app/taskdump/taskdump.c

    rdf6ded8 r1b20da0  
    8080static stacktrace_ops_t td_stacktrace_ops = {
    8181        .read_uintptr = td_read_uintptr
    82 }; 
     82};
    8383
    8484int main(int argc, char *argv[])

  • uspace/app/tester/mm/malloc2.c

    rdf6ded8 r1b20da0  
    11/*
    2  * Copyright (c) 2011 Jakub Jermar 
     2 * Copyright (c) 2011 Jakub Jermar
    33 * All rights reserved.
    44 *

  • uspace/app/tester/mm/pager1.c

    rdf6ded8 r1b20da0  
    104104        touch_area(buffer, buffer_len);
    105105
    106         as_area_destroy(buffer);       
     106        as_area_destroy(buffer);
    107107        vfs_put(fd);
    108108       

  • uspace/app/tester/print/print6.c

    rdf6ded8 r1b20da0  
    4040                const char *warn_str;
    4141        } pat[] = {
    42                 /* 
    43                  * Generic 
     42                /*
     43                 * Generic
    4444                 */
    4545                { 2.0,         "%g",       "2", 0 },
    … …  
    4848                { 9e59,        "%g",   "9e+59", 0 },
    4949                { -9e-59,      "%g",  "-9e-59", 0 },
    50                 { 1e307,       "%g",  "1e+307", 0 },   
    51                 { 0.09999999999999999, "%g",  "9.999999999999999e-02", 0 },   
    52                 { 0.099999999999999999, "%g",  "0.1", 0 },   
     50                { 1e307,       "%g",  "1e+307", 0 },
     51                { 0.09999999999999999, "%g",  "9.999999999999999e-02", 0 },
     52                { 0.099999999999999999, "%g",  "0.1", 0 },
    5353
    5454                /*
    … …  
    5656                 * doubles.
    5757                 */
    58                 { 3.4567e-317, "%g",  "3.4567e-317", "3.456998e-317" },   
    59                 { 3.4567e-318, "%g",  "3.4567e-318", 0 },   
    60                 { 123456789012345.0, "%g",  "123456789012345", 0 },   
    61                 { -123456789012345.0, "%g",  "-123456789012345", 0 },   
     58                { 3.4567e-317, "%g",  "3.4567e-317", "3.456998e-317" },
     59                { 3.4567e-318, "%g",  "3.4567e-318", 0 },
     60                { 123456789012345.0, "%g",  "123456789012345", 0 },
     61                { -123456789012345.0, "%g",  "-123456789012345", 0 },
    6262
    6363                /* Special */
    64                 { 1e300 * 1e300, "%g",  "inf", 0 },   
    65                 { -1.0 /(1e300 * 1e300), "%g",  "-0", 0 },   
    66 
    67                 { 1234567.8901, "%g",  "1234567.8901", 0 },   
    68                 { 1234567.80012, "%g",  "1234567.80012", 0 },   
    69                 { 112e-32, "%g",  "1.12e-30", 0 },   
    70                 { 10.0e45, "%g",  "1e+46", 0 },   
     64                { 1e300 * 1e300, "%g",  "inf", 0 },
     65                { -1.0 /(1e300 * 1e300), "%g",  "-0", 0 },
     66
     67                { 1234567.8901, "%g",  "1234567.8901", 0 },
     68                { 1234567.80012, "%g",  "1234567.80012", 0 },
     69                { 112e-32, "%g",  "1.12e-30", 0 },
     70                { 10.0e45, "%g",  "1e+46", 0 },
    7171
    7272                /* rounding w/ trailing zero removal */
    73                 { 0.01, "%10.6g",      "      0.01", 0 },   
    74                 { 9.495, "%10.2g",     "       9.5", 0 },   
    75                 { 9.495e30, "%10.2g",  "   9.5e+30", 0 },   
    76                 { 9.495e30, "%10g",  " 9.495e+30", 0 },   
    77                 { 9.495e30, "%10.6g",  " 9.495e+30", 0 },   
    78 
    79                 /*
    80                  * Scientific 
    81                  */
    82                 { 1e05, "%e",  "1.000000e+05", 0 },   
     73                { 0.01, "%10.6g",      "      0.01", 0 },
     74                { 9.495, "%10.2g",     "       9.5", 0 },
     75                { 9.495e30, "%10.2g",  "   9.5e+30", 0 },
     76                { 9.495e30, "%10g",  " 9.495e+30", 0 },
     77                { 9.495e30, "%10.6g",  " 9.495e+30", 0 },
     78
     79                /*
     80                 * Scientific
     81                 */
     82                { 1e05, "%e",  "1.000000e+05", 0 },
    8383
    8484                /* full padding */
    … …  
    8686                /* __PRINTF_FLAG_SHOWPLUS | __PRINTF_FLAG_ZEROPADDED */
    8787                { 1e-1, "%+010.3e",  "+1.000e-01", 0 },
    88                 { 1e-1, "%+10.3e",  "+1.000e-01", 0 },   
     88                { 1e-1, "%+10.3e",  "+1.000e-01", 0 },
    8989                /* __PRINTF_FLAG_SHOWPLUS | __PRINTF_FLAG_LEFTALIGNED */
    9090                { 1e-1, "%+-10.3e",  "+1.000e-01", 0 },
    … …  
    9494                /* __PRINTF_FLAG_SHOWPLUS | __PRINTF_FLAG_ZEROPADDED */
    9595                { 1e-1, "%+010.2e",  "+01.00e-01", 0 },
    96                 { 1e-1, "%+10.2e",  " +1.00e-01", 0 },   
     96                { 1e-1, "%+10.2e",  " +1.00e-01", 0 },
    9797                /* __PRINTF_FLAG_SHOWPLUS | __PRINTF_FLAG_LEFTALIGNED */
    9898                { 1e-1, "%+-10.2e",  "+1.00e-01 ", 0 },
    … …  
    103103                /* __PRINTF_FLAG_SPACESIGN */
    104104                { 1e-1, "% 10.2e",  "  1.00e-01", 0 },
    105                 { 1e-1, "%10.2e",  "  1.00e-01", 0 },   
     105                { 1e-1, "%10.2e",  "  1.00e-01", 0 },
    106106
    107107                /* padding fractionals */
    … …  
    109109                /* __PRINTF_FLAG_SHOWPLUS | __PRINTF_FLAG_ZEROPADDED */
    110110                { 1.08e29, "%+010.3e",  "+1.080e+29", 0 },
    111                 { 1.08e29, "%+10.3e",  "+1.080e+29", 0 }, 
     111                { 1.08e29, "%+10.3e",  "+1.080e+29", 0 },
    112112                /* __PRINTF_FLAG_SHOWPLUS | __PRINTF_FLAG_ZEROPADDED */
    113113                { 1.08e29, "%+011.2e",  "+001.08e+29", 0 },
    114                 { 1.085e29, "%11.2e", "   1.09e+29", 0 },   
     114                { 1.085e29, "%11.2e", "   1.09e+29", 0 },
    115115
    116116                /* rounding */
    117117
    118                 { 1.345e2, "%+10.2e",  " +1.35e+02", 0 }, 
    119                 { 9.995e2, "%+10.2e",  " +1.00e+03", 0 }, 
    120                 { -9.99499999e2, "%10.2e",  " -9.99e+02", 0 },   
    121                 { -9.99499999e2, "%10.0e",  "    -1e+03", 0 },   
     118                { 1.345e2, "%+10.2e",  " +1.35e+02", 0 },
     119                { 9.995e2, "%+10.2e",  " +1.00e+03", 0 },
     120                { -9.99499999e2, "%10.2e",  " -9.99e+02", 0 },
     121                { -9.99499999e2, "%10.0e",  "    -1e+03", 0 },
    122122                /* __PRINTF_FLAG_DECIMALPT */
    123123                { -9.99499999e2, "%#10.0e",  "   -1.e+03", 0 },
    … …  
    129129                /* special */
    130130
    131                 { 1e300 * 1e300, "%10.5e",  "       inf", 0 },   
    132                 { -1.0 /(1e300 * 1e300), "%10.2e",  " -0.00e+00", 0 },   
     131                { 1e300 * 1e300, "%10.5e",  "       inf", 0 },
     132                { -1.0 /(1e300 * 1e300), "%10.2e",  " -0.00e+00", 0 },
    133133                /* __PRINTF_FLAG_BIGCHARS */
    134134                { 1e300 * 1e300, "%10.5E",  "       INF", 0 },
    … …  
    151151                /* __PRINTF_FLAG_SPACESIGN | __PRINTF_FLAG_ZEROPADDED */
    152152                { 1e-1, "% 010.3f",  " 00000.100", 0 },
    153                 { 1e-1, "%10.3f",  "     0.100", 0 },   
     153                { 1e-1, "%10.3f",  "     0.100", 0 },
    154154
    155155                /* rounding */
    156156
    157                 { -0.0, "%10.0f",     "        -0", 0 },   
    158                 { -0.099, "%+10.3f",   "    -0.099", 0 }, 
    159                 { -0.0995, "%+10.3f",  "    -0.100", 0 }, 
    160                 { -0.0994, "%+10.3f",  "    -0.099", 0 }, 
    161                 { -99.995, "%+10.0f",  "      -100", 0 }, 
    162                 { 3.5, "%+10.30f",  "+3.500000000000000000000000000000", 0 }, 
    163                 { 3.5, "%+10.0f",      "        +4", 0 }, 
    164                 { 0.1, "%+10.6f",      " +0.100000", 0 }, 
     157                { -0.0, "%10.0f",     "        -0", 0 },
     158                { -0.099, "%+10.3f",   "    -0.099", 0 },
     159                { -0.0995, "%+10.3f",  "    -0.100", 0 },
     160                { -0.0994, "%+10.3f",  "    -0.099", 0 },
     161                { -99.995, "%+10.0f",  "      -100", 0 },
     162                { 3.5, "%+10.30f",  "+3.500000000000000000000000000000", 0 },
     163                { 3.5, "%+10.0f",      "        +4", 0 },
     164                { 0.1, "%+10.6f",      " +0.100000", 0 },
    165165
    166166                /*
    … …  
    168168                 * 0.09..917
    169169                 */
    170                 { 0.1, "%+10.20f",  "+0.10000000000000000550", 0 }, 
     170                { 0.1, "%+10.20f",  "+0.10000000000000000550", 0 },
    171171                /* Next closest to 0.1 */
    172172                { 0.0999999999999999917, "%+10.20f", "+0.09999999999999999170",
    173                     0 }, 
     173                    0 },
    174174                { 0.0999999999999999917, "%+10f",    " +0.100000", 0 },
    175175                { 0.0999999999999998945, "%10.20f",  "0.09999999999999989450",
    176                     0 },   
     176                    0 },
    177177        };
    178178

  • uspace/app/testread/testread.c

    rdf6ded8 r1b20da0  
    172172        uint32_t total_run_time = final_time.tv_sec - start_time.tv_sec;
    173173        if (total_run_time > 0) {
    174                 printf("total bytes: %" PRIuOFF64 
     174                printf("total bytes: %" PRIuOFF64
    175175                    ", total time: %u s, avg speed: %" PRIuOFF64 " B/s\n",
    176176                    offset,

  • uspace/app/tetris/tetris.c

    rdf6ded8 r1b20da0  
    174174}
    175175
    176 static void tetris_menu_draw(int level) 
     176static void tetris_menu_draw(int level)
    177177{
    178178        clear_screen();

  • uspace/app/trace/proto.c

    rdf6ded8 r1b20da0  
    173173        mo->oper = oper;
    174174
    175         hash_table_insert(&proto->method_oper, &mo->link);     
     175        hash_table_insert(&proto->method_oper, &mo->link);
    176176}
    177177

  • uspace/app/trace/trace.c

    rdf6ded8 r1b20da0  
    678678                V_INTEGER,
    679679                V_INTEGER,
    680                 V_INTEGER               
     680                V_INTEGER
    681681        };
    682682

  • uspace/app/vcalc/vcalc.c

    rdf6ded8 r1b20da0  
    576576        grid->add(grid, &btn_c->widget, 0, 4, 1, 1);
    577577        grid->add(grid, &btn_0->widget, 1, 4, 1, 1);
    578         grid->add(grid, &btn_eval->widget, 2, 4, 1, 1); 
     578        grid->add(grid, &btn_eval->widget, 2, 4, 1, 1);
    579579        grid->add(grid, &btn_div->widget, 3, 4, 1, 1);
    580580       
Note: See TracChangeset for help on using the changeset viewer.