Changeset a35b458 in mainline for kernel/test/avltree


Ignore:
Timestamp:
2018-03-02T20:10:49Z (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:
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

  • kernel/test/avltree/avltree1.c

    r3061bc1 ra35b458  
    5656{
    5757        avltree_node_t *tmp;
    58        
     58
    5959        if (!node)
    6060                return NULL;
    61        
     61
    6262        if (node->lft) {
    6363                tmp = test_tree_parents(node->lft);
    … …  
    8181{
    8282        int h1, h2, diff;
    83        
     83
    8484        if (!node)
    8585                return 0;
    86        
     86
    8787        h1 = test_tree_balance(node->lft);
    8888        h2 = test_tree_balance(node->rgt);
    8989        diff = h2 - h1;
    90        
     90
    9191        if ((diff != node->balance) || ((diff != -1) && (diff != 0) && (diff != 1)))
    9292                TPRINTF("Bad balance\n");
    93        
     93
    9494        return ((h1 > h2) ? (h1 + 1) : (h2 + 1));
    9595}
    … …  
    110110                return;
    111111        }
    112        
     112
    113113        if (node == NULL)
    114114                return;
    115        
     115
    116116        TPRINTF("%" PRIu64 "[%" PRIu8 "]", node->key, node->balance);
    117117        if (node->lft != NULL || node->rgt != NULL) {
    118118                TPRINTF("(");
    119                
     119
    120120                print_tree_structure_flat(node->lft, level + 1);
    121121                if (node->rgt != NULL) {
    … …  
    123123                        print_tree_structure_flat(node->rgt, level + 1);
    124124                }
    125                
     125
    126126                TPRINTF(")");
    127127        }
    … …  
    131131{
    132132        int i;
    133        
     133
    134134        for (i = 0; i < NODE_COUNT - 1; i++)
    135135                avltree_nodes[i].par = &avltree_nodes[i + 1];
    136        
     136
    137137        avltree_nodes[i].par = NULL;
    138        
     138
    139139        /*
    140140         * Node keys which will be used for insertion. Up to NODE_COUNT size of
    141141         * array.
    142142         */
    143        
     143
    144144        /* First tree node and same key */
    145145        avltree_nodes[0].key = 60;
    146146        avltree_nodes[1].key = 60;
    147147        avltree_nodes[2].key = 60;
    148        
     148
    149149        /* LL rotation */
    150150        avltree_nodes[3].key = 50;
    151151        avltree_nodes[4].key = 40;
    152152        avltree_nodes[5].key = 30;
    153        
     153
    154154        /* LR rotation */
    155155        avltree_nodes[6].key = 20;
    … …  
    157157        avltree_nodes[8].key = 25;
    158158        avltree_nodes[9].key = 25;
    159        
     159
    160160        /* LL rotation in lower floor */
    161161        avltree_nodes[10].key = 35;
    162        
     162
    163163        /* RR rotation */
    164164        avltree_nodes[11].key = 70;
    165165        avltree_nodes[12].key = 80;
    166        
     166
    167167        /* RL rotation */
    168168        avltree_nodes[13].key = 90;
    169169        avltree_nodes[14].key = 85;
    170        
     170
    171171        /* Insert 0 key */
    172172        avltree_nodes[15].key = 0;
    173173        avltree_nodes[16].key = 0;
    174        
     174
    175175        /* Insert reverse */
    176176        avltree_nodes[17].key = 600;
    … …  
    178178        avltree_nodes[19].key = 400;
    179179        avltree_nodes[20].key = 300;
    180        
     180
    181181        for (i = 21; i < NODE_COUNT; i++)
    182182                avltree_nodes[i].key = i * 3;
    183        
     183
    184184        first_free_node = &avltree_nodes[0];
    185185}
    … …  
    188188{
    189189        avltree_node_t *node;
    190        
     190
    191191        node = first_free_node;
    192192        first_free_node = first_free_node->par;
    193        
     193
    194194        return node;
    195195}
    … …  
    199199        unsigned int i;
    200200        avltree_node_t *newnode;
    201        
     201
    202202        avltree_create(tree);
    203        
     203
    204204        TPRINTF("Inserting %zu nodes...", node_count);
    205        
     205
    206206        for (i = 0; i < node_count; i++) {
    207207                newnode = alloc_avltree_node();
    208                
     208
    209209                avltree_insert(tree, newnode);
    210210                test_tree_parents(tree->root);
    211211                test_tree_balance(tree->root);
    212212        }
    213        
     213
    214214        TPRINTF("done.\n");
    215215}
    … …  
    220220        avltree_node_t *delnode;
    221221        unsigned int i;
    222        
     222
    223223        switch (node_position) {
    224224        case 0:
    225225                TPRINTF("Deleting root nodes...");
    226                
     226
    227227                while (tree->root != NULL) {
    228228                        delnode = tree->root;
    … …  
    234234        case 1:
    235235                TPRINTF("Deleting nodes according to creation time...");
    236                
     236
    237237                for (i = 0; i < node_count; i++) {
    238238                        avltree_delete(tree, &avltree_nodes[i]);
    … …  
    242242                break;
    243243        }
    244        
     244
    245245        TPRINTF("done.\n");
    246246}
    … …  
    249249{
    250250        unsigned int i = 0;
    251        
     251
    252252        TPRINTF("Deleting minimum nodes...");
    253        
     253
    254254        while (tree->root != NULL) {
    255255                i++;
    … …  
    258258                test_tree_balance(tree->root);
    259259        }
    260        
     260
    261261        if (i != node_count)
    262262                TPRINTF("Bad node count. Some nodes have been lost!\n");
    263        
     263
    264264        TPRINTF("done.\n");
    265265}
    … …  
    270270        test_tree_insert(&avltree, NODE_COUNT);
    271271        test_tree_delete(&avltree, NODE_COUNT, 0);
    272        
     272
    273273        alloc_avltree_node_prepare();
    274274        test_tree_insert(&avltree, NODE_COUNT);
    275275        test_tree_delete(&avltree, NODE_COUNT, 1);
    276        
     276
    277277        alloc_avltree_node_prepare();
    278278        test_tree_insert(&avltree, NODE_COUNT);
    279279        test_tree_delmin(&avltree, NODE_COUNT);
    280        
     280
    281281        return NULL;
    282282}
Note: See TracChangeset for help on using the changeset viewer.