Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3262 → Rev 3261

/trunk/tools/xstruct.py
26,39 → 26,26
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
"""
Convert descriptive structure definitions to structure object
Convert descriptive structure definitions to struct formats
"""
 
import struct
 
class Struct:
def size(self):
return struct.calcsize(self._format_)
def convert(definition):
"Convert structure defition to struct format"
def pack(self):
list = []
for variable in self._list_:
list.append(self.__dict__[variable])
return struct.pack(self._format_, *list)
 
def create(definition):
"Create structure object"
tokens = definition.split(None)
# Initial byte order tag
format = {
struct = {
"little:": lambda: "<",
"big:": lambda: ">",
"network:": lambda: "!"
}[tokens[0]]()
inst = Struct()
list = []
# Member tags
comment = False
variable = False
for token in tokens[1:]:
if (comment):
if (token == "*/"):
65,23 → 52,13
comment = False
continue
if (variable):
inst.__dict__[token] = None
list.append(token)
variable = False
continue
if (token == "/*"):
comment = True
elif (token[0:8] == "padding["):
size = token[8:].split("]")[0]
format += "%dx" % int(size)
elif (token[0:5] == "char["):
size = token[5:].split("]")[0]
format += "%ds" % int(size)
variable = True
struct += ("%d" % int(size)) + "s"
else:
format += {
struct += {
"uint8_t": lambda: "B",
"uint16_t": lambda: "H",
"uint32_t": lambda: "L",
92,8 → 69,11
"int32_t": lambda: "l",
"int64_t": lambda: "q"
}[token]()
variable = True
inst.__dict__['_format_'] = format
inst.__dict__['_list_'] = list
return inst
return struct
 
def little_string(string):
return struct.pack("<" + ("%d" % len(string)) + "s", string)
 
def little_padding(length):
return struct.pack("<" + ("%d" % length) + "x")
/trunk/tools/mktmpfs.py
32,34 → 32,26
 
import sys
import os
import struct
import xstruct
 
HEADER = """little:
char[5] tag /* 'TMPFS' */
"""
HEADER = xstruct.convert("little: "
"char[5] /* 'TMPFS' */ "
)
 
DENTRY_NONE = """little:
uint8_t kind /* NONE */
uint32_t fname_len /* 0 */
"""
DENTRY = xstruct.convert("little: "
"uint8_t /* NONE, FILE or DIRECTORY */ "
"uint32_t /* filename length */ "
)
 
DENTRY_FILE = """little:
uint8_t kind /* FILE */
uint32_t fname_len /* filename length */
char[%d] fname /* filename */
uint32_t flen /* file length */
"""
SIZE = xstruct.convert("little: "
"uint32_t /* file size */ "
)
 
DENTRY_DIRECTORY = """little:
uint8_t kind /* DIRECTORY */
uint32_t fname_len /* filename length */
char[%d] fname /* filename */
"""
DENTRY_NONE = 0
DENTRY_FILE = 1
DENTRY_DIRECTORY = 2
 
TMPFS_NONE = 0
TMPFS_FILE = 1
TMPFS_DIRECTORY = 2
 
def usage(prname):
"Print usage syntax"
print prname + " <PATH> <IMAGE>"
71,18 → 63,13
canon = os.path.join(root, name)
if (os.path.isfile(canon)):
outf.write(struct.pack(DENTRY, DENTRY_FILE, len(name)))
outf.write(xstruct.little_string(name))
size = os.path.getsize(canon)
rd = 0;
outf.write(struct.pack(SIZE, size))
dentry = xstruct.create(DENTRY_FILE % len(name))
dentry.kind = TMPFS_FILE
dentry.fname_len = len(name)
dentry.fname = name
dentry.flen = size
outf.write(dentry.pack())
inf = file(canon, "r")
rd = 0;
while (rd < size):
data = inf.read(4096);
outf.write(data)
90,20 → 77,10
inf.close()
if (os.path.isdir(canon)):
dentry = xstruct.create(DENTRY_DIRECTORY % len(name))
dentry.kind = TMPFS_DIRECTORY
dentry.fname_len = len(name)
dentry.fname = name
outf.write(dentry.pack())
outf.write(struct.pack(DENTRY, DENTRY_DIRECTORY, len(name)))
outf.write(xstruct.little_string(name))
recursion(canon, outf)
dentry = xstruct.create(DENTRY_NONE)
dentry.kind = TMPFS_NONE
dentry.fname_len = 0
outf.write(dentry.pack())
outf.write(struct.pack(DENTRY, DENTRY_NONE, 0))
 
def main():
if (len(sys.argv) < 3):
117,20 → 94,11
outf = file(sys.argv[2], "w")
header = xstruct.create(HEADER)
header.tag = "TMPFS"
outf.write(header.pack())
outf.write(struct.pack(HEADER, "TMPFS"))
recursion(path, outf)
dentry = xstruct.create(DENTRY_NONE)
dentry.kind = TMPFS_NONE
dentry.fname_len = 0
outf.write(dentry.pack())
outf.write(struct.pack(DENTRY, DENTRY_NONE, 0))
 
outf.close()
if __name__ == '__main__':
main()
/trunk/tools/mkhord.py
32,16 → 32,18
 
import sys
import os
import struct
import xstruct
 
HEADER = """little:
char[4] tag /* 'HORD' */
uint8_t version /* version */
uint8_t encoding /* encoding */
uint32_t header_size /* header size */
uint64_t payload_size /* payload size */
"""
HEADER = xstruct.convert("little: "
"char[4] /* 'HORD' */ "
"uint8_t /* version */ "
"uint8_t /* encoding */ "
"uint32_t /* header size */ "
"uint64_t /* payload size */ "
)
 
HORD_VERSION = 1
HORD_LSB = 1
 
def align_up(size, alignment):
74,28 → 76,20
inf = file(fs_image, "rb")
outf = file(sys.argv[3], "wb")
header = xstruct.create(HEADER)
header_size = header.size()
header_size = struct.calcsize(HEADER)
payload_size = os.path.getsize(fs_image)
header_size_aligned = align_up(header_size, align)
payload_size_aligned = align_up(payload_size, align)
header.tag = "HORD"
header.version = 1
header.encoding = HORD_LSB
header.header_size = header_size_aligned
header.payload_size = payload_size_aligned
outf.write(struct.pack(HEADER, "HORD", HORD_VERSION, HORD_LSB, header_size_aligned, payload_size_aligned))
outf.write(xstruct.little_padding(header_size_aligned - header_size))
outf.write(header.pack())
outf.write(xstruct.create("little: padding[%d]" % (header_size_aligned - header_size)).pack())
outf.write(inf.read())
padding = payload_size_aligned - payload_size
if (padding > 0):
outf.write(xstruct.create("little: padding[%d]" % padding).pack())
outf.write(xstruct.little_padding(padding))
inf.close()
outf.close()