Changeset a35b458 in mainline for tools/mkfat.py


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

  • tools/mkfat.py

    r3061bc1 ra35b458  
    4141def subtree_size(root, cluster_size, dirent_size):
    4242        "Recursive directory walk and calculate size"
    43        
     43
    4444        size = 0
    4545        files = 2
    46        
     46
    4747        for item in listdir_items(root):
    4848                if item.is_file:
    … …  
    5252                        size += subtree_size(item.path, cluster_size, dirent_size)
    5353                        files += 1
    54        
     54
    5555        return size + align_up(files * dirent_size, cluster_size)
    5656
    5757def root_entries(root):
    5858        "Return number of root directory entries"
    59        
     59
    6060        return len(os.listdir(root))
    6161
    6262def write_file(item, outf, cluster_size, data_start, fat, reserved_clusters):
    6363        "Store the contents of a file"
    64        
     64
    6565        prev = -1
    6666        first = 0
    67        
     67
    6868        for data in chunks(item, cluster_size):
    6969                empty_cluster = fat.index(0)
    7070                fat[empty_cluster] = 0xffff
    71                
     71
    7272                if (prev != -1):
    7373                        fat[prev] = empty_cluster
    7474                else:
    7575                        first = empty_cluster
    76                
     76
    7777                prev = empty_cluster
    78                
     78
    7979                outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)
    8080                outf.write(data)
    81        
     81
    8282        return first, item.size
    8383
    8484def write_directory(directory, outf, cluster_size, data_start, fat, reserved_clusters, dirent_size, empty_cluster):
    8585        "Store the contents of a directory"
    86        
     86
    8787        length = len(directory)
    8888        size = length * dirent_size
    8989        prev = -1
    9090        first = 0
    91        
     91
    9292        i = 0
    9393        rd = 0;
    … …  
    9999                else:
    100100                        first = empty_cluster
    101                
     101
    102102                prev = empty_cluster
    103                
     103
    104104                data = bytes()
    105105                data_len = 0
    … …  
    107107                        if (i == 0):
    108108                                directory[i].cluster = empty_cluster
    109                        
     109
    110110                        data += directory[i].pack()
    111111                        data_len += dirent_size
    112112                        i += 1
    113                
     113
    114114                outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)
    115115                outf.write(data)
    116116                rd += len(data)
    117        
     117
    118118        return first, size
    119119
    … …  
    188188def fat_lchars(name):
    189189        "Filter FAT legal characters"
    190        
     190
    191191        filtered_name = b''
    192192        filtered = False
    193        
     193
    194194        for char in name.encode('ascii', 'replace').upper():
    195195                if char in lchars:
    … …  
    198198                        filtered_name += b'_'
    199199                        filtered = True
    200        
     200
    201201        return (filtered_name, filtered)
    202202
    203203def fat_name83(name, name83_list):
    204204        "Create a 8.3 name for the given name"
    205        
     205
    206206        ascii_name, lfn = fat_lchars(name)
    207207        # Splitting works only on strings, not on bytes
    208208        ascii_parts = ascii_name.decode('utf8').split('.')
    209        
     209
    210210        short_name = ''
    211211        short_ext = ''
    212        
     212
    213213        if len(ascii_name) > 11:
    214214                lfn = True
    215        
     215
    216216        if len(ascii_parts) > 0:
    217217                short_name = ascii_parts[0]
    218218                if len(short_name) > 8:
    219219                        lfn = True
    220        
     220
    221221        if len(ascii_parts) > 1:
    222222                short_ext = ascii_parts[-1]
    223223                if len(short_ext) > 3:
    224224                        lfn = True
    225        
     225
    226226        if len(ascii_parts) > 2:
    227227                lfn = True
    228        
     228
    229229        if lfn == False:
    230230                name83_list.append(short_name + '.' + short_ext)
    231231                return (short_name.ljust(8)[0:8], short_ext.ljust(3)[0:3], False)
    232        
     232
    233233        # For filenames with multiple extensions, we treat the last one
    234234        # as the actual extension. The rest of the filename is stripped
    … …  
    236236        for part in ascii_parts[1:-1]:
    237237                short_name += part
    238        
     238
    239239        for number in range(1, 999999):
    240240                number_str = ('~' + str(number)).upper()
    241                
     241
    242242                if len(short_name) + len(number_str) > 8:
    243243                        short_name = short_name[0:8 - len(number_str)]
    244                
     244
    245245                short_name += number_str;
    246                
     246
    247247                if not (short_name + '.' + short_ext) in name83_list:
    248248                        break
    249        
     249
    250250        name83_list.append(short_name + '.' + short_ext)
    251251        return (short_name.ljust(8)[0:8], short_ext.ljust(3)[0:3], True)
    … …  
    253253def create_lfn_dirent(name, seq, checksum):
    254254        "Create LFN directory entry"
    255        
     255
    256256        entry = xstruct.create(LFN_DIR_ENTRY)
    257257        name_rest = name[26:]
    258        
     258
    259259        if len(name_rest) > 0:
    260260                entry.seq = seq
    261261        else:
    262262                entry.seq = seq | 0x40
    263        
     263
    264264        entry.name1 = name[0:10]
    265265        entry.name2 = name[10:22]
    266266        entry.name3 = name[22:26]
    267        
     267
    268268        entry.attr = 0x0F
    269269        entry.rec_type = 0
    270270        entry.checksum = checksum
    271271        entry.cluster = 0
    272        
     272
    273273        return (entry, name_rest)
    274274
    275275def lfn_checksum(name):
    276276        "Calculate LFN checksum"
    277        
     277
    278278        checksum = 0
    279279        for i in range(0, 11):
    280280                checksum = (((checksum & 1) << 7) + (checksum >> 1) + ord(name[i])) & 0xFF
    281        
     281
    282282        return checksum
    283283
    284284def create_dirent(name, name83_list, directory, cluster, size):
    285285        short_name, short_ext, lfn = fat_name83(name, name83_list)
    286        
     286
    287287        dir_entry = xstruct.create(DIR_ENTRY)
    288        
     288
    289289        dir_entry.name = short_name
    290290        dir_entry.ext = short_ext
    291        
     291
    292292        if (directory):
    293293                dir_entry.attr = 0x30
    294294        else:
    295295                dir_entry.attr = 0x20
    296        
     296
    297297        dir_entry.lcase = 0x18
    298298        dir_entry.ctime_fine = 0 # FIXME
    … …  
    303303        dir_entry.mdate = 0 # FIXME
    304304        dir_entry.cluster = cluster
    305        
     305
    306306        if (directory):
    307307                dir_entry.size = 0
    308308        else:
    309309                dir_entry.size = size
    310        
     310
    311311        if not lfn:
    312312                return [dir_entry]
    313        
     313
    314314        long_name = name.encode('utf_16_le')
    315315        entries = [dir_entry]
    316        
     316
    317317        seq = 1
    318318        checksum = lfn_checksum(dir_entry.name + dir_entry.ext)
    319        
     319
    320320        while len(long_name) > 0:
    321321                long_entry, long_name = create_lfn_dirent(long_name, seq, checksum)
    322322                entries.append(long_entry)
    323323                seq += 1
    324        
     324
    325325        entries.reverse()
    326326        return entries
    … …  
    328328def create_dot_dirent(empty_cluster):
    329329        dir_entry = xstruct.create(DOT_DIR_ENTRY)
    330        
     330
    331331        dir_entry.signature = 0x2e
    332332        dir_entry.name = b'       '
    333333        dir_entry.ext = b'   '
    334334        dir_entry.attr = 0x10
    335        
     335
    336336        dir_entry.ctime_fine = 0 # FIXME
    337337        dir_entry.ctime = 0 # FIXME
    … …  
    342342        dir_entry.cluster = empty_cluster
    343343        dir_entry.size = 0
    344        
     344
    345345        return dir_entry
    346346
    347347def create_dotdot_dirent(parent_cluster):
    348348        dir_entry = xstruct.create(DOTDOT_DIR_ENTRY)
    349        
     349
    350350        dir_entry.signature = [0x2e, 0x2e]
    351351        dir_entry.name = b'      '
    352352        dir_entry.ext = b'   '
    353353        dir_entry.attr = 0x10
    354        
     354
    355355        dir_entry.ctime_fine = 0 # FIXME
    356356        dir_entry.ctime = 0 # FIXME
    … …  
    361361        dir_entry.cluster = parent_cluster
    362362        dir_entry.size = 0
    363        
     363
    364364        return dir_entry
    365365
    366366def recursion(head, root, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, parent_cluster):
    367367        "Recursive directory walk"
    368        
     368
    369369        directory = []
    370370        name83_list = []
    371        
     371
    372372        if not head:
    373373                # Directory cluster preallocation
    374374                empty_cluster = fat.index(0)
    375375                fat[empty_cluster] = 0xFFFF
    376                
     376
    377377                directory.append(create_dot_dirent(empty_cluster))
    378378                directory.append(create_dotdot_dirent(parent_cluster))
    379379        else:
    380380                empty_cluster = 0
    381        
     381
    382382        for item in listdir_items(root):
    383383                if item.is_file:
    … …  
    387387                        rv = recursion(False, item.path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
    388388                        directory.extend(create_dirent(item.name, name83_list, True, rv[0], rv[1]))
    389        
     389
    390390        if head:
    391391                outf.seek(root_start)
    … …  
    410410        uint32_t hidden            /* hidden sectors */
    411411        uint32_t sectors_big       /* total number of sectors (if sectors == 0) */
    412        
     412
    413413        /* Extended BIOS Parameter Block */
    414414        uint8_t drive              /* physical drive number */
    … …  
    438438                usage(sys.argv[0])
    439439                return
    440        
     440
    441441        if (not sys.argv[1].isdigit()):
    442442                print("<EXTRA_BYTES> must be a number")
    443443                return
    444        
     444
    445445        extra_bytes = int(sys.argv[1])
    446        
     446
    447447        path = os.path.abspath(sys.argv[2])
    448448        if (not os.path.isdir(path)):
    449449                print("<PATH> must be a directory")
    450450                return
    451        
     451
    452452        fat16_clusters = 4096
    453        
     453
    454454        sector_size = 512
    455455        cluster_size = 4096
    … …  
    458458        fat_count = 2
    459459        reserved_clusters = 2
    460        
     460
    461461        # Make sure the filesystem is large enough for FAT16
    462462        size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size + extra_bytes
    … …  
    467467                else:
    468468                        size = fat16_clusters * cluster_size + reserved_clusters * cluster_size
    469        
     469
    470470        root_size = align_up(root_entries(path) * dirent_size, cluster_size)
    471        
     471
    472472        fat_size = align_up(align_up(size, cluster_size) // cluster_size * fatent_size, sector_size)
    473        
     473
    474474        sectors = (cluster_size + fat_count * fat_size + root_size + size) // sector_size
    475475        root_start = cluster_size + fat_count * fat_size
    476476        data_start = root_start + root_size
    477        
     477
    478478        outf = open(sys.argv[3], "wb")
    479        
     479
    480480        boot_sector = xstruct.create(BOOT_SECTOR)
    481481        boot_sector.jmp = [0xEB, 0x3C, 0x90]
    … …  
    499499        else:
    500500                boot_sector.sectors_big = 0
    501        
     501
    502502        boot_sector.drive = 0x80
    503503        boot_sector.extboot_signature = 0x29
    … …  
    506506        boot_sector.fstype = b'FAT16   '
    507507        boot_sector.boot_signature = [0x55, 0xAA]
    508        
     508
    509509        outf.write(boot_sector.pack())
    510        
     510
    511511        empty_sector = xstruct.create(EMPTY_SECTOR)
    512        
     512
    513513        # Reserved sectors
    514514        for i in range(1, cluster_size // sector_size):
    515515                outf.write(empty_sector.pack())
    516        
     516
    517517        # FAT tables
    518518        for i in range(0, fat_count):
    519519                for j in range(0, fat_size // sector_size):
    520520                        outf.write(empty_sector.pack())
    521        
     521
    522522        # Root directory
    523523        for i in range(0, root_size // sector_size):
    524524                outf.write(empty_sector.pack())
    525        
     525
    526526        # Data
    527527        for i in range(0, size // sector_size):
    528528                outf.write(empty_sector.pack())
    529        
     529
    530530        fat = array.array('L', [0] * (fat_size // fatent_size))
    531531        fat[0] = 0xfff8
    532532        fat[1] = 0xffff
    533        
     533
    534534        recursion(True, path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, 0)
    535        
     535
    536536        # Store FAT
    537537        fat_entry = xstruct.create(FAT_ENTRY)
    … …  
    541541                        fat_entry.next = fat[j]
    542542                        outf.write(fat_entry.pack())
    543        
     543
    544544        outf.close()
    545545
Note: See TracChangeset for help on using the changeset viewer.