Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3261 → Rev 3262

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