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