trunk/scons/nsis.py

# NSIS Support for SCons
# Written by Mike Elkins, January 2004
# Provided 'as-is', it works for me!


"""
This tool provides SCons support for the Nullsoft Scriptable Install System
a windows installer builder available at http://nsis.sourceforge.net/home


To use it you must copy this file into the scons/SCons/Tools directory or use
the tooldir arg in the Tool function and put a line like 'env.Tool("NSIS")'
into your file. Then you can do 'env.Installer("foobar")' which will read foobar.nsi and
create dependencies on all the files you put into your installer, so that if
anything changes your installer will be rebuilt.  It also makes the target
equal to the filename you specified in foobar.nsi.  Wildcards are handled correctly.

In addition, if you set NSISDEFINES to a dictionary, those variables will be passed
to NSIS.
"""


import SCons.Builder
import SCons.Util
import SCons.Scanner
import SCons.Sig
import os.path
import glob


def nsis_parse( sources, keyword, multiple ):
  """
  A function that knows how to read a .nsi file and figure
  out what files are referenced, or find the 'OutFile' line.


  sources is a list of nsi files.
  keyword is the command ('File' or 'OutFile') to look for
  multiple is true if you want all the args as a list, false if you
  just want the first one.
  """
  stuff = []
  for s in sources:
    c = s.get_contents()
    for l in c.split('\n'):
      semi = l.find(';')
      if (semi != -1):
        l = l[:semi]
      hash = l.find('#')
      if (hash != -1):
        l = l[:hash]
      # Look for the keyword
      l = l.strip()
      spl = l.split(None,1)
      if len(spl) > 1:
        if spl[0].capitalize() == keyword.capitalize():
          arg = spl[1]
          if arg.startswith('"') and arg.endswith('"'):
            arg = arg[1:-1]
          if multiple:
            stuff += [ arg ]
          else:
            return arg
  return stuff


def nsis_path( filename, nsisdefines, rootdir ):
  """
  Do environment replacement, and prepend with the SCons root dir if
  necessary
  """
  # We can't do variables defined by NSIS itself (like $INSTDIR),
  # only user supplied ones (like ${FOO})
  varPos = filename.find('${')
  while varPos != -1:
    endpos = filename.find('}',varPos)
    assert endpos != -1
    if not nsisdefines.has_key(filename[varPos+2:endpos]):
      raise KeyError ("Could not find %s in NSISDEFINES" % filename[varPos+2:endpos])
    val = nsisdefines[filename[varPos+2:endpos]]
    if type(val) == list:
      if varPos != 0 or endpos+1 != len(filename):
        raise Exception("Can't use lists on variables that aren't complete filenames")
      return val
    filename = filename[0:varPos] + val + filename[endpos+1:]
    varPos = filename.find('${')
  return filename


def nsis_scanner( node, env, path ):
  """
  The scanner that looks through the source .nsi files and finds all lines
  that are the 'File' command, fixes the directories etc, and returns them.
  """
  nodes = node.rfile()
  if not node.exists():
    return []
  nodes = []
  source_dir = node.get_dir()
  for include in nsis_parse([node],'file',1):
    exp = nsis_path(include,env['NSISDEFINES'],source_dir)
    if type(exp) != list:
      exp = [exp]
    for p in exp:
      for filename in glob.glob( os.path.abspath(
        os.path.join(str(source_dir),p))):
          # Why absolute path?  Cause it breaks mysteriously without it :(
          nodes.append(filename)
  return nodes


def nsis_emitter( source, target, env ):
  """
  The emitter changes the target name to match what the command actually will
  output, which is the argument to the OutFile command.
  """
  nsp = nsis_parse(source,'outfile',0)
  if not nsp:
    return (target,source)
  x  = (
    nsis_path(nsp,env['NSISDEFINES'],''),
    source)
  return x

def quoteIfSpaced(text):
  if ' ' in text:
    return '"'+text+'"'
  else:
    return text

def toString(item,env):
  if type(item) == list:
    ret = ''
    for i in item:
      if ret:
        ret += ' '
      val = toString(i,env)
      if ' ' in val:
        val = "'"+val+"'"
      ret += val
    return ret
  else:
    # For convienence, handle #s here
    if str(item).startswith('#'):
      item = env.File(item).get_abspath()
    return str(item)

def runNSIS(source,target,env,for_signature):
  ret = env['NSIS']+" "
  if env.has_key('NSISFLAGS'):
    for flag in env['NSISFLAGS']:
      ret += flag
      ret += ' '
  if env.has_key('NSISDEFINES'):
    for d in env['NSISDEFINES']:
      ret += '/D'+d
      if env['NSISDEFINES'][d]:
        ret +='='+quoteIfSpaced(toString(env['NSISDEFINES'][d],env))
      ret += ' '
  for s in source:
    ret += quoteIfSpaced(str(s))
  return ret

def generate(env):
  """
  This function adds NSIS support to your environment.
  """
  env['BUILDERS']['Installer'] = SCons.Builder.Builder(generator=runNSIS,
                                 src_suffix='.nsi',
                                 emitter=nsis_emitter)
  env.Append(SCANNERS = SCons.Scanner.Scanner( function = nsis_scanner,
             skeys = ['.nsi']))
  if not env.has_key('NSISDEFINES'):
    env['NSISDEFINES'] = {}
  env['NSIS'] = find_nsis(env)

def find_nsis(env):
  """
  Try and figure out if NSIS is installed on this machine, and if so,
  where.
  """
  if SCons.Util.can_read_reg:
    # If we can read the registry, get the NSIS command from it
    try:
      k = SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
                                  'SOFTWARE\\NSIS')
      val, tok = SCons.Util.RegQueryValueEx(k,None)
      ret = val + os.path.sep + 'makensis.exe'
      if os.path.exists(ret):
        return '"' + ret + '"'
      else:
        return None
    except:
      pass # Couldn't find the key, just act like we can't read the registry
  # Hope it's on the path
  return env.WhereIs('makensis.exe')

def exists(env):
  """
  Is NSIS findable on this machine?
  """
  if find_nsis(env) != None:
    return 1
  return 0
1	# NSIS Support for SCons
2	# Written by Mike Elkins, January 2004
3	# Provided 'as-is', it works for me!
4
5
6	"""
7	This tool provides SCons support for the Nullsoft Scriptable Install System
8	a windows installer builder available at http://nsis.sourceforge.net/home
9
10
11	To use it you must copy this file into the scons/SCons/Tools directory or use
12	the tooldir arg in the Tool function and put a line like 'env.Tool("NSIS")'
13	into your file. Then you can do 'env.Installer("foobar")' which will read foobar.nsi and
14	create dependencies on all the files you put into your installer, so that if
15	anything changes your installer will be rebuilt. It also makes the target
16	equal to the filename you specified in foobar.nsi. Wildcards are handled correctly.
17
18	In addition, if you set NSISDEFINES to a dictionary, those variables will be passed
19	to NSIS.
20	"""
21
22
23
24	import SCons.Builder
25	import SCons.Util
26	import SCons.Scanner
27	import SCons.Sig
28	import os.path
29	import glob
30
31
32	def nsis_parse( sources, keyword, multiple ):
33	"""
34	A function that knows how to read a .nsi file and figure
35	out what files are referenced, or find the 'OutFile' line.
36
37
38	sources is a list of nsi files.
39	keyword is the command ('File' or 'OutFile') to look for
40	multiple is true if you want all the args as a list, false if you
41	just want the first one.
42	"""
43	stuff = []
44	for s in sources:
45	c = s.get_contents()
46	for l in c.split('\n'):
47	semi = l.find(';')
48	if (semi != -1):
49	l = l[:semi]
50	hash = l.find('#')
51	if (hash != -1):
52	l = l[:hash]
53	# Look for the keyword
54	l = l.strip()
55	spl = l.split(None,1)
56	if len(spl) > 1:
57	if spl[0].capitalize() == keyword.capitalize():
58	arg = spl[1]
59	if arg.startswith('"') and arg.endswith('"'):
60	arg = arg[1:-1]
61	if multiple:
62	stuff += [ arg ]
63	else:
64	return arg
65	return stuff
66
67
68	def nsis_path( filename, nsisdefines, rootdir ):
69	"""
70	Do environment replacement, and prepend with the SCons root dir if
71	necessary
72	"""
73	# We can't do variables defined by NSIS itself (like $INSTDIR),
74	# only user supplied ones (like ${FOO})
75	varPos = filename.find('${')
76	while varPos != -1:
77	endpos = filename.find('}',varPos)
78	assert endpos != -1
79	if not nsisdefines.has_key(filename[varPos+2:endpos]):
80	raise KeyError ("Could not find %s in NSISDEFINES" % filename[varPos+2:endpos])
81	val = nsisdefines[filename[varPos+2:endpos]]
82	if type(val) == list:
83	if varPos != 0 or endpos+1 != len(filename):
84	raise Exception("Can't use lists on variables that aren't complete filenames")
85	return val
86	filename = filename[0:varPos] + val + filename[endpos+1:]
87	varPos = filename.find('${')
88	return filename
89
90
91	def nsis_scanner( node, env, path ):
92	"""
93	The scanner that looks through the source .nsi files and finds all lines
94	that are the 'File' command, fixes the directories etc, and returns them.
95	"""
96	nodes = node.rfile()
97	if not node.exists():
98	return []
99	nodes = []
100	source_dir = node.get_dir()
101	for include in nsis_parse([node],'file',1):
102	exp = nsis_path(include,env['NSISDEFINES'],source_dir)
103	if type(exp) != list:
104	exp = [exp]
105	for p in exp:
106	for filename in glob.glob( os.path.abspath(
107	os.path.join(str(source_dir),p))):
108	# Why absolute path? Cause it breaks mysteriously without it :(
109	nodes.append(filename)
110	return nodes
111
112
113	def nsis_emitter( source, target, env ):
114	"""
115	The emitter changes the target name to match what the command actually will
116	output, which is the argument to the OutFile command.
117	"""
118	nsp = nsis_parse(source,'outfile',0)
119	if not nsp:
120	return (target,source)
121	x = (
122	nsis_path(nsp,env['NSISDEFINES'],''),
123	source)
124	return x
125
126	def quoteIfSpaced(text):
127	if ' ' in text:
128	return '"'+text+'"'
129	else:
130	return text
131
132	def toString(item,env):
133	if type(item) == list:
134	ret = ''
135	for i in item:
136	if ret:
137	ret += ' '
138	val = toString(i,env)
139	if ' ' in val:
140	val = "'"+val+"'"
141	ret += val
142	return ret
143	else:
144	# For convienence, handle #s here
145	if str(item).startswith('#'):
146	item = env.File(item).get_abspath()
147	return str(item)
148
149	def runNSIS(source,target,env,for_signature):
150	ret = env['NSIS']+" "
151	if env.has_key('NSISFLAGS'):
152	for flag in env['NSISFLAGS']:
153	ret += flag
154	ret += ' '
155	if env.has_key('NSISDEFINES'):
156	for d in env['NSISDEFINES']:
157	ret += '/D'+d
158	if env['NSISDEFINES'][d]:
159	ret +='='+quoteIfSpaced(toString(env['NSISDEFINES'][d],env))
160	ret += ' '
161	for s in source:
162	ret += quoteIfSpaced(str(s))
163	return ret
164
165	def generate(env):
166	"""
167	This function adds NSIS support to your environment.
168	"""
169	env['BUILDERS']['Installer'] = SCons.Builder.Builder(generator=runNSIS,
170	src_suffix='.nsi',
171	emitter=nsis_emitter)
172	env.Append(SCANNERS = SCons.Scanner.Scanner( function = nsis_scanner,
173	skeys = ['.nsi']))
174	if not env.has_key('NSISDEFINES'):
175	env['NSISDEFINES'] = {}
176	env['NSIS'] = find_nsis(env)
177
178	def find_nsis(env):
179	"""
180	Try and figure out if NSIS is installed on this machine, and if so,
181	where.
182	"""
183	if SCons.Util.can_read_reg:
184	# If we can read the registry, get the NSIS command from it
185	try:
186	k = SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
187	'SOFTWARE\\NSIS')
188	val, tok = SCons.Util.RegQueryValueEx(k,None)
189	ret = val + os.path.sep + 'makensis.exe'
190	if os.path.exists(ret):
191	return '"' + ret + '"'
192	else:
193	return None
194	except:
195	pass # Couldn't find the key, just act like we can't read the registry
196	# Hope it's on the path
197	return env.WhereIs('makensis.exe')
198
199	def exists(env):
200	"""
201	Is NSIS findable on this machine?
202	"""
203	if find_nsis(env) != None:
204	return 1
205	return 0