Fork us on GitHub Follow us on Facebook Follow us on Twitter

Ignore:
Timestamp:
2011-08-25T22:15:33Z (10 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
0dbe5ac
Parents:
abb7491c
Message:

Cstyle.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/exfat/exfat_directory.c

    rabb7491c rff0c270  
    7272        di->bs = block_bb_get(di->service_id);
    7373/*      di->blocks = nodep->size / BPS(di->bs); */
    74         di->blocks = ROUND_UP(nodep->size, BPS(di->bs))/BPS(di->bs);
     74        di->blocks = ROUND_UP(nodep->size, BPS(di->bs)) / BPS(di->bs);
    7575        return EOK;
    7676}
     
    9090int exfat_directory_close(exfat_directory_t *di)
    9191{
    92         int rc=EOK;
     92        int rc = EOK;
    9393       
    9494        if (di->b)
     
    113113        if (!di->b) {
    114114                if (di->nodep) {
    115                         rc = exfat_block_get(&di->b, di->bs, di->nodep, i, BLOCK_FLAGS_NONE);
     115                        rc = exfat_block_get(&di->b, di->bs, di->nodep, i,
     116                            BLOCK_FLAGS_NONE);
    116117                } else {
    117                         rc = exfat_block_get_by_clst(&di->b, di->bs, di->service_id,
    118                             di->fragmented, di->firstc, NULL, i, BLOCK_FLAGS_NONE);
     118                        rc = exfat_block_get_by_clst(&di->b, di->bs,
     119                            di->service_id, di->fragmented, di->firstc, NULL, i,
     120                            BLOCK_FLAGS_NONE);
    119121                }
    120122                if (rc != EOK) {
     
    133135        di->pos += 1;
    134136        rc = exfat_directory_block_load(di);
    135         if (rc!=EOK)
     137        if (rc != EOK)
    136138                di->pos -= 1;
    137139       
     
    141143int exfat_directory_prev(exfat_directory_t *di)
    142144{
    143         int rc=EOK;
     145        int rc = EOK;
    144146       
    145147        if (di->pos > 0) {
     
    163165        di->pos = pos;
    164166        rc = exfat_directory_block_load(di);
    165         if (rc!=EOK)
     167        if (rc != EOK)
    166168                di->pos = _pos;
    167169       
     
    182184}
    183185
    184 int exfat_directory_find(exfat_directory_t *di, exfat_dentry_clsf_t type, exfat_dentry_t **d)
     186int exfat_directory_find(exfat_directory_t *di, exfat_dentry_clsf_t type,
     187    exfat_dentry_t **d)
    185188{
    186189        do {
     
    195198}
    196199
    197 int exfat_directory_find_continue(exfat_directory_t *di, exfat_dentry_clsf_t type, exfat_dentry_t **d)
     200int
     201exfat_directory_find_continue(exfat_directory_t *di, exfat_dentry_clsf_t type,
     202    exfat_dentry_t **d)
    198203{
    199204        int rc;
     
    208213    exfat_file_dentry_t *df, exfat_stream_dentry_t *ds)
    209214{
    210         uint16_t wname[EXFAT_FILENAME_LEN+1];
     215        uint16_t wname[EXFAT_FILENAME_LEN + 1];
    211216        exfat_dentry_t *d = NULL;
    212217        int rc, i;
     
    233238                return EOVERFLOW;
    234239
    235         for (i=0; i<df->count-1; i++) {
     240        for (i = 0; i < df->count - 1; i++) {
    236241                rc = exfat_directory_next(di);
    237242                if (rc != EOK)
     
    269274{
    270275        int rc, i, count;
    271         exfat_dentry_t *array=NULL, *de;
     276        exfat_dentry_t *array = NULL, *de;
    272277        aoff64_t pos = di->pos;
    273278
     
    275280        if (rc != EOK)
    276281                return rc;
    277         count = de->file.count+1;
     282        count = de->file.count + 1;
    278283        array = (exfat_dentry_t *) malloc(count*sizeof(exfat_dentry_t));
    279284        if (!array)
    280285                return ENOMEM;
    281         for (i=0; i<count; i++) {
     286        for (i = 0; i < count; i++) {
    282287                rc = exfat_directory_get(di, &de);
    283288                if (rc != EOK)
     
    291296        }
    292297        rc = exfat_directory_seek(di, pos);
    293         if (rc!=EOK) {
     298        if (rc != EOK) {
    294299                free(array);
    295300                return rc;
     
    303308        array[1].stream.data_size = host2uint64_t_le(ds->data_size);
    304309        array[0].file.checksum = host2uint16_t_le(exfat_directory_set_checksum((uint8_t *)array,
    305             count*sizeof(exfat_dentry_t)));
     310            count * sizeof(exfat_dentry_t)));
    306311
    307312        /* Store */
    308         for (i=0; i<count; i++) {
     313        for (i = 0; i < count; i++) {
    309314                rc = exfat_directory_get(di, &de);
    310315                if (rc != EOK)
     
    313318                di->b->dirty = true;
    314319                rc = exfat_directory_next(di);
    315                 if (rc!=EOK) {
     320                if (rc != EOK) {
    316321                        free(array);
    317322                        return rc;
     
    329334        uint16_t *uctable;
    330335        exfat_dentry_t df, ds, *de;
    331         uint16_t wname[EXFAT_FILENAME_LEN+1];
     336        uint16_t wname[EXFAT_FILENAME_LEN + 1];
    332337        int rc, i;
    333338        size_t uctable_chars, j;
     
    399404        uint16_t *sname = wname;
    400405
    401         for (i=0; i<ds.stream.name_size; i++)
     406        for (i = 0; i < ds.stream.name_size; i++)
    402407                wname[i] = host2uint16_t_le(wname[i]);
    403408
    404         for (i=0; i < df.file.count-1; i++) {
     409        for (i = 0; i < df.file.count - 1; i++) {
    405410                rc = exfat_directory_next(di);
    406411                if (rc != EOK)
    407412                        return rc;
    408413
    409                 if (i == df.file.count-2)
    410                         chars = ds.stream.name_size - EXFAT_NAME_PART_LEN*(df.file.count-2);
     414                if (i == df.file.count - 2)
     415                        chars = ds.stream.name_size - EXFAT_NAME_PART_LEN*(df.file.count - 2);
    411416                rc = exfat_directory_get(di, &de);
    412417                if (rc != EOK)
     
    414419                de->type = EXFAT_TYPE_NAME;
    415420                /* test */
    416                 for (j=0; j<chars; j++){
     421                for (j = 0; j < chars; j++) {
    417422                        de->name.name[j] = *sname;
    418423                        sname++;
     
    434439        if (rc != EOK)
    435440                return rc;
    436         count = de->file.count+1;
     441        count = de->file.count + 1;
    437442       
    438443        while (count) {
     
    440445                if (rc != EOK)
    441446                        return rc;
    442                 de->type &= (~EXFAT_TYPE_USED);
     447                de->type &= ~EXFAT_TYPE_USED;
    443448                di->b->dirty = true;
    444449
    445450                rc = exfat_directory_next(di);
    446                 if (rc!=EOK)
     451                if (rc != EOK)
    447452                        return rc;
    448453                count--;
     
    489494                                case EXFAT_DENTRY_LAST:
    490495                                case EXFAT_DENTRY_FREE:
    491                                         if (found==0) pos = di->pos;
     496                                        if (found == 0)
     497                                                pos = di->pos;
    492498                                        found++;
    493499                                        if (found == count) {
Note: See TracChangeset for help on using the changeset viewer.