Changeset 0516fd7 in mainline


Ignore:
Timestamp:
2008-08-09T23:46:00Z (16 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8f2a852
Parents:
838e14e2
Message:

structure objects: variable names, comments

Location:
tools
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • tools/mkhord.py

    r838e14e2 r0516fd7  
    3333import sys
    3434import os
    35 import struct
    3635import xstruct
    3736
    38 HEADER = xstruct.convert("little: "
    39         "char[4]   /* 'HORD' */ "
    40         "uint8_t   /* version */ "
    41         "uint8_t   /* encoding */ "
    42         "uint32_t  /* header size */ "
    43         "uint64_t  /* payload size */ "
    44 )
     37HEADER = """little:
     38        char[4] tag            /* 'HORD' */
     39        uint8_t version        /* version */
     40        uint8_t encoding       /* encoding */
     41        uint32_t header_size   /* header size */
     42        uint64_t payload_size  /* payload size */
     43"""
    4544
    46 HORD_VERSION = 1
    4745HORD_LSB = 1
    4846
    … …  
    7775        outf = file(sys.argv[3], "wb")
    7876       
    79         header_size = struct.calcsize(HEADER)
     77        header = xstruct.create(HEADER)
     78       
     79        header_size = header.size()
    8080        payload_size = os.path.getsize(fs_image)
    8181       
    … …  
    8383        payload_size_aligned = align_up(payload_size, align)
    8484       
    85         outf.write(struct.pack(HEADER, "HORD", HORD_VERSION, HORD_LSB, header_size_aligned, payload_size_aligned))
    86         outf.write(xstruct.little_padding(header_size_aligned - header_size))
     85        header.tag = "HORD"
     86        header.version = 1
     87        header.encoding = HORD_LSB
     88        header.header_size = header_size_aligned
     89        header.payload_size = payload_size_aligned
     90       
     91        outf.write(header.pack())
     92        outf.write(xstruct.create("little: padding[%d]" % (header_size_aligned - header_size)).pack())
    8793       
    8894        outf.write(inf.read())
    … …  
    9096        padding = payload_size_aligned - payload_size
    9197        if (padding > 0):
    92                 outf.write(xstruct.little_padding(padding))
     98                outf.write(xstruct.create("little: padding[%d]" % padding).pack())
    9399       
    94100        inf.close()

  • tools/mktmpfs.py

    r838e14e2 r0516fd7  
    3333import sys
    3434import os
    35 import struct
    3635import xstruct
    3736
    38 HEADER = xstruct.convert("little: "
    39         "char[5]  /* 'TMPFS' */ "
    40 )
     37HEADER = """little:
     38        char[5] tag  /* 'TMPFS' */
     39"""
    4140
    42 DENTRY = xstruct.convert("little: "
    43         "uint8_t   /* NONE, FILE or DIRECTORY */ "
    44         "uint32_t  /* filename length */ "
    45 )
     41DENTRY_NONE = """little:
     42        uint8_t kind        /* NONE */
     43        uint32_t fname_len  /* 0 */
     44"""
    4645
    47 SIZE = xstruct.convert("little: "
    48         "uint32_t  /* file size */ "
    49 )
     46DENTRY_FILE = """little:
     47        uint8_t kind        /* FILE */
     48        uint32_t fname_len  /* filename length */
     49        char[%d] fname      /* filename */
     50        uint32_t flen       /* file length */
     51"""
    5052
    51 DENTRY_NONE = 0
    52 DENTRY_FILE = 1
    53 DENTRY_DIRECTORY = 2
     53DENTRY_DIRECTORY = """little:
     54        uint8_t kind        /* DIRECTORY */
     55        uint32_t fname_len  /* filename length */
     56        char[%d] fname      /* filename */
     57"""
     58
     59TMPFS_NONE = 0
     60TMPFS_FILE = 1
     61TMPFS_DIRECTORY = 2
    5462
    5563def usage(prname):
    … …  
    6472               
    6573                if (os.path.isfile(canon)):
    66                         outf.write(struct.pack(DENTRY, DENTRY_FILE, len(name)))
    67                         outf.write(xstruct.little_string(name))
    6874                        size = os.path.getsize(canon)
    69                         rd = 0;
    70                         outf.write(struct.pack(SIZE, size))
     75                       
     76                        dentry = xstruct.create(DENTRY_FILE % len(name))
     77                        dentry.kind = TMPFS_FILE
     78                        dentry.fname_len = len(name)
     79                        dentry.fname = name
     80                        dentry.flen = size
     81                       
     82                        outf.write(dentry.pack())
    7183                       
    7284                        inf = file(canon, "r")
     85                        rd = 0;
    7386                        while (rd < size):
    7487                                data = inf.read(4096);
    … …  
    7891               
    7992                if (os.path.isdir(canon)):
    80                         outf.write(struct.pack(DENTRY, DENTRY_DIRECTORY, len(name)))
    81                         outf.write(xstruct.little_string(name))
     93                        dentry = xstruct.create(DENTRY_DIRECTORY % len(name))
     94                        dentry.kind = TMPFS_DIRECTORY
     95                        dentry.fname_len = len(name)
     96                        dentry.fname = name
     97                       
     98                        outf.write(dentry.pack())
     99                       
    82100                        recursion(canon, outf)
    83                         outf.write(struct.pack(DENTRY, DENTRY_NONE, 0))
     101                       
     102                        dentry = xstruct.create(DENTRY_NONE)
     103                        dentry.kind = TMPFS_NONE
     104                        dentry.fname_len = 0
     105                       
     106                        outf.write(dentry.pack())
    84107
    85108def main():
    … …  
    95118        outf = file(sys.argv[2], "w")
    96119       
    97         outf.write(struct.pack(HEADER, "TMPFS"))
     120        header = xstruct.create(HEADER)
     121        header.tag = "TMPFS"
     122       
     123        outf.write(header.pack())
     124       
    98125        recursion(path, outf)
    99         outf.write(struct.pack(DENTRY, DENTRY_NONE, 0))
    100 
     126       
     127        dentry = xstruct.create(DENTRY_NONE)
     128        dentry.kind = TMPFS_NONE
     129        dentry.fname_len = 0
     130       
     131        outf.write(dentry.pack())
     132       
    101133        outf.close()
    102                
     134       
    103135if __name__ == '__main__':
    104136        main()

  • tools/xstruct.py

    r838e14e2 r0516fd7  
    2727#
    2828"""
    29 Convert descriptive structure definitions to struct formats
     29Convert descriptive structure definitions to structure object
    3030"""
    3131
    3232import struct
    3333
    34 def convert(definition):
    35         "Convert structure defition to struct format"
     34class Struct:
     35        def size(self):
     36                return struct.calcsize(self._format_)
     37       
     38        def pack(self):
     39                list = []
     40                for variable in self._list_:
     41                        list.append(self.__dict__[variable])
     42               
     43                return struct.pack(self._format_, *list)
     44
     45def create(definition):
     46        "Create structure object"
    3647       
    3748        tokens = definition.split(None)
    3849       
    3950        # Initial byte order tag
    40         struct = {
     51        format = {
    4152                "little:":  lambda: "<",
    4253                "big:":     lambda: ">",
    4354                "network:": lambda: "!"
    4455        }[tokens[0]]()
     56        inst = Struct()
     57        list = []
    4558       
    4659        # Member tags
    47        
    4860        comment = False
     61        variable = False
    4962        for token in tokens[1:]:
    5063                if (comment):
    … …  
    5366                        continue
    5467               
     68                if (variable):
     69                        inst.__dict__[token] = None
     70                        list.append(token)
     71                        variable = False
     72                        continue
     73               
    5574                if (token == "/*"):
    5675                        comment = True
     76                elif (token[0:8] == "padding["):
     77                        size = token[8:].split("]")[0]
     78                        format += "%dx" % int(size)
    5779                elif (token[0:5] == "char["):
    5880                        size = token[5:].split("]")[0]
    59                         struct += ("%d" % int(size)) + "s"
     81                        format += "%ds" % int(size)
     82                        variable = True
    6083                else:
    61                         struct += {
     84                        format += {
    6285                                "uint8_t":  lambda: "B",
    6386                                "uint16_t": lambda: "H",
    … …  
    7093                                "int64_t":  lambda: "q"
    7194                        }[token]()
     95                        variable = True
    7296       
    73         return struct
    74 
    75 def little_string(string):
    76         return struct.pack("<" + ("%d" % len(string)) + "s", string)
    77 
    78 def little_padding(length):
    79         return struct.pack("<" + ("%d" % length) + "x")
     97        inst.__dict__['_format_'] = format
     98        inst.__dict__['_list_'] = list
     99        return inst
Note: See TracChangeset for help on using the changeset viewer.