import glob, os, sys
sys.path.append('..\\..')

from PyStand import Struct
uint8 = Struct.uint8
uint16 = Struct.uint16
uint32 = Struct.uint32
string = Struct.string

class OptimisticObj(object):
	class ImageFileHeader(Struct):
		__endian__ = Struct.LE
		def __format__(self):
			self.machine, self.numberOfSections = uint16[2]
			self.timestamp, self.symtab, self.numsyms = uint32[3]
			self.optHdrSize, self.characteristics = uint16[2]
	
	class ImageSectionHeader(Struct):
		__endian__ = Struct.LE
		def __format__(self):
			self.Name = string(8, stripNulls=True)
			self.VirtualSize, self.VirtualAddress = uint32[2]
			self.SizeOfRawData, self.RawData = uint32[2]
			self.Relocations, self.Linenumbers = uint32[2]
			self.NumRelocations, self.NumLinenumbers = uint16[2]
			self.Characteristics = uint32
	
	class ImageSymbol(Struct):
		__endian__ = Struct.LE
		def __format__(self):
			self.name = uint32[2]
			self.value = uint32
			self.section = uint16
			self.type = uint16
			self.storageClass = uint8
			self.numAuxSym = uint8
	
	def __init__(self, data):
		self.data = data
		imgheader = self.ImageFileHeader(data)
		pos = len(imgheader)
		
		sections = [None]
		sectheader = self.ImageSectionHeader()
		for i in xrange(imgheader.numberOfSections):
			sectheader.unpack(data, pos)
			sections.append(sectheader)
			pos += len(sectheader)
		
		imgsym = self.ImageSymbol()
		pos = imgheader.symtab
		
		symbols = []
		
		for i in xrange(imgheader.numsyms):
			try:
				imgsym.unpack(data, pos)
			except:
				break
			
			if imgsym.name[0] != 0:
				name = data[pos:pos+8].rstrip('\0')
			else:
				temp = imgheader.symtab + (len(imgsym) * imgheader.numsyms) + imgsym.name[1]
				name = data[temp:].split('\0', 1)[0]
			pos += len(imgsym)
			
			if imgsym.storageClass == 2 and imgsym.type == 0x20 and imgsym.section != 0:
				if imgsym.value != 0:
					self.generateSignature(name, imgsym.value, imgsym.section)
				
			pos += 18 * imgsym.numAuxSym
	
	def generateSignature(self, name, offset, section):
		section = self.sections[section]
		print name

class Optimistic(object):
	class AR_MemberHeader(Struct):
		__endian__ = Struct.LE
		def __format__(self):
			self.name = string(16)
			self.date = string(12)
			self.userID = string(6)
			self.groupID = string(6)
			self.mode = string(8)
			self.size = string(10)
			self.endHeader = string(2)
			self.data = string(0)
	
	def __init__(self, path):
		for fn in glob.glob(path + '\\*.lib'):
			self.splitLib(fn)
	
	def splitLib(self, fn):
		fp = file(fn, 'rb')
		assert fp.read(8) == '!<arch>\n'
		
		print fn
		while True:
			member = self.readMember(fp)
			if not member:
				break
			
			if member.data[:2] == '\x4C\x01':
				OptimisticObj(member.data)
	
	def readMember(self, fp):
		member = self.AR_MemberHeader()
		try:
			member.unpack(fp.read(len(member)))
		except:
			return None
		assert member.endHeader == '`\n'
		member.data = fp.read(int(member.size))
		if fp.tell() & 1:
			fp.read(1)
		
		return member

if __name__=='__main__':
	Optimistic(*sys.argv[1:])