From 6054311dacd847239162a6f3ba87f085defddcad Mon Sep 17 00:00:00 2001
From: megazig <megazig@megazig-desktop.(none)>
Date: Tue, 21 Apr 2009 01:47:51 -0500
Subject: somestuff added

---
 creditcards/Struct.py  | 282 +++++++++++++++++++++++++++++
 creditcards/Struct.pyc | Bin 0 -> 8217 bytes
 creditcards/pywii.py   | 473 +++++++++++++++++++++++++++++++++++++++++++++++++
 creditcards/pywii.pyc  | Bin 0 -> 22692 bytes
 4 files changed, 755 insertions(+)
 create mode 100644 creditcards/Struct.py
 create mode 100644 creditcards/Struct.pyc
 create mode 100644 creditcards/pywii.py
 create mode 100644 creditcards/pywii.pyc

diff --git a/creditcards/Struct.py b/creditcards/Struct.py
new file mode 100644
index 0000000..b9ef147
--- /dev/null
+++ b/creditcards/Struct.py
@@ -0,0 +1,282 @@
+import struct, sys
+
+class StructType(tuple):
+	def __getitem__(self, value):
+		return [self] * value
+	def __call__(self, value, endian='<'):
+		if isinstance(value, str):
+			return struct.unpack(endian + tuple.__getitem__(self, 0), value[:tuple.__getitem__(self, 1)])[0]
+		else:
+			return struct.pack(endian + tuple.__getitem__(self, 0), value)
+
+class StructException(Exception):
+	pass
+
+class Struct(object):
+	__slots__ = ('__attrs__', '__baked__', '__defs__', '__endian__', '__next__', '__sizes__', '__values__')
+	int8 = StructType(('b', 1))
+	uint8 = StructType(('B', 1))
+	
+	int16 = StructType(('h', 2))
+	uint16 = StructType(('H', 2))
+	
+	int32 = StructType(('l', 4))
+	uint32 = StructType(('L', 4))
+	
+	int64 = StructType(('q', 8))
+	uint64 = StructType(('Q', 8))
+	
+	float = StructType(('f', 4))
+
+	@classmethod
+	def string(cls, len, offset=0, encoding=None, stripNulls=False, value=''):
+		return StructType(('string', (len, offset, encoding, stripNulls, value)))
+	
+	LE = '<'
+	BE = '>'
+	__endian__ = '<'
+	
+	def __init__(self, func=None, unpack=None, **kwargs):
+		self.__defs__ = []
+		self.__sizes__ = []
+		self.__attrs__ = []
+		self.__values__ = {}
+		self.__next__ = True
+		self.__baked__ = False
+		
+		if func == None:
+			self.__format__()
+		else:
+			sys.settrace(self.__trace__)
+			func()
+			for name in func.func_code.co_varnames:
+				value = self.__frame__.f_locals[name]
+				self.__setattr__(name, value)
+		
+		self.__baked__ = True
+		
+		if unpack != None:
+			if isinstance(unpack, tuple):
+				self.unpack(*unpack)
+			else:
+				self.unpack(unpack)
+		
+		if len(kwargs):
+			for name in kwargs:
+				self.__values__[name] = kwargs[name]
+	
+	def __trace__(self, frame, event, arg):
+		self.__frame__ = frame
+		sys.settrace(None)
+	
+	def __setattr__(self, name, value):
+		if name in self.__slots__:
+			return object.__setattr__(self, name, value)
+		
+		if self.__baked__ == False:
+			if not isinstance(value, list):
+				value = [value]
+				attrname = name
+			else:
+				attrname = '*' + name
+			
+			self.__values__[name] = None
+			
+			for sub in value:
+				if isinstance(sub, Struct):
+					sub = sub.__class__
+				try:
+					if issubclass(sub, Struct):
+						sub = ('struct', sub)
+				except TypeError:
+					pass
+				type_, size = tuple(sub)
+				if type_ == 'string':
+					self.__defs__.append(Struct.string)
+					self.__sizes__.append(size)
+					self.__attrs__.append(attrname)
+					self.__next__ = True
+					
+					if attrname[0] != '*':
+						self.__values__[name] = size[3]
+					elif self.__values__[name] == None:
+						self.__values__[name] = [size[3] for val in value]
+				elif type_ == 'struct':
+					self.__defs__.append(Struct)
+					self.__sizes__.append(size)
+					self.__attrs__.append(attrname)
+					self.__next__ = True
+					
+					if attrname[0] != '*':
+						self.__values__[name] = size()
+					elif self.__values__[name] == None:
+						self.__values__[name] = [size() for val in value]
+				else:
+					if self.__next__:
+						self.__defs__.append('')
+						self.__sizes__.append(0)
+						self.__attrs__.append([])
+						self.__next__ = False
+					
+					self.__defs__[-1] += type_
+					self.__sizes__[-1] += size
+					self.__attrs__[-1].append(attrname)
+					
+					if attrname[0] != '*':
+						self.__values__[name] = 0
+					elif self.__values__[name] == None:
+						self.__values__[name] = [0 for val in value]
+		else:
+			try:
+				self.__values__[name] = value
+			except KeyError:
+				raise AttributeError(name)
+	
+	def __getattr__(self, name):
+		if self.__baked__ == False:
+			return name
+		else:
+			try:
+				return self.__values__[name]
+			except KeyError:
+				raise AttributeError(name)
+	
+	def __len__(self):
+		ret = 0
+		arraypos, arrayname = None, None
+		
+		for i in range(len(self.__defs__)):
+			sdef, size, attrs = self.__defs__[i], self.__sizes__[i], self.__attrs__[i]
+			
+			if sdef == Struct.string:
+				size, offset, encoding, stripNulls, value = size
+				if isinstance(size, str):
+					size = self.__values__[size] + offset
+			elif sdef == Struct:
+				if attrs[0] == '*':
+					if arrayname != attrs:
+						arrayname = attrs
+						arraypos = 0
+					size = len(self.__values__[attrs[1:]][arraypos])
+				size = len(self.__values__[attrs])
+			
+			ret += size
+		
+		return ret
+	
+	def unpack(self, data, pos=0):
+		for name in self.__values__:
+			if not isinstance(self.__values__[name], Struct):
+				self.__values__[name] = None
+			elif self.__values__[name].__class__ == list and len(self.__values__[name]) != 0:
+				if not isinstance(self.__values__[name][0], Struct):
+					self.__values__[name] = None
+		
+		arraypos, arrayname = None, None
+		
+		for i in range(len(self.__defs__)):
+			sdef, size, attrs = self.__defs__[i], self.__sizes__[i], self.__attrs__[i]
+			
+			if sdef == Struct.string:
+				size, offset, encoding, stripNulls, value = size
+				if isinstance(size, str):
+					size = self.__values__[size] + offset
+				
+				temp = data[pos:pos+size]
+				if len(temp) != size:
+					raise StructException('Expected %i byte string, got %i' % (size, len(temp)))
+				
+				if encoding != None:
+					temp = temp.decode(encoding)
+				
+				if stripNulls:
+					temp = temp.rstrip('\0')
+				
+				if attrs[0] == '*':
+					name = attrs[1:]
+					if self.__values__[name] == None:
+						self.__values__[name] = []
+					self.__values__[name].append(temp)
+				else:
+					self.__values__[attrs] = temp
+				pos += size
+			elif sdef == Struct:
+				if attrs[0] == '*':
+					if arrayname != attrs:
+						arrayname = attrs
+						arraypos = 0
+					name = attrs[1:]
+					self.__values__[attrs][arraypos].unpack(data, pos)
+					pos += len(self.__values__[attrs][arraypos])
+					arraypos += 1
+				else:
+					self.__values__[attrs].unpack(data, pos)
+					pos += len(self.__values__[attrs])
+			else:
+				values = struct.unpack(self.__endian__+sdef, data[pos:pos+size])
+				pos += size
+				j = 0
+				for name in attrs:
+					if name[0] == '*':
+						name = name[1:]
+						if self.__values__[name] == None:
+							self.__values__[name] = []
+						self.__values__[name].append(values[j])
+					else:
+						self.__values__[name] = values[j]
+					j += 1
+		
+		return self
+	
+	def pack(self):
+		arraypos, arrayname = None, None
+		
+		ret = ''
+		for i in range(len(self.__defs__)):
+			sdef, size, attrs = self.__defs__[i], self.__sizes__[i], self.__attrs__[i]
+			
+			if sdef == Struct.string:
+				size, offset, encoding, stripNulls, value = size
+				if isinstance(size, str):
+					size = self.__values__[size]+offset
+				
+				if attrs[0] == '*':
+					if arrayname != attrs:
+						arraypos = 0
+						arrayname = attrs
+					temp = self.__values__[attrs[1:]][arraypos]
+					arraypos += 1
+				else:
+					temp = self.__values__[attrs]
+				
+				if encoding != None:
+					temp = temp.encode(encoding)
+				
+				temp = temp[:size]
+				ret += temp + ('\0' * (size - len(temp)))
+			elif sdef == Struct:
+				if attrs[0] == '*':
+					if arrayname != attrs:
+						arraypos = 0
+						arrayname = attrs
+					ret += self.__values__[attrs[1:]][arraypos].pack()
+					arraypos += 1
+				else:
+					ret += self.__values__[attrs].pack()
+			else:
+				values = []
+				for name in attrs:
+					if name[0] == '*':
+						if arrayname != name:
+							arraypos = 0
+							arrayname = name
+						values.append(self.__values__[name[1:]][arraypos])
+						arraypos += 1
+					else:
+						values.append(self.__values__[name])
+				
+				ret += struct.pack(self.__endian__+sdef, *values)
+		return ret
+	
+	def __getitem__(self, value):
+		return [('struct', self.__class__)] * value
diff --git a/creditcards/Struct.pyc b/creditcards/Struct.pyc
new file mode 100644
index 0000000..255f861
Binary files /dev/null and b/creditcards/Struct.pyc differ
diff --git a/creditcards/pywii.py b/creditcards/pywii.py
new file mode 100644
index 0000000..40c0fcf
--- /dev/null
+++ b/creditcards/pywii.py
@@ -0,0 +1,473 @@
+#!/usr/bin/python
+
+from struct import unpack, pack
+
+import os, os.path
+import sys
+import string
+
+fun_dict = {}
+buf_dict = {}
+ctrl_dict = {}
+io_dict = {}
+var_dict = {}
+
+def hexdump(s,sep=" "):
+        return sep.join(map(lambda x: "%02x"%ord(x),s))
+
+def ascii(s):
+        s2 = ""
+        for c in s:
+                if ord(c)<0x20 or ord(c)>0x7e:
+                        s2 += "."
+                else:
+                        s2 += c
+        return s2
+
+def pad(s,c,l):
+	if len(s)<l:
+		s += c * (l-len(s))
+	return s
+
+def chexdump(s):
+	for i in range(0,len(s),16):
+		print >>outf,  "%08x  %s  %s  |%s|"%(i,pad(hexdump(s[i:i+8],' ')," ",23),pad(hexdump(s[i+8:i+16],' ')," ",23),pad(ascii(s[i:i+16])," ",16))
+
+def chexdumpstr(s):
+	retval = ""
+	for i in range(0,len(s),16):
+		retval +=  "\n%08x  %s  %s  |%s|"%(i,pad(hexdump(s[i:i+8],' ')," ",23),pad(hexdump(s[i+8:i+16],' ')," ",23),pad(ascii(s[i:i+16])," ",16))
+	return retval
+
+def readpstring(f):
+	strlen = unpack("B", f.read(1))[0]
+	return f.read(strlen)
+
+def getpstring(d):
+	strlen = unpack("B", d[0])[0]
+#	print >>outf,  "strlen = ",strlen
+	return d[1:(strlen+1)]
+	
+class TResourceItem:
+	def __init__(self, data):
+#		chexdump(data[0:8])
+		(self.posn, self.size) = unpack("<II", data[0:8])
+		self.name = getpstring(data[8:])
+		print >>outf,  "TResourceItem(posn=0x%x,size=0x%x,name='%s')" % (self.posn, self.size, self.name)
+
+	def __str__(self):
+		return "TResourceItem(posn=0x%x,size=0x%x,name='%s')" % (self.posn, self.size, self.name)
+	
+	def get_item(self, f):
+		f.seek(self.posn)
+		return f.read(self.size)
+
+
+class TResourceCollection:
+	def __init__(self, data):
+		self.data = data
+	
+	def get_resources(self):
+		num_resources, num2, num3 = unpack("<III", self.data[22:34])
+		print >>outf,  "TResourceCollection(%d,%x,%x)" % (num_resources, num2, num3)
+		retval = []
+		ptr = 34
+#		chexdump(self.data[ptr:])
+		for i in range(num_resources):
+			item = TResourceItem(self.data[ptr:])
+			ptr += len(item.name)+9
+			retval.append(item)
+		
+		return retval
+
+class TMemDev:
+	def __init__(self, data):
+		self.data = data[8:]
+		self.famcode, self.pinmap, self.a, self.b = unpack("<HHHH", data[0:8])
+		
+	def __str__(self):
+		return "TMemDev: famcode=%04x pinmap=%04x %04x %04x %s" %(self.famcode, self.pinmap, self.a, self.b, hexdump(self.data))
+
+class TLogDev:
+	def __init__(self, data):
+		self.data = data[8:]
+		self.famcode, self.pinmap, self.a, self.b = unpack("<HHHH", data[0:8])
+
+	def __str__(self):
+		return "TLogDev: famcode=%04x pinmap=%04x %04x %04x %s" %(self.famcode, self.pinmap, self.a, self.b, hexdump(self.data))
+
+class TPofFuseDev:
+	def __init__(self, data):
+		self.data = data[8:]
+		self.famcode, self.pinmap, self.a, self.b = unpack("<HHHH", data[0:8])
+
+	def __str__(self):
+		return "TPofFuseDev: famcode=%04x pinmap=%04x %04x %04x %s" %(self.famcode, self.pinmap, self.a, self.b, hexdump(self.data))
+
+class TPofDev:
+	def __init__(self, data):
+		self.data = data[8:]
+		self.famcode, self.pinmap, self.a, self.b = unpack("<HHHH", data[0:8])
+
+	def __str__(self):
+		return "TPofDev: famcode=%04x pinmap=%04x %04x %04x %s" %(self.famcode, self.pinmap, self.a, self.b, hexdump(self.data))
+
+class TXPMemDev:
+	def __init__(self, data):
+		self.data = data[11:]
+		self.famcode, self.pinmap, self.a, self.b, self.size = unpack("<HHHBI", data[0:11])
+		
+	def __str__(self):
+		return "TXPMemDev: famcode=%04x pinmap=%04x %04x %02x %08x %s" %(self.famcode, self.pinmap, self.a, self.b, self.size, hexdump(self.data))
+
+class TXilinxMemDev:
+	def __init__(self, data):
+		self.data = data[8:]
+		self.famcode, self.pinmap, self.a, self.b = unpack("<HHHH", data[0:8])
+
+	def __str__(self):
+		return "TXilinxMemDev: famcode=%04x pinmap=%04x %04x %04x %s" %(self.famcode, self.pinmap, self.a, self.b, hexdump(self.data))
+
+class TDblBufMemDev:
+	def __init__(self, data):
+		self.data = data[8:]
+		self.famcode, self.pinmap, self.a, self.b = unpack("<HHHH", data[0:8])
+
+	def __str__(self):
+		return "TDblBufMemDev: famcode=%04x pinmap=%04x %04x %04x %s" %(self.famcode, self.pinmap, self.a, self.b, hexdump(self.data))
+
+class TAddTabMemDev:
+	def __init__(self, data):
+		self.data = data[8:]
+		self.famcode, self.pinmap, self.a, self.b = unpack("<HHHH", data[0:8])
+
+	def __str__(self):
+		return "TAddTabMemDev: famcode=%04x pinmap=%04x %04x %04x %s" %(self.famcode, self.pinmap, self.a, self.b, hexdump(self.data))
+
+class TDNCol:
+	def __init__(self, data):
+		self.num_elements, self.x, self.y = unpack("<III", data[0:12])
+		self.elements = []
+		ptr = 12
+		for i in range(self.num_elements):
+			element = parse_item(data[ptr:])
+			self.elements.append(element)
+			ptr += len(element.name)+10
+
+	def __str__(self):
+		return "TDNCol: %d %d %d %s" % (self.num_elements, self.x, self.y, string.join(map(str,self.elements), ', '))
+
+class TDN:
+	def __init__(self, data):
+		self.name = getpstring(data)
+		self.id = unpack("<B", data[len(self.name)+1:len(self.name)+2])[0]
+#		print >>outf,  "TDN: %s %d" % (self.name, self.id)
+		if self.name[0:4] == '_BUF': buf_dict[self.id] = self.name
+		if self.name[0:4] == '_FUN': fun_dict[self.id] = self.name
+		if self.name[0:4] == '_CTR': ctrl_dict[self.id] = self.name
+		if self.name[0:4] == '_IO_': io_dict[self.id] = self.name
+		if self.name[0:4] == '_VAR': var_dict[self.id] = self.name
+		
+	def __str__(self):
+#		return "TDN: %s %d" % (self.name, self.id)
+#	
+#	def pretty(self):
+		return "[%s %x]\n" % (self.name, self.id)
+
+class TKernel:
+	def __init__(self, data):
+		self.data = data
+		
+#		chexdump(data)
+		
+	def __str__(self):
+		retval = "TKernel: "
+		data = self.data
+		while len(data) >= 4:
+			(id, wave) = unpack("<HH", data[0:4])
+			retval += "%04x %04x " % (id, wave)
+			retval += "\n"
+			data = data[4:]
+		return retval
+
+class TXilinxAddrData:
+	def __init__(self, data):
+		self.data = data
+#		chexdump(data)
+
+	def __str__(self):
+		return "TXilinxAddrData: " + chexdumpstr(self.data)
+
+class TFuseCode:
+	def __init__(self, data):
+		self.data = data
+#		chexdump(data)
+
+	def __str__(self):
+		return "TFuseCode: " + chexdumpstr(self.data)
+
+class TFamCode:
+	def __init__(self, data):
+		self.data = data
+#		chexdump(data)
+
+	def __str__(self):
+		retval = "TFamCode: %02x " % (ord(self.data[0]))
+		data = self.data[6:]
+		while len(data) >= 4:
+			(id, wave) = unpack("<HH", data[0:4])
+			retval += "%04x %04x " % (id, wave)
+			if id in fun_dict: retval += fun_dict[id]
+			retval += "\n"
+			data = data[4:]
+#		return "TFamCode: " + chexdumpstr(self.data)
+		return retval
+
+class TPinCode:
+	def __init__(self, data):
+		self.num_pins = ord(data[0])
+		self.data = data[1:]
+#		chexdump(data)
+
+	def __str__(self):
+		return "TPinCode: %d pins, %s" % (self.num_pins, chexdumpstr(self.data))
+
+class TPOFCoreCode:
+	def __init__(self, data):
+		self.data = data
+#		chexdump(data)
+
+	def __str__(self):
+		return "TPOFCoreCode: " + chexdumpstr(self.data)
+
+class TWaveCode:
+	def __init__(self, data):
+		self.data = data[4:]
+#		chexdump(data)
+		self.type = unpack("<I", data[0:4])[0]
+		if self.type == 6:
+			self.len1, self.addr, self.len2 = unpack("<HHH", data[4:10])
+			self.data = data[10:]
+			
+	def __str__(self):
+		if self.type == 6:
+			
+			return "TWaveCode: type = 6 (805x) len1 = %04x addr=%04x len2 = %04x data = %s" % (self.len1, self.addr, self.len2, chexdumpstr(self.data))
+#		if self.type == 4:
+#			return "TWaveCode: type = 4 (XC3030 bitstream) len = %d" % (self.len)
+		return "TWaveCode: type = %x data = %s" % (self.type, chexdumpstr(self.data))
+		
+class TVersion:
+	def __init__(self, data):
+#		chexdump(data)
+		self.version = unpack("<B", data[0])
+
+	def __str__(self):
+		return "TVersion: %d" % self.version
+
+class TVarName:
+	def __init__(self, data):
+		num_vars = unpack("<H", data[0:2])[0]
+		ptr = 2
+		self.vars = []
+		for i in range(num_vars):
+			element = getpstring(data[ptr:])
+#			print >>outf,  "var = " + element
+			self.vars.append(element)
+			ptr += len(element)+1
+#		chexdump(data)
+
+	def __str__(self):
+		return "TVarName: " + string.join(self.vars, ', ')
+
+def parse_item(data):
+	preamble = unpack(">H", data[0:2])[0]
+	if preamble != 0x25b:
+		print >>outf,  "Expected 0x25b for preamble, got"
+		chexdump(data[0:16])
+		exit()
+		
+	type_name = getpstring(data[2:])
+	body = data[3+len(type_name):-1]
+#	print >>outf,  "Type name = ", type_name
+	if type_name == "TMemDev": return TMemDev(body)
+	if type_name == "TLogDev": return TLogDev(body)
+	if type_name == "TPofDev": return TPofDev(body)
+	if type_name == "TPofFuseDev": return TPofFuseDev(body)
+	if type_name == "TXPMemDev": return TXPMemDev(body)
+	if type_name == "TXilinxMemDev": return TXilinxMemDev(body)
+	if type_name == "TXilinxAddrData": return TXilinxAddrData(body)
+	if type_name == "TDblBufMemDev": return TDblBufMemDev(body)
+	if type_name == "TAddTabMemDev": return TAddTabMemDev(body)
+	if type_name == "TDevPool": return TDevPool(body)
+	
+	if type_name == "TDNCol": return TDNCol(body)
+	if type_name == "TDN": return TDN(body)
+	if type_name == "TKernel": return TKernel(body)
+	if type_name == "TFamCode": return TFamCode(body)
+	if type_name == "TFuseCode": return TFuseCode(body)
+	if type_name == "TPOFCoreCode": return TPOFCoreCode(body)
+	if type_name == "TPinCode": return TPinCode(body)
+	if type_name == "TWaveCode": return TWaveCode(body)
+	if type_name == "TVersion": return TVersion(body)
+	if type_name == "TVarName": return TVarName(body)
+	print >>outf,  "Unknown type " + type_name
+	
+def print_data(indent, f):
+	data = f.read(2)
+	if len(data) != 2:
+		return False
+	preamble = unpack(">H", data)[0]
+	type_name = readpstring(f)
+	if preamble != 0x25b:
+		print >>outf,  indent, "preamble = %x" % (preamble)
+#	print >>outf,  type_name
+	if type_name == "TVendorCollection":
+		num1, num2, num3 = unpack("<III", f.read(12))
+		print >>outf,  indent, "%s(%d, %d, %d):" % (type_name, num1, num2, num3)
+
+		for i in range(num1):
+			print >>outf, _data(indent + "   ", f)
+		f.read(5)
+		return True
+	if type_name == "TVendor":
+		vendor_name = readpstring(f)
+		postamble = f.read(1)
+		print >>outf,  indent, "%s: %s" % (type_name, vendor_name)
+		return True
+	if type_name == "TDevPool":
+		num_devices, num2 = unpack("<HH", f.read(4))
+#		print >>outf,  indent, num_devices
+		devices = []
+		for i in range(num_devices):
+			devices.append([unpack("<H", f.read(2))[0]])
+#			print >>outf,  indent, "value: %x" % unpack("<H", f.read(2))
+#		print >>outf,  indent, "--"
+		for i in range(num_devices):
+			devices[i].append(unpack("<H", f.read(2))[0])
+		for i in range(num_devices):
+			devices[i].append(unpack("<H", f.read(2))[0])
+		for i in range(num_devices):
+			devices[i].append(unpack("<H", f.read(2))[0])
+		for i in range(num_devices):
+			devices[i].append(unpack("<H", f.read(2))[0])
+		for i in range(num_devices):
+			devices[i].append(unpack("<H", f.read(2))[0])
+		for i in range(num_devices):
+			devices[i].append(unpack("<H", f.read(2))[0])
+		for i in range(num_devices):
+			devices[i].append(unpack("<H", f.read(2))[0])
+		for i in range(num_devices):
+			devices[i].append(unpack("<H", f.read(2))[0])
+		for i in range(num_devices):
+			devices[i].append(unpack("<H", f.read(2))[0])
+		i = 0
+		for name in f.read(num2).split("\x00"):
+			if i < num_devices:
+				devices[i].append(name)
+				print >>outf,  type_name+": %04x %04x %04x %02x %04x %04x %02x %04x %02x %02x %s" % tuple(devices[i])
+				i = i + 1
+#		print >>outf,  chexdump(f.read(num2))
+		f.read(1)
+		return True
+	if type_name == "TResourceCollection":
+		num_resources, num2, num3 = unpack("<III", f.read(12))
+		print >>outf,  indent, num_resources
+		print >>outf,  indent, "%s(%d,%x,%x)" % (type_name, num_resources, num2, num3)
+		for i in range(num_resources):
+			posn, size = unpack("<II", f.read(8))
+			name = readpstring(f)
+			print >>outf,  indent, "%-20s posn=%8x size=%8x" % (name, posn, size)
+		f.read(5)
+		return True
+	if type_name == "TVersion":
+		print >>outf,  indent, "Version = %x" % (unpack("<B", f.read(1))[0])
+		f.read(2)
+		return True
+	if type_name == "TVarName":
+		num_vars = unpack("<H", f.read(2))[0]
+		for i in range(num_vars):
+			print >>outf,  "var = " + readpstring(f)
+		f.read(1)
+		return True
+	if type_name == "TWaveCode":
+		num1, codesize = unpack("<IH", f.read(6))
+		print >>outf,  indent, "WaveCode = type:%x len:%x" % (num1, codesize)
+		chexdump(f.read(codesize))
+		f.read(1)
+		return True
+	if type_name == "TPinCode":
+		size, foo, bar, baz, bazz, buzz = unpack("<BBHHHB", f.read(9))
+		print >>outf,  indent, "size = %x foo=%d bar=%d baz=%d bazz=%x buzz=%x" % (size, foo, bar, baz, bazz, buzz)
+#		for i in range(size+foo+bar*2+20):
+#			print >>outf,  indent, "%x" % unpack("<B", f.read(1))
+		buf = ""
+		while True:
+			char = f.read(1)
+			if char == ']': break
+			buf += char
+		chexdump(buf)
+#		f.read(2)
+		return True
+	if type_name == "TFamCode":
+		num1, codesize = unpack("<HH", f.read(4))
+		print >>outf,  indent, "FamCode = type:%x len:%x" % (num1, codesize)
+#		chexdump(f.read(num1*4+codesize*10+6))
+		buf = ""
+		while True:
+			char = f.read(1)
+			if char == ']' and len(buf) > 0x100: break
+			buf += char
+		chexdump(buf)
+		return True
+	if type_name == "TMemDev":
+		print >>outf,  indent, "MemDev:"
+		chexdump(f.read(17))
+		f.read(1)
+		return True
+	if type_name == "TKernel":
+		print >>outf,  indent, "Kernel:"
+		chexdump(f.read(240))
+		f.read(1)
+		return True
+	if type_name == "TDNCol":
+		num = unpack("<I", f.read(4))[0]
+		print >>outf,  indent, "DNCol: %d" % (num)
+		chexdump(f.read(7))
+		f.read(1)
+		for i in range(num):
+			print >>outf, _data(indent + "   ", f)
+		f.read(5)
+		return True
+	if type_name == "TDN":
+		name = readpstring(f)
+		num1 = unpack("<B", f.read(1))[0]
+		print >>outf,  indent, "DN: %s %x" % (name, num1)
+		
+#		chexdump(f.read(13))
+		f.read(2)
+#		print >>outf, _data(indent, f)
+		return True
+	
+	print >>outf,  "Unknown atom ", type_name
+	return False
+
+#f = open(sys.argv[1], "rb")
+outf = open(string.replace(sys.argv[1], "rez", "txt"), "w")
+#buf = f.read()
+
+#magic = f.read(4)
+#filesize, table_offset = unpack("<II",f.read(8))
+#chexdump(buf[0:256])
+
+#print >>outf,  "magic = '%s', file size = 0x%x, table offset = 0x%x" % (magic, filesize, table_offset)
+#f.seek(table_offset)
+#collection = TResourceCollection(f.read())
+#foo = collection.get_resources()
+#print >>outf,  foo
+
+#for item in foo:
+	#print >>outf,  item.name+": "+str(parse_item(item.get_item(f)))+"\n"
+	
+#while True:
+#	if not print_data("", f): break
diff --git a/creditcards/pywii.pyc b/creditcards/pywii.pyc
new file mode 100644
index 0000000..cb0f95e
Binary files /dev/null and b/creditcards/pywii.pyc differ
-- 
cgit v1.3.1