kennethreitz-archive/pyinstaller
1
0
Fork 0
mirror of https://github.com/kennethreitz-archive/pyinstaller.git synced 2026-06-05 15:40:17 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
c7d287e5b560a34920bfdb1c196f6ba2f9af8455
pyinstaller/versionInfo.py
T
htgoebel c7d287e5b5 Reindenting python soucefiles. 
git-svn-id: http://svn.pyinstaller.org/trunk@485 8dd32b29-ccff-0310-8a9a-9233e24343b1
2008-07-23 19:04:41 +00:00

531 lines
20 KiB
Python
Raw Blame History

# Copyright (C) 2005, Giovanni Bajo
# Based on previous work under copyright (c) 2001, 2002 McMillan Enterprises, Inc.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
import win32api
import struct
import pywintypes
import string
import pprint
TEST=0
LOAD_LIBRARY_AS_DATAFILE = 2
RT_VERSION = 16
def getRaw0(o):
return o.raw
def getRaw1(o):
return str(buffer(o))
import sys
if hasattr(sys, "version_info"):
pyvers = sys.version_info[0]*10 + sys.version_info[1]
else:
toks = string.split(sys.version, '.', 2)
pyvers = int(toks[0])*10 + int(toks[1])
if pyvers < 20:
getRaw = getRaw0
else:
getRaw = getRaw1
##VS_VERSION_INFO {
## WORD wLength; // Specifies the length of the VS_VERSION_INFO structure
## WORD wValueLength; // Specifies the length of the Value member
## WORD wType; // 1 means text, 0 means binary
## WCHAR szKey[]; // Contains the Unicode string "VS_VERSION_INFO".
## WORD Padding1[];
## VS_FIXEDFILEINFO Value;
## WORD Padding2[];
## WORD Children[]; // Specifies a list of zero or more StringFileInfo or VarFileInfo structures (or both) that are children of the current version structure.
##};
def decode(pathnm):
h = win32api.LoadLibraryEx(pathnm, 0, LOAD_LIBRARY_AS_DATAFILE)
nm = win32api.EnumResourceNames(h, RT_VERSION)[0]
data = win32api.LoadResource(h, RT_VERSION, nm)
vs = VSVersionInfo()
j = vs.fromRaw(data)
if TEST:
print vs
if data[:j] != vs.toRaw():
print "AAAAAGGHHHH"
txt = repr(vs)
glbls = {}
glbls['VSVersionInfo'] = VSVersionInfo
glbls['FixedFileInfo'] = FixedFileInfo
glbls['StringFileInfo'] = StringFileInfo
glbls['StringTable'] = StringTable
glbls['StringStruct'] = StringStruct
glbls['VarFileInfo'] = VarFileInfo
glbls['VarStruct'] = VarStruct
vs2 = eval(txt+'\n', glbls)
if vs.toRaw() != vs2.toRaw():
print
print 'reconstruction not the same!'
print vs2
win32api.FreeLibrary(h)
return vs
class VSVersionInfo:
def __init__(self, ffi=None, kids=None):
self.ffi = ffi
self.kids = kids
if kids is None:
self.kids = []
def fromRaw(self, data):
i, (sublen, vallen, wType, nm) = parseCommon(data)
#vallen is length of the ffi, typ is 0, nm is 'VS_VERSION_INFO'
i = ((i + 3) / 4) * 4
# now a VS_FIXEDFILEINFO
self.ffi = FixedFileInfo()
j = self.ffi.fromRaw(data, i)
#print ffi
if TEST:
if data[i:j] != self.ffi.toRaw():
print "raw:", `data[i:j]`
print "ffi:", `self.ffi.toRaw()`
i = j
while i < sublen:
j = i
i, (csublen, cvallen, ctyp, nm) = parseCommon(data, i)
if string.strip(str(nm)) == "StringFileInfo":
sfi = StringFileInfo()
k = sfi.fromRaw(csublen, cvallen, nm, data, i, j+csublen)
if TEST:
if data[j:k] != sfi.toRaw():
rd = data[j:k]
sd = sfi.toRaw()
for x in range(0, len(rd), 16):
rds = rd[x:x+16]
sds = sd[x:x+16]
if rds != sds:
print "rd[%s:%s+16]: %s" % (x, x, `rds`)
print "sd[%s:%s+16]: %s" % (x, x, `sds`)
print
print "raw: len %d, wLength %d" % (len(rd), struct.unpack('h', rd[:2])[0])
print "sfi: len %d, wLength %d" % (len(sd), struct.unpack('h', sd[:2])[0])
self.kids.append(sfi)
i = k
else:
vfi = VarFileInfo()
k = vfi.fromRaw(csublen, cvallen, nm, data, i, j+csublen)
self.kids.append(vfi)
if TEST:
if data[j:k] != vfi.toRaw():
print "raw:", `data[j:k]`
print "vfi:", `vfi.toRaw()`
i = k
i = j + csublen
i = ((i + 3) / 4) * 4
return i
def toRaw(self):
nm = pywintypes.Unicode('VS_VERSION_INFO')
rawffi = self.ffi.toRaw()
vallen = len(rawffi)
typ = 0
sublen = 6 + 2*len(nm) + 2
pad = ''
if sublen % 4:
pad = '\000\000'
sublen = sublen + len(pad) + vallen
pad2 = ''
if sublen % 4:
pad2 = '\000\000'
tmp = []
for kid in self.kids:
tmp.append(kid.toRaw())
tmp = string.join(tmp, '')
sublen = sublen + len(pad2) + len(tmp)
return struct.pack('hhh', sublen, vallen, typ) + getRaw(nm) + '\000\000' + pad + rawffi + pad2 + tmp
def __repr__(self, indent=''):
tmp = []
newindent = indent + ' '
for kid in self.kids:
tmp.append(kid.__repr__(newindent+' '))
tmp = string.join(tmp, ', \n')
return "VSVersionInfo(\n%sffi=%s,\n%skids=[\n%s\n%s]\n)" % (newindent, self.ffi.__repr__(newindent), newindent, tmp, newindent)
def parseCommon(data, start=0):
i = start + 6
(wLength, wValueLength, wType) = struct.unpack('3h', data[start:i])
#print "wLength, wValueLength, wType, i:", wLength, wValueLength, wType, i
i, szKey = parseUString(data, i, i+wLength)
#i = ((i + 3) / 4) * 4
#print `data[start+6:start+wLength]`
return i, (wLength, wValueLength, wType, szKey)
def parseUString(data, start, limit):
i = start
while i < limit:
if data[i:i+2] == '\000\000':
break
i = i + 2
szKey = pywintypes.UnicodeFromRaw(data[start:i])
i = i + 2
#print "szKey:", '"'+str(szKey)+'"', "(consumed", i-start, "bytes - to", i, ")"
return i, szKey
##VS_FIXEDFILEINFO { // vsffi
## DWORD dwSignature; //Contains the value 0xFEEFO4BD
## DWORD dwStrucVersion; //Specifies the binary version number of this structure. The high-order word of this member contains the major version number, and the low-order word contains the minor version number.
## DWORD dwFileVersionMS; // Specifies the most significant 32 bits of the file's binary version number
## DWORD dwFileVersionLS; //
## DWORD dwProductVersionMS; // Specifies the most significant 32 bits of the binary version number of the product with which this file was distributed
## DWORD dwProductVersionLS; //
## DWORD dwFileFlagsMask; // Contains a bitmask that specifies the valid bits in dwFileFlags. A bit is valid only if it was defined when the file was created.
## DWORD dwFileFlags; // VS_FF_DEBUG, VS_FF_PATCHED etc.
## DWORD dwFileOS; // VOS_NT, VOS_WINDOWS32 etc.
## DWORD dwFileType; // VFT_APP etc.
## DWORD dwFileSubtype; // 0 unless VFT_DRV or VFT_FONT or VFT_VXD
## DWORD dwFileDateMS;
## DWORD dwFileDateLS;
##};
class FixedFileInfo:
def __init__(self, filevers=(0, 0, 0, 0), prodvers=(0, 0, 0, 0), mask=0x3f, flags=0x0, OS=0x40004, fileType=0x1, subtype=0x0, date=(0, 0)):
self.sig = 0xfeef04bdL
self.strucVersion = 0x10000
self.fileVersionMS = (filevers[0] << 16) | (filevers[1] & 0xffff)
self.fileVersionLS = (filevers[2] << 16) | (filevers[3] & 0xffff)
self.productVersionMS = (prodvers[0] << 16) | (prodvers[1] & 0xffff)
self.productVersionLS = (prodvers[2] << 16) | (prodvers[3] & 0xffff)
self.fileFlagsMask = mask
self.fileFlags = flags
self.fileOS = OS
self.fileType = fileType
self.fileSubtype = subtype
self.fileDateMS = date[0]
self.fileDateLS = date[1]
def fromRaw(self, data, i):
(self.sig,
self.strucVersion,
self.fileVersionMS,
self.fileVersionLS,
self.productVersionMS,
self.productVersionLS,
self.fileFlagsMask,
self.fileFlags,
self.fileOS,
self.fileType,
self.fileSubtype,
self.fileDateMS,
self.fileDateLS) = struct.unpack('13l', data[i:i+52])
return i+52
def toRaw(self):
return struct.pack('L12l', self.sig,
self.strucVersion,
self.fileVersionMS,
self.fileVersionLS,
self.productVersionMS,
self.productVersionLS,
self.fileFlagsMask,
self.fileFlags,
self.fileOS,
self.fileType,
self.fileSubtype,
self.fileDateMS,
self.fileDateLS)
def __repr__(self, indent=''):
fv = (self.fileVersionMS >> 16, self.fileVersionMS & 0xffff, self.fileVersionLS >> 16, self.fileVersionLS & 0xFFFF)
pv = (self.productVersionMS >> 16, self.productVersionMS & 0xffff, self.productVersionLS >> 16, self.productVersionLS & 0xFFFF)
fd = (self.fileDateMS, self.fileDateLS)
tmp = ["FixedFileInfo(",
"filevers=%s," % (fv,),
"prodvers=%s," % (pv,),
"mask=%s," % hex(self.fileFlagsMask),
"flags=%s," % hex(self.fileFlags),
"OS=%s," % hex(self.fileOS),
"fileType=%s," % hex(self.fileType),
"subtype=%s," % hex(self.fileSubtype),
"date=%s" % (fd,),
")"
]
return string.join(tmp, '\n'+indent+' ')
##StringFileInfo {
## WORD wLength; // Specifies the length of the version resource
## WORD wValueLength; // Specifies the length of the Value member in the current VS_VERSION_INFO structure
## WORD wType; // 1 means text, 0 means binary
## WCHAR szKey[]; // Contains the Unicode string "StringFileInfo".
## WORD Padding[];
## StringTable Children[]; // Specifies a list of zero or more String structures
##};
class StringFileInfo:
def __init__(self, kids=None):
self.name = "StringFileInfo"
if kids is None:
self.kids = []
else:
self.kids = kids
def fromRaw(self, sublen, vallen, name, data, i, limit):
self.name = name
while i < limit:
st = StringTable()
j = st.fromRaw(data, i, limit)
if TEST:
if data[i:j] != st.toRaw():
rd = data[i:j]
sd = st.toRaw()
for x in range(0, len(rd), 16):
rds = rd[x:x+16]
sds = sd[x:x+16]
if rds != sds:
print "rd[%s:%s+16]: %s" % (x, x, `rds`)
print "sd[%s:%s+16]: %s" % (x, x, `sds`)
print
print "raw: len %d, wLength %d" % (len(rd), struct.unpack('h', rd[:2])[0])
print " st: len %d, wLength %d" % (len(sd), struct.unpack('h', sd[:2])[0])
self.kids.append(st)
i = j
return i
def toRaw(self):
if type(self.name) is STRINGTYPE:
self.name = pywintypes.Unicode(self.name)
vallen = 0
typ = 1
sublen = 6 + 2*len(self.name) + 2
pad = ''
if sublen % 4:
pad = '\000\000'
tmp = []
for kid in self.kids:
tmp.append(kid.toRaw())
tmp = string.join(tmp, '')
sublen = sublen + len(pad) + len(tmp)
if tmp[-2:] == '\000\000':
sublen = sublen - 2
return struct.pack('hhh', sublen, vallen, typ) + getRaw(self.name) + '\000\000' + pad + tmp
def __repr__(self, indent=''):
tmp = []
newindent = indent + ' '
for kid in self.kids:
tmp.append(kid.__repr__(newindent))
tmp = string.join(tmp, ', \n')
return "%sStringFileInfo(\n%s[\n%s\n%s])" % (indent, newindent, tmp, newindent)
##StringTable {
## WORD wLength;
## WORD wValueLength;
## WORD wType;
## WCHAR szKey[];
## String Children[]; // Specifies a list of zero or more String structures.
##};
class StringTable:
def __init__(self, name=None, kids=None):
self.name = name
self.kids = kids
if name is None:
self.name = ''
if kids is None:
self.kids = []
def fromRaw(self, data, i, limit):
#print "Parsing StringTable"
i, (cpsublen, cpwValueLength, cpwType, self.name) = parseCodePage(data, i, limit) # should be code page junk
#i = ((i + 3) / 4) * 4
while i < limit:
ss = StringStruct()
j = ss.fromRaw(data, i, limit)
if TEST:
if data[i:j] != ss.toRaw():
print "raw:", `data[i:j]`
print " ss:", `ss.toRaw()`
i = j
self.kids.append(ss)
i = ((i + 3) / 4) * 4
return i
def toRaw(self):
if type(self.name) is STRINGTYPE:
self.name = pywintypes.Unicode(self.name)
vallen = 0
typ = 1
sublen = 6 + 2*len(self.name) + 2
tmp = []
for kid in self.kids:
raw = kid.toRaw()
if len(raw) % 4:
raw = raw + '\000\000'
tmp.append(raw)
tmp = string.join(tmp, '')
sublen = sublen + len(tmp)
if tmp[-2:] == '\000\000':
sublen = sublen - 2
return struct.pack('hhh', sublen, vallen, typ) + getRaw(self.name) + '\000\000' + tmp
def __repr__(self, indent=''):
tmp = []
newindent = indent + ' '
for kid in self.kids:
tmp.append(repr(kid))
tmp = string.join(tmp, ',\n%s' % newindent)
return "%sStringTable(\n%s'%s', \n%s[%s])" % (indent, newindent, str(self.name), newindent, tmp)
##String {
## WORD wLength;
## WORD wValueLength;
## WORD wType;
## WCHAR szKey[];
## WORD Padding[];
## String Value[];
##};
class StringStruct:
def __init__(self, name=None, val=None):
self.name = name
self.val = val
if name is None:
self.name = ''
if val is None:
self.val = ''
def fromRaw(self, data, i, limit):
i, (sublen, vallen, typ, self.name) = parseCommon(data, i)
limit = i + sublen
i = ((i + 3) / 4) * 4
i, self.val = parseUString(data, i, limit)
return i
def toRaw(self):
if type(self.name) is STRINGTYPE:
self.name = pywintypes.Unicode(self.name)
if type(self.val) is STRINGTYPE:
self.val = pywintypes.Unicode(self.val)
vallen = len(self.val) + 1
typ = 1
sublen = 6 + 2*len(self.name) + 2
pad = ''
if sublen % 4:
pad = '\000\000'
sublen = sublen + len(pad) + 2*vallen
return struct.pack('hhh', sublen, vallen, typ) + getRaw(self.name) + '\000\000' + pad + getRaw(self.val) + '\000\000'
def __repr__(self, indent=''):
if pyvers < 20:
return "StringStruct('%s', '%s')" % (str(self.name), str(self.val))
else:
return "StringStruct('%s', '%s')" % (self.name, self.val)
def parseCodePage(data, i, limit):
#print "Parsing CodePage"
i, (sublen, wValueLength, wType, nm) = parseCommon(data, i)
#i = ((i + 3) / 4) * 4
return i, (sublen, wValueLength, wType, nm)
##VarFileInfo {
## WORD wLength; // Specifies the length of the version resource
## WORD wValueLength; // Specifies the length of the Value member in the current VS_VERSION_INFO structure
## WORD wType; // 1 means text, 0 means binary
## WCHAR szKey[]; // Contains the Unicode string "VarFileInfo".
## WORD Padding[];
## Var Children[]; // Specifies a list of zero or more Var structures
##};
class VarFileInfo:
def __init__(self, kids=None):
if kids is None:
self.kids = []
else:
self.kids = kids
def fromRaw(self, sublen, vallen, name, data, i, limit):
self.sublen = sublen
self.vallen = vallen
self.name = name
i = ((i + 3) / 4) * 4
while i < limit:
vs = VarStruct()
j = vs.fromRaw(data, i, limit)
self.kids.append(vs)
if TEST:
if data[i:j] != vs.toRaw():
print "raw:", `data[i:j]`
print "cmp:", `vs.toRaw()`
i = j
return i
def toRaw(self):
self.vallen = 0
self.wType = 1
self.name = pywintypes.Unicode('VarFileInfo')
sublen = 6 + 2*len(self.name) + 2
pad = ''
if sublen % 4:
pad = '\000\000'
tmp = []
for kid in self.kids:
tmp.append(kid.toRaw())
tmp = string.join(tmp, '')
self.sublen = sublen + len(pad) + len(tmp)
return struct.pack('hhh', self.sublen, self.vallen, self.wType) + getRaw(self.name) + '\000\000' + pad + tmp
def __repr__(self, indent=''):
tmp = map(repr, self.kids)
return "%sVarFileInfo([%s])" % (indent, string.join(tmp, ', '))
##Var {
## WORD wLength; // Specifies the length of the version resource
## WORD wValueLength; // Specifies the length of the Value member in the current VS_VERSION_INFO structure
## WORD wType; // 1 means text, 0 means binary
## WCHAR szKey[]; // Contains the Unicode string "Translation" or a user-defined key string value
## WORD Padding[]; //
## WORD Value[]; // Specifies a list of one or more values that are language and code-page identifiers
##};
STRINGTYPE = type('')
class VarStruct:
def __init__(self, name=None, kids=None):
self.name = name
self.kids = kids
if name is None:
self.name = ''
if kids is None:
self.kids = []
def fromRaw(self, data, i, limit):
i, (self.sublen, self.wValueLength, self.wType, self.name) = parseCommon(data, i)
i = ((i + 3) / 4) * 4
for j in range(self.wValueLength/2):
kid = struct.unpack('h', data[i:i+2])[0]
self.kids.append(kid)
i = i + 2
return i
def toRaw(self):
self.wValueLength = len(self.kids) * 2
self.wType = 0
if type(self.name) is STRINGTYPE:
self.name = pywintypes.Unicode(self.name)
sublen = 6 + 2*len(self.name) + 2
pad = ''
if sublen % 4:
pad = '\000\000'
self.sublen = sublen + len(pad) + self.wValueLength
tmp = []
for kid in self.kids:
tmp.append(struct.pack('h', kid))
tmp = string.join(tmp, '')
return struct.pack('hhh', self.sublen, self.wValueLength, self.wType) + getRaw(self.name) + '\000\000' + pad + tmp
def __repr__(self, indent=''):
return "VarStruct('%s', %s)" % (str(self.name), repr(self.kids))
def SetVersion(exenm, versionfile):
txt = open(versionfile, 'r').read()
vs = eval(txt+'\n', globals())
hdst = win32api.BeginUpdateResource(exenm, 0)
win32api.UpdateResource(hdst, RT_VERSION, 1, vs.toRaw())
win32api.EndUpdateResource (hdst, 0)
if __name__ == '__main__':
import sys
TEST = 1
if len(sys.argv) < 2:
decode('c:/Program Files/Netscape/Communicator/Program/netscape.exe')
else:
print "Examining", sys.argv[1]
decode(sys.argv[1])
Reference in New Issue View Git Blame Copy Permalink