Changeset 8565a42 in mainline for tools/mkfat.py


Ignore:
Timestamp:
2018-03-02T20:34:50Z (7 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.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • tools/mkfat.py

    r3061bc1 r8565a42  
    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.