[javascriptlint-commit] SF.net SVN: javascriptlint: [178] trunk

[<mat...@us...>]

Revision: 178
          http://javascriptlint.svn.sourceforge.net/javascriptlint/?rev=178&view=rev
Author:   matthiasmiller
Date:     2008-03-31 06:45:14 -0700 (Mon, 31 Mar 2008)

Log Message:
-----------
Use spaces instead of tabs.

Modified Paths:
--------------
    trunk/DEVELOPMENT
    trunk/jsl.py
    trunk/pyjsl/conf.py
    trunk/pyjsl/jsparse.py
    trunk/pyjsl/lint.py
    trunk/pyjsl/util.py
    trunk/pyjsl/visitation.py
    trunk/pyjsl/warnings.py
    trunk/pyspidermonkey/pyspidermonkey.c
    trunk/setup.py
    trunk/test.py

Modified: trunk/DEVELOPMENT
===================================================================
--- trunk/DEVELOPMENT	2008-03-20 21:38:49 UTC (rev 177)
+++ trunk/DEVELOPMENT	2008-03-31 13:45:14 UTC (rev 178)
@@ -1,9 +1,7 @@
 ** STYLE GUIDELINES
 
-> Use tabs instead of spaces (for now)
 > All lines should be 79 characters or less
-> For everything else, follow http://www.python.org/dev/peps/pep-0008/ as much
-  as possible.
+> Follow http://www.python.org/dev/peps/pep-0008/ as much as possible.
 
 
 ** TODO
@@ -23,9 +21,9 @@
 SpiderMonkey. Use a relative path for pretty commit messages.
  
 svn_load_dirs.pl \
-	-t X.X.X \
-	-p svn_load_dirs.conf \
-	https://javascriptlint.svn.sourceforge.net/svnroot/javascriptlint/vendorsrc/Mozilla.org/js \
-	current \
-	js-X.X.X
+    -t X.X.X \
+    -p svn_load_dirs.conf \
+    https://javascriptlint.svn.sourceforge.net/svnroot/javascriptlint/vendorsrc/Mozilla.org/js \
+    current \
+    js-X.X.X
 

Modified: trunk/jsl.py
===================================================================
--- trunk/jsl.py	2008-03-20 21:38:49 UTC (rev 177)
+++ trunk/jsl.py	2008-03-31 13:45:14 UTC (rev 178)
@@ -7,11 +7,11 @@
 import unittest
 
 try:
-	import setup
+    import setup
 except ImportError:
-	pass
+    pass
 else:
-	sys.path.append(setup.get_lib_path())
+    sys.path.append(setup.get_lib_path())
 
 import pyjsl.conf
 import pyjsl.jsparse
@@ -19,84 +19,84 @@
 import test
 
 _lint_results = {
-	'warnings': 0,
-	'errors': 0
+    'warnings': 0,
+    'errors': 0
 }
 
 def get_test_files():
-	# Get a list of test files.
-	dir_ = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'tests')
+    # Get a list of test files.
+    dir_ = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'tests')
 
-	all_files = []
-	for root, dirs, files in os.walk(dir_):
-		all_files += [os.path.join(dir_, root, file) for file in files]
-		if '.svn' in dirs:
-			dirs.remove('.svn')
-		# TODO
-		if 'conf' in dirs:
-			dirs.remove('conf')
-	all_files.sort()
-	return all_files
+    all_files = []
+    for root, dirs, files in os.walk(dir_):
+        all_files += [os.path.join(dir_, root, file) for file in files]
+        if '.svn' in dirs:
+            dirs.remove('.svn')
+        # TODO
+        if 'conf' in dirs:
+            dirs.remove('conf')
+    all_files.sort()
+    return all_files
 
 def run_tests():
-	for file in get_test_files():
-		if file.endswith('.htm') or file.endswith('.html'):
-			continue #TODO
-		elif file.endswith('.js'):
-			try:
-				test.run(file)
-			except test.TestError, error:
-				print error
+    for file in get_test_files():
+        if file.endswith('.htm') or file.endswith('.html'):
+            continue #TODO
+        elif file.endswith('.js'):
+            try:
+                test.run(file)
+            except test.TestError, error:
+                print error
 
 def _dump(paths):
-	for path in paths:
-		script = pyjsl.util.readfile(path)
-		pyjsl.jsparse.dump_tree(script)
+    for path in paths:
+        script = pyjsl.util.readfile(path)
+        pyjsl.jsparse.dump_tree(script)
 
 def _lint(paths, conf):
-	def lint_error(path, line, col, errname):
-		_lint_results['warnings'] = _lint_results['warnings'] + 1
-		print '%s(%i): %s' % (path, line, errname)
-	pyjsl.lint.lint_files(paths, lint_error, conf=conf)
+    def lint_error(path, line, col, errname):
+        _lint_results['warnings'] = _lint_results['warnings'] + 1
+        print '%s(%i): %s' % (path, line, errname)
+    pyjsl.lint.lint_files(paths, lint_error, conf=conf)
 
 def _resolve_paths(path, recurse):
-	if os.path.isfile(path):
-		return [path]
-	elif os.path.isdir(path):
-		dir = path
-		pattern = '*'
-	else:
-		dir, pattern = os.path.split(path)
+    if os.path.isfile(path):
+        return [path]
+    elif os.path.isdir(path):
+        dir = path
+        pattern = '*'
+    else:
+        dir, pattern = os.path.split(path)
 
-	# Build a list of directories
-	dirs = [dir]
-	if recurse:
-		for cur_root, cur_dirs, cur_files in os.walk(dir):
-			for name in cur_dirs:
-				dirs.append(os.path.join(cur_root, name))
+    # Build a list of directories
+    dirs = [dir]
+    if recurse:
+        for cur_root, cur_dirs, cur_files in os.walk(dir):
+            for name in cur_dirs:
+                dirs.append(os.path.join(cur_root, name))
 
-	# Glob all files.
-	paths = []
-	for dir in dirs:
-		paths.extend(glob.glob(os.path.join(dir, pattern)))
-	return paths
+    # Glob all files.
+    paths = []
+    for dir in dirs:
+        paths.extend(glob.glob(os.path.join(dir, pattern)))
+    return paths
 
 def profile_enabled(func, *args, **kwargs):
-	import tempfile
-	import hotshot
-	import hotshot.stats
-	handle, filename = tempfile.mkstemp()
-	profile = hotshot.Profile(filename)
-	profile.runcall(func, *args, **kwargs)
-	profile.close()
-	stats = hotshot.stats.load(filename)
-	stats = stats.sort_stats("time")
-	stats.print_stats()
+    import tempfile
+    import hotshot
+    import hotshot.stats
+    handle, filename = tempfile.mkstemp()
+    profile = hotshot.Profile(filename)
+    profile.runcall(func, *args, **kwargs)
+    profile.close()
+    stats = hotshot.stats.load(filename)
+    stats = stats.sort_stats("time")
+    stats.print_stats()
 def profile_disabled(func, *args, **kwargs):
-	func(*args, **kwargs)
+    func(*args, **kwargs)
 
 def usage():
-	print """
+    print """
 Usage:
    jsl [files]
    --help (-h)  print this help
@@ -105,42 +105,42 @@
 """
 
 if __name__ == '__main__':
-	try:
-		opts, args = getopt.getopt(sys.argv[1:], 'ht:v', ['conf=', 'help', 'test', 'dump', 'unittest', 'profile'])
-	except getopt.GetoptError:
-		usage()
-		sys.exit(2)
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'ht:v', ['conf=', 'help', 'test', 'dump', 'unittest', 'profile'])
+    except getopt.GetoptError:
+        usage()
+        sys.exit(2)
 
-	dump = False
-	conf = pyjsl.conf.Conf()
-	profile_func = profile_disabled
-	for opt, val in opts:
-		if opt in ('-h', '--help'):
-			usage()
-			sys.exit()
-		if opt in ('--dump',):
-			dump = True
-		if opt in ('-t', '--test'):
-			profile_func(run_tests)
-		if opt in ('--unittest',):
-			unittest.main(pyjsl.jsparse, argv=sys.argv[:1])
-		if opt in ('--profile',):
-			profile_func = profile_enabled
-		if opt in ('--conf',):
-			conf.loadfile(val)
+    dump = False
+    conf = pyjsl.conf.Conf()
+    profile_func = profile_disabled
+    for opt, val in opts:
+        if opt in ('-h', '--help'):
+            usage()
+            sys.exit()
+        if opt in ('--dump',):
+            dump = True
+        if opt in ('-t', '--test'):
+            profile_func(run_tests)
+        if opt in ('--unittest',):
+            unittest.main(pyjsl.jsparse, argv=sys.argv[:1])
+        if opt in ('--profile',):
+            profile_func = profile_enabled
+        if opt in ('--conf',):
+            conf.loadfile(val)
 
-	paths = []
-	for recurse, path in conf['paths']:
-		paths.extend(_resolve_paths(path, recurse))
-	for arg in args:
-		paths.extend(_resolve_paths(arg, False))
-	if dump:
-		profile_func(_dump, paths)
-	else:
-		profile_func(_lint, paths, conf)
+    paths = []
+    for recurse, path in conf['paths']:
+        paths.extend(_resolve_paths(path, recurse))
+    for arg in args:
+        paths.extend(_resolve_paths(arg, False))
+    if dump:
+        profile_func(_dump, paths)
+    else:
+        profile_func(_lint, paths, conf)
 
-	if _lint_results['errors']:
-		sys.exit(3)
-	if _lint_results['warnings']:
-		sys.exit(1)
+    if _lint_results['errors']:
+        sys.exit(3)
+    if _lint_results['warnings']:
+        sys.exit(1)
 

Modified: trunk/pyjsl/conf.py
===================================================================
--- trunk/pyjsl/conf.py	2008-03-20 21:38:49 UTC (rev 177)
+++ trunk/pyjsl/conf.py	2008-03-31 13:45:14 UTC (rev 178)
@@ -3,133 +3,133 @@
 import warnings
 
 class ConfError(Exception):
-	def __init__(self, error):
-		Exception.__init__(error)
-		self.lineno = None
-		self.path = None
+    def __init__(self, error):
+        Exception.__init__(error)
+        self.lineno = None
+        self.path = None
 
 class Setting:
-	wants_parm = False
-	wants_dir = False
+    wants_parm = False
+    wants_dir = False
 
 class BooleanSetting(Setting):
-	wants_parm = False
-	def __init__(self, default):
-		self.value = default
-	def load(self, enabled):
-		self.value = enabled
+    wants_parm = False
+    def __init__(self, default):
+        self.value = default
+    def load(self, enabled):
+        self.value = enabled
 
 class StringSetting(Setting):
-	wants_parm = True
-	def __init__(self, default):
-		self.value = default
-	def load(self, enabled, parm):
-		if not enabled:
-			raise ConfError, 'Expected +.'
-		self.value = parm
+    wants_parm = True
+    def __init__(self, default):
+        self.value = default
+    def load(self, enabled, parm):
+        if not enabled:
+            raise ConfError, 'Expected +.'
+        self.value = parm
 
 class DeclareSetting(Setting):
-	wants_parm = True
-	def __init__(self):
-		self.value = []
-	def load(self, enabled, parm):
-		if not enabled:
-			raise ConfError, 'Expected +.'
-		self.value.append(parm)
+    wants_parm = True
+    def __init__(self):
+        self.value = []
+    def load(self, enabled, parm):
+        if not enabled:
+            raise ConfError, 'Expected +.'
+        self.value.append(parm)
 
 class ProcessSetting(Setting):
-	wants_parm = True
-	wants_dir = True
-	def __init__(self, recurse_setting):
-		self.value = []
-		self._recurse = recurse_setting
-	def load(self, enabled, parm, dir):
-		if dir:
-			parm = os.path.join(dir, parm)
-		self.value.append((self._recurse.value, parm))
+    wants_parm = True
+    wants_dir = True
+    def __init__(self, recurse_setting):
+        self.value = []
+        self._recurse = recurse_setting
+    def load(self, enabled, parm, dir):
+        if dir:
+            parm = os.path.join(dir, parm)
+        self.value.append((self._recurse.value, parm))
 
 class Conf:
-	def __init__(self):
-		recurse = BooleanSetting(False) 
-		self._settings = {
-			'recurse': recurse,
-			'show_context': BooleanSetting(False),
-			'output-format': StringSetting('TODO'),
-			'lambda_assign_requires_semicolon': BooleanSetting(False),
-			'legacy_control_comments': BooleanSetting(True),
-			'jscript_function_extensions': BooleanSetting(False),
-			'always_use_option_explicit': BooleanSetting(False),
-			'define': DeclareSetting(),
-			'context': BooleanSetting(False),
-			'process': ProcessSetting(recurse),
-			# SpiderMonkey warnings
-			'no_return_value': BooleanSetting(True),
-			'equal_as_assign': BooleanSetting(True),
-			'anon_no_return_value': BooleanSetting(True)
-		}
-		for klass in warnings.klasses:
-			self._settings[klass.__name__] = BooleanSetting(True)
-		self.loadline('-block_without_braces')
+    def __init__(self):
+        recurse = BooleanSetting(False) 
+        self._settings = {
+            'recurse': recurse,
+            'show_context': BooleanSetting(False),
+            'output-format': StringSetting('TODO'),
+            'lambda_assign_requires_semicolon': BooleanSetting(False),
+            'legacy_control_comments': BooleanSetting(True),
+            'jscript_function_extensions': BooleanSetting(False),
+            'always_use_option_explicit': BooleanSetting(False),
+            'define': DeclareSetting(),
+            'context': BooleanSetting(False),
+            'process': ProcessSetting(recurse),
+            # SpiderMonkey warnings
+            'no_return_value': BooleanSetting(True),
+            'equal_as_assign': BooleanSetting(True),
+            'anon_no_return_value': BooleanSetting(True)
+        }
+        for klass in warnings.klasses:
+            self._settings[klass.__name__] = BooleanSetting(True)
+        self.loadline('-block_without_braces')
 
-	def loadfile(self, path):
-		path = os.path.abspath(path)
-		conf = open(path, 'r').read()
-		try:
-			self.loadtext(conf, dir=os.path.dirname(path))
-		except ConfError, error:
-			error.path = path
-			raise
+    def loadfile(self, path):
+        path = os.path.abspath(path)
+        conf = open(path, 'r').read()
+        try:
+            self.loadtext(conf, dir=os.path.dirname(path))
+        except ConfError, error:
+            error.path = path
+            raise
 
-	def loadtext(self, conf, dir=None):
-		lines = conf.splitlines()
-		for lineno in range(0, len(lines)):
-			try:
-				self.loadline(lines[lineno], dir)
-			except ConfError, error:
-				error.lineno = lineno
-				raise
+    def loadtext(self, conf, dir=None):
+        lines = conf.splitlines()
+        for lineno in range(0, len(lines)):
+            try:
+                self.loadline(lines[lineno], dir)
+            except ConfError, error:
+                error.lineno = lineno
+                raise
 
-	def loadline(self, line, dir=None):
-		assert not '\r' in line
-		assert not '\n' in line
+    def loadline(self, line, dir=None):
+        assert not '\r' in line
+        assert not '\n' in line
 
-		# Allow comments
-		if '#' in line:
-			line = line[:line.find('#')]
-		line = line.rstrip()
-		if not line:
-			return
+        # Allow comments
+        if '#' in line:
+            line = line[:line.find('#')]
+        line = line.rstrip()
+        if not line:
+            return
 
-		# Parse the +/-
-		if line.startswith('+'):
-			enabled = True
-		elif line.startswith('-'):
-			enabled = False
-		else:
-			raise ConfError, 'Expected + or -.'
-		line = line[1:]
+        # Parse the +/-
+        if line.startswith('+'):
+            enabled = True
+        elif line.startswith('-'):
+            enabled = False
+        else:
+            raise ConfError, 'Expected + or -.'
+        line = line[1:]
 
-		# Parse the key/parms
-		name = line.split()[0].lower()
-		parm = line[len(name):].lstrip()
+        # Parse the key/parms
+        name = line.split()[0].lower()
+        parm = line[len(name):].lstrip()
 
-		# Load the setting
-		setting = self._settings[name]
-		args = {
-			'enabled': enabled
-		}
-		if setting.wants_parm:
-			args['parm'] = parm
-		elif parm:
-			raise ConfError, 'The %s setting does not expect a parameter.' % name
-		if setting.wants_dir:
-			args['dir'] = dir
-		setting.load(**args)
+        # Load the setting
+        setting = self._settings[name]
+        args = {
+            'enabled': enabled
+        }
+        if setting.wants_parm:
+            args['parm'] = parm
+        elif parm:
+            raise ConfError, 'The %s setting does not expect a parameter.' % name
+        if setting.wants_dir:
+            args['dir'] = dir
+        setting.load(**args)
 
-	def __getitem__(self, name):
-		if name == 'paths':
-			name = 'process'
-		elif name == 'declarations':
-			name = 'define'
-		return self._settings[name].value
+    def __getitem__(self, name):
+        if name == 'paths':
+            name = 'process'
+        elif name == 'declarations':
+            name = 'define'
+        return self._settings[name].value
 

Modified: trunk/pyjsl/jsparse.py
===================================================================
--- trunk/pyjsl/jsparse.py	2008-03-20 21:38:49 UTC (rev 177)
+++ trunk/pyjsl/jsparse.py	2008-03-31 13:45:14 UTC (rev 178)
@@ -8,325 +8,325 @@
 from pyspidermonkey import tok, op
 
 _tok_names = dict(zip(
-	[getattr(tok, prop) for prop in dir(tok)],
-	['tok.%s' % prop for prop in dir(tok)]
+    [getattr(tok, prop) for prop in dir(tok)],
+    ['tok.%s' % prop for prop in dir(tok)]
 ))
 
 class NodePos:
-	def __init__(self, line, col):
-		self.line = line
-		self.col = col
-	def __cmp__(self, other):
-		if self.line < other.line:
-			return -1
-		if self.line > other.line:
-			return 1
-		if self.col < other.col:
-			return -1
-		if self.col > other.col:
-			return 1
-		return 0
-	def __str__(self):
-		return '(line %i, col %i)' % (self.line+1, self.col+1)
+    def __init__(self, line, col):
+        self.line = line
+        self.col = col
+    def __cmp__(self, other):
+        if self.line < other.line:
+            return -1
+        if self.line > other.line:
+            return 1
+        if self.col < other.col:
+            return -1
+        if self.col > other.col:
+            return 1
+        return 0
+    def __str__(self):
+        return '(line %i, col %i)' % (self.line+1, self.col+1)
 
 class NodePositions:
-	" Given a string, allows [x] lookups for NodePos line and column numbers."
-	def __init__(self, text):
-		# Find the length of each line and incrementally sum all of the lengths
-		# to determine the ending position of each line.
-		self._lines = text.splitlines(True)
-		lines = [0] + [len(x) for x in self._lines]
-		for x in range(1, len(lines)):
-			lines[x] += lines[x-1]
-		self._line_offsets = lines
-	def from_offset(self, offset):
-		line = bisect.bisect(self._line_offsets, offset)-1
-		col = offset - self._line_offsets[line]
-		return NodePos(line, col)
-	def to_offset(self, pos):
-		offset = self._line_offsets[pos.line] + pos.col
-		assert offset <= self._line_offsets[pos.line+1] # out-of-bounds col num
-		return offset
-	def text(self, start, end):
-		assert start <= end
-		# Trim the ending first in case it's a single line.
-		lines = self._lines[start.line:end.line+1]
-		lines[-1] = lines[-1][:end.col+1]
-		lines[0] = lines[0][start.col:]
-		return ''.join(lines)
+    " Given a string, allows [x] lookups for NodePos line and column numbers."
+    def __init__(self, text):
+        # Find the length of each line and incrementally sum all of the lengths
+        # to determine the ending position of each line.
+        self._lines = text.splitlines(True)
+        lines = [0] + [len(x) for x in self._lines]
+        for x in range(1, len(lines)):
+            lines[x] += lines[x-1]
+        self._line_offsets = lines
+    def from_offset(self, offset):
+        line = bisect.bisect(self._line_offsets, offset)-1
+        col = offset - self._line_offsets[line]
+        return NodePos(line, col)
+    def to_offset(self, pos):
+        offset = self._line_offsets[pos.line] + pos.col
+        assert offset <= self._line_offsets[pos.line+1] # out-of-bounds col num
+        return offset
+    def text(self, start, end):
+        assert start <= end
+        # Trim the ending first in case it's a single line.
+        lines = self._lines[start.line:end.line+1]
+        lines[-1] = lines[-1][:end.col+1]
+        lines[0] = lines[0][start.col:]
+        return ''.join(lines)
 
 class NodeRanges:
-	def __init__(self):
-		self._offsets = []
-	def add(self, start, end):
-		i = bisect.bisect_left(self._offsets, start)
-		if i % 2 == 1:
-			i -= 1
-			start = self._offsets[i]
+    def __init__(self):
+        self._offsets = []
+    def add(self, start, end):
+        i = bisect.bisect_left(self._offsets, start)
+        if i % 2 == 1:
+            i -= 1
+            start = self._offsets[i]
 
-		end = end + 1
-		j = bisect.bisect_left(self._offsets, end)
-		if j % 2 == 1:
-			end = self._offsets[j]
-			j += 1
+        end = end + 1
+        j = bisect.bisect_left(self._offsets, end)
+        if j % 2 == 1:
+            end = self._offsets[j]
+            j += 1
 
-		self._offsets[i:j] = [start,end]
-	def has(self, pos):
-		return bisect.bisect_right(self._offsets, pos) % 2 == 1
+        self._offsets[i:j] = [start,end]
+    def has(self, pos):
+        return bisect.bisect_right(self._offsets, pos) % 2 == 1
 
 class _Node:
-	def add_child(self, node):
-		if node:
-			node.node_index = len(self.kids)
-			node.parent = self
-		self.kids.append(node)
-	
-	def start_pos(self):
-		try:
-			return self._start_pos
-		except AttributeError:
-			self._start_pos = NodePos(self._start_line, self._start_col)
-			return self._start_pos
+    def add_child(self, node):
+        if node:
+            node.node_index = len(self.kids)
+            node.parent = self
+        self.kids.append(node)
+    
+    def start_pos(self):
+        try:
+            return self._start_pos
+        except AttributeError:
+            self._start_pos = NodePos(self._start_line, self._start_col)
+            return self._start_pos
 
-	def end_pos(self):
-		try:
-			return self._end_pos
-		except AttributeError:
-			self._end_pos = NodePos(self._end_line, self._end_col)
-			return self._end_pos
+    def end_pos(self):
+        try:
+            return self._end_pos
+        except AttributeError:
+            self._end_pos = NodePos(self._end_line, self._end_col)
+            return self._end_pos
 
-	def __str__(self):
-		kind = self.kind
-		if not kind:
-			kind = '(none)'
-		return '%s>%s' % (_tok_names[kind], str(self.kids))
+    def __str__(self):
+        kind = self.kind
+        if not kind:
+            kind = '(none)'
+        return '%s>%s' % (_tok_names[kind], str(self.kids))
 
-	def is_equivalent(self, other, are_functions_equiv=False):
-		if not other:
-			return False
+    def is_equivalent(self, other, are_functions_equiv=False):
+        if not other:
+            return False
 
-		# Bail out for functions
-		if not are_functions_equiv:
-			if self.kind == tok.FUNCTION:
-				return False
-			if self.kind == tok.LP and self.opcode == op.CALL:
-				return False
+        # Bail out for functions
+        if not are_functions_equiv:
+            if self.kind == tok.FUNCTION:
+                return False
+            if self.kind == tok.LP and self.opcode == op.CALL:
+                return False
 
-		if self.kind != other.kind:
-			return False
-		if self.opcode != other.opcode:
-			return False
+        if self.kind != other.kind:
+            return False
+        if self.opcode != other.opcode:
+            return False
 
-		# Check atoms on names, properties, and string constants
-		if self.kind in (tok.NAME, tok.DOT, tok.STRING) and self.atom != other.atom:
-			return False
+        # Check atoms on names, properties, and string constants
+        if self.kind in (tok.NAME, tok.DOT, tok.STRING) and self.atom != other.atom:
+            return False
 
-		# Check values on numbers
-		if self.kind == tok.NUMBER and self.dval != other.dval:
-			return False
+        # Check values on numbers
+        if self.kind == tok.NUMBER and self.dval != other.dval:
+            return False
 
-		# Compare child nodes
-		if len(self.kids) != len(other.kids):
-			return False
-		for i in range(0, len(self.kids)):
-			# Watch for dead nodes
-			if not self.kids[i]:
-				if not other.kids[i]: return True
-				else: return False
-			if not self.kids[i].is_equivalent(other.kids[i]):
-				return False
+        # Compare child nodes
+        if len(self.kids) != len(other.kids):
+            return False
+        for i in range(0, len(self.kids)):
+            # Watch for dead nodes
+            if not self.kids[i]:
+                if not other.kids[i]: return True
+                else: return False
+            if not self.kids[i].is_equivalent(other.kids[i]):
+                return False
 
-		return True
+        return True
 
 def _parse_comments(script, root, node_positions, ignore_ranges):
-	pos = 0
-	single_line_re = r"//[^\r\n]*"
-	multi_line_re = r"/\*(.*?)\*/"
-	full_re = "(%s)|(%s)" % (single_line_re, multi_line_re)
-	comment_re = re.compile(full_re, re.DOTALL)
+    pos = 0
+    single_line_re = r"//[^\r\n]*"
+    multi_line_re = r"/\*(.*?)\*/"
+    full_re = "(%s)|(%s)" % (single_line_re, multi_line_re)
+    comment_re = re.compile(full_re, re.DOTALL)
 
-	comments = []
-	while True:
-		match = comment_re.search(script, pos)
-		if not match:
-			return comments
+    comments = []
+    while True:
+        match = comment_re.search(script, pos)
+        if not match:
+            return comments
 
-		# Get the comment text
-		comment_text = script[match.start():match.end()]
-		if comment_text.startswith('/*'):
-			comment_text = comment_text[2:-2]
-			opcode = 'JSOP_C_COMMENT'
-		else:
-			comment_text = comment_text[2:]
-			opcode = 'JSOP_CPP_COMMENT'
-		opcode = opcode[5:].lower()
+        # Get the comment text
+        comment_text = script[match.start():match.end()]
+        if comment_text.startswith('/*'):
+            comment_text = comment_text[2:-2]
+            opcode = 'JSOP_C_COMMENT'
+        else:
+            comment_text = comment_text[2:]
+            opcode = 'JSOP_CPP_COMMENT'
+        opcode = opcode[5:].lower()
 
-		start_offset = match.start()+1
-		end_offset = match.end()
+        start_offset = match.start()+1
+        end_offset = match.end()
 
-		# Make sure it doesn't start in a string or regexp
-		if not ignore_ranges.has(start_offset):
-			start_pos = node_positions.from_offset(start_offset)
-			end_pos = node_positions.from_offset(end_offset)
-			kwargs = {
-				'type': 'COMMENT',
-				'atom': comment_text,
-				'opcode': opcode,
-				'_start_line': start_pos.line,
-				'_start_col': start_pos.col,
-				'_end_line': end_pos.line,
-				'_end_col': end_pos.col,
-				'parent': None,
-				'kids': [],
-				'node_index': None
-			}
-			comment_node = _Node()
-			comment_node.__dict__.update(kwargs)
-			comments.append(comment_node)
-			pos = match.end()
-		else:
-			pos = match.start()+1
+        # Make sure it doesn't start in a string or regexp
+        if not ignore_ranges.has(start_offset):
+            start_pos = node_positions.from_offset(start_offset)
+            end_pos = node_positions.from_offset(end_offset)
+            kwargs = {
+                'type': 'COMMENT',
+                'atom': comment_text,
+                'opcode': opcode,
+                '_start_line': start_pos.line,
+                '_start_col': start_pos.col,
+                '_end_line': end_pos.line,
+                '_end_col': end_pos.col,
+                'parent': None,
+                'kids': [],
+                'node_index': None
+            }
+            comment_node = _Node()
+            comment_node.__dict__.update(kwargs)
+            comments.append(comment_node)
+            pos = match.end()
+        else:
+            pos = match.start()+1
 
 def parse(script, error_callback):
-	def _wrapped_callback(line, col, msg):
-		assert msg.startswith('JSMSG_')
-		msg = msg[6:].lower()
-		error_callback(line, col, msg)
+    def _wrapped_callback(line, col, msg):
+        assert msg.startswith('JSMSG_')
+        msg = msg[6:].lower()
+        error_callback(line, col, msg)
 
-	positions = NodePositions(script)
+    positions = NodePositions(script)
 
-	roots = []
-	nodes = []
-	comment_ignore_ranges = NodeRanges()
-	def process(node):
-		if node.kind == tok.NUMBER:
-			node.atom = positions.text(node.start_pos(), node.end_pos())
-		elif node.kind == tok.STRING or \
-				(node.kind == tok.OBJECT and node.opcode == op.REGEXP):
-			start_offset = positions.to_offset(node.start_pos())
-			end_offset = positions.to_offset(node.end_pos())
-			comment_ignore_ranges.add(start_offset, end_offset)
-		for kid in node.kids:
-			if kid:
-				process(kid)
-	def pop():
-		nodes.pop()
+    roots = []
+    nodes = []
+    comment_ignore_ranges = NodeRanges()
+    def process(node):
+        if node.kind == tok.NUMBER:
+            node.atom = positions.text(node.start_pos(), node.end_pos())
+        elif node.kind == tok.STRING or \
+                (node.kind == tok.OBJECT and node.opcode == op.REGEXP):
+            start_offset = positions.to_offset(node.start_pos())
+            end_offset = positions.to_offset(node.end_pos())
+            comment_ignore_ranges.add(start_offset, end_offset)
+        for kid in node.kids:
+            if kid:
+                process(kid)
+    def pop():
+        nodes.pop()
 
-	root_node = pyspidermonkey.parse(script, _Node, _wrapped_callback)
-	process(root_node)
+    root_node = pyspidermonkey.parse(script, _Node, _wrapped_callback)
+    process(root_node)
 
-	comments = _parse_comments(script, root_node, positions, comment_ignore_ranges)
-	return root_node, comments
+    comments = _parse_comments(script, root_node, positions, comment_ignore_ranges)
+    return root_node, comments
 
 def _dump_node(node, depth=0):
-	print '.	'*depth,
-	if node is None:
-		print '(none)'
-	else:
-		print '%s\t%s, %s' % (_tok_names[node.kind], node.start_pos(), node.end_pos())
-		for node in node.kids:
-			_dump_node(node, depth+1)
+    print '.    '*depth,
+    if node is None:
+        print '(none)'
+    else:
+        print '%s\t%s, %s' % (_tok_names[node.kind], node.start_pos(), node.end_pos())
+        for node in node.kids:
+            _dump_node(node, depth+1)
 
 def dump_tree(script):
-	def error_callback(line, col, msg):
-		print '(%i, %i): %s', (line, col, msg)
-	node, comments = parse(script, error_callback)
-	_dump_node(node)
+    def error_callback(line, col, msg):
+        print '(%i, %i): %s', (line, col, msg)
+    node, comments = parse(script, error_callback)
+    _dump_node(node)
 
 class TestComments(unittest.TestCase):
-	def _test(self, script, expected_comments):
-		root, comments = parse(script, lambda line, col, msg: None)
-		encountered_comments = [node.atom for node in comments]
-		self.assertEquals(encountered_comments, list(expected_comments))
-	def testSimpleComments(self):
-		self._test('re = /\//g', ())
-		self._test('re = /\///g', ())
-		self._test('re = /\////g', ('g',))
-	def testCComments(self):
-		self._test('/*a*//*b*/', ('a', 'b'))
-		self._test('/*a\r\na*//*b\r\nb*/', ('a\r\na', 'b\r\nb'))
-		self._test('a//*b*/c', ('*b*/c',))
-		self._test('a///*b*/c', ('/*b*/c',))
-		self._test('a/*//*/;', ('//',))
-		self._test('a/*b*/+/*c*/d', ('b', 'c'))
+    def _test(self, script, expected_comments):
+        root, comments = parse(script, lambda line, col, msg: None)
+        encountered_comments = [node.atom for node in comments]
+        self.assertEquals(encountered_comments, list(expected_comments))
+    def testSimpleComments(self):
+        self._test('re = /\//g', ())
+        self._test('re = /\///g', ())
+        self._test('re = /\////g', ('g',))
+    def testCComments(self):
+        self._test('/*a*//*b*/', ('a', 'b'))
+        self._test('/*a\r\na*//*b\r\nb*/', ('a\r\na', 'b\r\nb'))
+        self._test('a//*b*/c', ('*b*/c',))
+        self._test('a///*b*/c', ('/*b*/c',))
+        self._test('a/*//*/;', ('//',))
+        self._test('a/*b*/+/*c*/d', ('b', 'c'))
 
 class TestNodePositions(unittest.TestCase):
-	def _test(self, text, expected_lines, expected_cols):
-		# Get a NodePos list
-		positions = NodePositions(text)
-		positions = [positions.from_offset(i) for i in range(0, len(text))]
-		encountered_lines = ''.join([str(x.line) for x in positions])
-		encountered_cols = ''.join([str(x.col) for x in positions])
-		self.assertEquals(encountered_lines, expected_lines.replace(' ', ''))
-		self.assertEquals(encountered_cols, expected_cols.replace(' ', ''))
-	def testSimple(self):
-		self._test(
-			'abc\r\ndef\nghi\n\nj',
-			'0000 0 1111 2222 3 4',
-			'0123 4 0123 0123 0 0'
-		)
-		self._test(
-			'\rabc',
-			'0 111',
-			'0 012'
-		)
-	def testText(self):
-		pos = NodePositions('abc\r\ndef\n\nghi')
-		self.assertEquals(pos.text(NodePos(0, 0), NodePos(0, 0)), 'a')
-		self.assertEquals(pos.text(NodePos(0, 0), NodePos(0, 2)), 'abc')
-		self.assertEquals(pos.text(NodePos(0, 2), NodePos(1, 2)), 'c\r\ndef')
-	def testOffset(self):
-		pos = NodePositions('abc\r\ndef\n\nghi')
-		self.assertEquals(pos.to_offset(NodePos(0, 2)), 2)
-		self.assertEquals(pos.to_offset(NodePos(1, 0)), 5)
-		self.assertEquals(pos.to_offset(NodePos(3, 1)), 11)
+    def _test(self, text, expected_lines, expected_cols):
+        # Get a NodePos list
+        positions = NodePositions(text)
+        positions = [positions.from_offset(i) for i in range(0, len(text))]
+        encountered_lines = ''.join([str(x.line) for x in positions])
+        encountered_cols = ''.join([str(x.col) for x in positions])
+        self.assertEquals(encountered_lines, expected_lines.replace(' ', ''))
+        self.assertEquals(encountered_cols, expected_cols.replace(' ', ''))
+    def testSimple(self):
+        self._test(
+            'abc\r\ndef\nghi\n\nj',
+            '0000 0 1111 2222 3 4',
+            '0123 4 0123 0123 0 0'
+        )
+        self._test(
+            '\rabc',
+            '0 111',
+            '0 012'
+        )
+    def testText(self):
+        pos = NodePositions('abc\r\ndef\n\nghi')
+        self.assertEquals(pos.text(NodePos(0, 0), NodePos(0, 0)), 'a')
+        self.assertEquals(pos.text(NodePos(0, 0), NodePos(0, 2)), 'abc')
+        self.assertEquals(pos.text(NodePos(0, 2), NodePos(1, 2)), 'c\r\ndef')
+    def testOffset(self):
+        pos = NodePositions('abc\r\ndef\n\nghi')
+        self.assertEquals(pos.to_offset(NodePos(0, 2)), 2)
+        self.assertEquals(pos.to_offset(NodePos(1, 0)), 5)
+        self.assertEquals(pos.to_offset(NodePos(3, 1)), 11)
 
 class TestNodeRanges(unittest.TestCase):
-	def testAdd(self):
-		r = NodeRanges()
-		r.add(5, 10)
-		self.assertEquals(r._offsets, [5,11])
-		r.add(15, 20)
-		self.assertEquals(r._offsets, [5,11,15,21])
-		r.add(21,22)
-		self.assertEquals(r._offsets, [5,11,15,23])
-		r.add(4,5)
-		self.assertEquals(r._offsets, [4,11,15,23])
-		r.add(9,11)
-		self.assertEquals(r._offsets, [4,12,15,23])
-		r.add(10,20)
-		self.assertEquals(r._offsets, [4,23])
-		r.add(4,22)
-		self.assertEquals(r._offsets, [4,23])
-		r.add(30,30)
-		self.assertEquals(r._offsets, [4,23,30,31])
-	def testHas(self):
-		r = NodeRanges()
-		r.add(5, 10)
-		r.add(15, 15)
-		assert not r.has(4)
-		assert r.has(5)
-		assert r.has(6)
-		assert r.has(9)
-		assert r.has(10)
-		assert not r.has(14)
-		assert r.has(15)
-		assert not r.has(16)
+    def testAdd(self):
+        r = NodeRanges()
+        r.add(5, 10)
+        self.assertEquals(r._offsets, [5,11])
+        r.add(15, 20)
+        self.assertEquals(r._offsets, [5,11,15,21])
+        r.add(21,22)
+        self.assertEquals(r._offsets, [5,11,15,23])
+        r.add(4,5)
+        self.assertEquals(r._offsets, [4,11,15,23])
+        r.add(9,11)
+        self.assertEquals(r._offsets, [4,12,15,23])
+        r.add(10,20)
+        self.assertEquals(r._offsets, [4,23])
+        r.add(4,22)
+        self.assertEquals(r._offsets, [4,23])
+        r.add(30,30)
+        self.assertEquals(r._offsets, [4,23,30,31])
+    def testHas(self):
+        r = NodeRanges()
+        r.add(5, 10)
+        r.add(15, 15)
+        assert not r.has(4)
+        assert r.has(5)
+        assert r.has(6)
+        assert r.has(9)
+        assert r.has(10)
+        assert not r.has(14)
+        assert r.has(15)
+        assert not r.has(16)
 
 class TestCompilableUnit(unittest.TestCase):
-	def test(self):
-		tests = (
-			('var s = "', False),
-			('bogon()', True),
-			('int syntax_error;', True),
-			('a /* b', False),
-			('re = /.*', False),
-			('{ // missing curly', False)
-		)
-		for text, is_compilable_unit in tests:
-			self.assertEquals(pyspidermonkey.is_compilable_unit(text),
-								is_compilable_unit)
+    def test(self):
+        tests = (
+            ('var s = "', False),
+            ('bogon()', True),
+            ('int syntax_error;', True),
+            ('a /* b', False),
+            ('re = /.*', False),
+            ('{ // missing curly', False)
+        )
+        for text, is_compilable_unit in tests:
+            self.assertEquals(pyspidermonkey.is_compilable_unit(text),
+                                is_compilable_unit)
 
 if __name__ == '__main__':
-	unittest.main()
+    unittest.main()
 

Modified: trunk/pyjsl/lint.py
===================================================================
--- trunk/pyjsl/lint.py	2008-03-20 21:38:49 UTC (rev 177)
+++ trunk/pyjsl/lint.py	2008-03-31 13:45:14 UTC (rev 178)
@@ -11,282 +11,282 @@
 from pyspidermonkey import tok, op
 
 _newline_kinds = (
-	'eof', 'comma', 'dot', 'semi', 'colon', 'lc', 'rc', 'lp', 'rb', 'assign',
-	'relop', 'hook', 'plus', 'minus', 'star', 'divop', 'eqop', 'shop', 'or',
-	'and', 'bitor', 'bitxor', 'bitand', 'else', 'try'
+    'eof', 'comma', 'dot', 'semi', 'colon', 'lc', 'rc', 'lp', 'rb', 'assign',
+    'relop', 'hook', 'plus', 'minus', 'star', 'divop', 'eqop', 'shop', 'or',
+    'and', 'bitor', 'bitxor', 'bitand', 'else', 'try'
 ) 
 
 _globals = frozenset([
-	'Array', 'Boolean', 'Math', 'Number', 'String', 'RegExp', 'Script', 'Date',
-	'isNaN', 'isFinite', 'parseFloat', 'parseInt',
-	'eval', 'NaN', 'Infinity',
-	'escape', 'unescape', 'uneval',
-	'decodeURI', 'encodeURI', 'decodeURIComponent', 'encodeURIComponent',
-	'Function', 'Object', 
-	'Error', 'InternalError', 'EvalError', 'RangeError', 'ReferenceError',
-	'SyntaxError', 'TypeError', 'URIError',
-	'arguments', 'undefined'
+    'Array', 'Boolean', 'Math', 'Number', 'String', 'RegExp', 'Script', 'Date',
+    'isNaN', 'isFinite', 'parseFloat', 'parseInt',
+    'eval', 'NaN', 'Infinity',
+    'escape', 'unescape', 'uneval',
+    'decodeURI', 'encodeURI', 'decodeURIComponent', 'encodeURIComponent',
+    'Function', 'Object', 
+    'Error', 'InternalError', 'EvalError', 'RangeError', 'ReferenceError',
+    'SyntaxError', 'TypeError', 'URIError',
+    'arguments', 'undefined'
 ])
 
 _identifier = re.compile('^[A-Za-z_$][A-Za-z0-9_$]*$')
 
 def _find_function(node):
-	while node and node.kind != tok.FUNCTION:
-		node = node.parent
-	return node
+    while node and node.kind != tok.FUNCTION:
+        node = node.parent
+    return node
 
 def _find_functions(node):
-	functions = []
-	while node:
-		if node.kind == tok.FUNCTION:
-			functions.append(node)
-		node = node.parent
-	return functions
+    functions = []
+    while node:
+        if node.kind == tok.FUNCTION:
+            functions.append(node)
+        node = node.parent
+    return functions
 
 def _parse_control_comment(comment):
-	""" Returns None or (keyword, parms) """
-	if comment.atom.lower().startswith('jsl:'):
-		control_comment = comment.atom[4:]
-	elif comment.atom.startswith('@') and comment.atom.endswith('@'):
-		control_comment = comment.atom[1:-1]
-	else:
-		return None
+    """ Returns None or (keyword, parms) """
+    if comment.atom.lower().startswith('jsl:'):
+        control_comment = comment.atom[4:]
+    elif comment.atom.startswith('@') and comment.atom.endswith('@'):
+        control_comment = comment.atom[1:-1]
+    else:
+        return None
 
-	control_comments = {
-		'ignoreall': (False),
-		'ignore': (False),
-		'end': (False),
-		'option explicit': (False),
-		'import': (True),
-		'fallthru': (False),
-		'pass': (False),
-		'declare': (True)
-	}
-	if control_comment.lower() in control_comments:
-		keyword = control_comment.lower()
-	else:
-		keyword = control_comment.lower().split()[0]
-		if not keyword in control_comments:
-			return None
+    control_comments = {
+        'ignoreall': (False),
+        'ignore': (False),
+        'end': (False),
+        'option explicit': (False),
+        'import': (True),
+        'fallthru': (False),
+        'pass': (False),
+        'declare': (True)
+    }
+    if control_comment.lower() in control_comments:
+        keyword = control_comment.lower()
+    else:
+        keyword = control_comment.lower().split()[0]
+        if not keyword in control_comments:
+            return None
 
-	parms = control_comment[len(keyword):].strip()
-	return (comment, keyword, parms)
+    parms = control_comment[len(keyword):].strip()
+    return (comment, keyword, parms)
 
 class Scope:
-	def __init__(self, node):
-		self._is_with_scope = node.kind == tok.WITH
-		self._parent = None
-		self._kids = []
-		self._identifiers = {}
-		self._references = []
-		self._node = node
-	def add_scope(self, node):
-		self._kids.append(Scope(node))
-		self._kids[-1]._parent = self
-		if self._is_with_scope:
-			self._kids[-1]._is_with_scope = True
-		return self._kids[-1]
-	def add_declaration(self, name, node):
-		if not self._is_with_scope:
-			self._identifiers[name] = node
-	def add_reference(self, name, node):
-		if not self._is_with_scope:
-			self._references.append((name, node))
-	def get_identifier(self, name):
-		if name in self._identifiers:
-			return self._identifiers[name]
-		else:
-			return None
-	def get_identifiers(self):
-		"returns a list of names"
-		return self._identifiers.keys()
-	def resolve_identifier(self, name):
-		if name in self._identifiers:
-			return self, self._identifiers[name]
-		if self._parent:
-			return self._parent.resolve_identifier(name)
-		return None
-	def get_undeclared_identifiers(self):
-		identifiers = []
-		for child in self._kids:
-			identifiers += child.get_undeclared_identifiers()
-		for name, node in self._references:
-			if not self.resolve_identifier(name):
-				identifiers.append(node)
-		return identifiers
-	def find_scope(self, node):
-		for kid in self._kids:
-			scope = kid.find_scope(node)
-			if scope:
-				return scope
+    def __init__(self, node):
+        self._is_with_scope = node.kind == tok.WITH
+        self._parent = None
+        self._kids = []
+        self._identifiers = {}
+        self._references = []
+        self._node = node
+    def add_scope(self, node):
+        self._kids.append(Scope(node))
+        self._kids[-1]._parent = self
+        if self._is_with_scope:
+            self._kids[-1]._is_with_scope = True
+        return self._kids[-1]
+    def add_declaration(self, name, node):
+        if not self._is_with_scope:
+            self._identifiers[name] = node
+    def add_reference(self, name, node):
+        if not self._is_with_scope:
+            self._references.append((name, node))
+    def get_identifier(self, name):
+        if name in self._identifiers:
+            return self._identifiers[name]
+        else:
+            return None
+    def get_identifiers(self):
+        "returns a list of names"
+        return self._identifiers.keys()
+    def resolve_identifier(self, name):
+        if name in self._identifiers:
+            return self, self._identifiers[name]
+        if self._parent:
+            return self._parent.resolve_identifier(name)
+        return None
+    def get_undeclared_identifiers(self):
+        identifiers = []
+        for child in self._kids:
+            identifiers += child.get_undeclared_identifiers()
+        for name, node in self._references:
+            if not self.resolve_identifier(name):
+                identifiers.append(node)
+        return identifiers
+    def find_scope(self, node):
+        for kid in self._kids:
+            scope = kid.find_scope(node)
+            if scope:
+                return scope
 
-		# Always add it to the outer scope.
-		if not self._parent or \
-			(node.start_pos() >= self._node.start_pos() and \
-			node.end_pos() <= self._node.end_pos()):
-			return self
+        # Always add it to the outer scope.
+        if not self._parent or \
+            (node.start_pos() >= self._node.start_pos() and \
+            node.end_pos() <= self._node.end_pos()):
+            return self
 
-		return None
+        return None
 
 def lint_files(paths, lint_error, conf=conf.Conf()):
-	def lint_file(path):
-		def import_script(import_path):
-			import_path = os.path.join(os.path.dirname(path), import_path)
-			return lint_file(import_path)
-		def _lint_error(*args):
-			return lint_error(normpath, *args)
+    def lint_file(path):
+        def import_script(import_path):
+            import_path = os.path.join(os.path.dirname(path), import_path)
+            return lint_file(import_path)
+        def _lint_error(*args):
+            return lint_error(normpath, *args)
 
-		normpath = util.normpath(path)
-		if not normpath in lint_cache:
-			lint_cache[normpath] = {}
-			script = util.readfile(path)
-			print normpath
-			_lint_script(script, lint_cache[normpath], _lint_error, conf, import_script)
-		return lint_cache[normpath]
+        normpath = util.normpath(path)
+        if not normpath in lint_cache:
+            lint_cache[normpath] = {}
+            script = util.readfile(path)
+            print normpath
+            _lint_script(script, lint_cache[normpath], _lint_error, conf, import_script)
+        return lint_cache[normpath]
 
-	lint_cache = {}
-	for path in paths:
-		lint_file(path)
+    lint_cache = {}
+    for path in paths:
+        lint_file(path)
 
 def _lint_script(script, script_cache, lint_error, conf, import_callback):
-	def parse_error(row, col, msg):
-		if not msg in ('redeclared_var', 'var_hides_arg'):
-				parse_errors.append((jsparse.NodePos(row, col), msg))
+    def parse_error(row, col, msg):
+        if not msg in ('redeclared_var', 'var_hides_arg'):
+                parse_errors.append((jsparse.NodePos(row, col), msg))
 
-	def report(node, errname):
-		_report(node.start_pos(), errname, True)
+    def report(node, errname):
+        _report(node.start_pos(), errname, True)
 
-	def _report(pos, errname, require_key):
-		try:
-			if not conf[errname]:
-				return
-		except KeyError, err:
-			if require_key:
-				raise
+    def _report(pos, errname, require_key):
+        try:
+            if not conf[errname]:
+                return
+        except KeyError, err:
+            if require_key:
+                raise
 
-		for start, end in ignores:
-			if pos >= start and pos <= end:
-				return
+        for start, end in ignores:
+            if pos >= start and pos <= end:
+                return
 
-		return lint_error(pos.line, pos.col, errname)
+        return lint_error(pos.line, pos.col, errname)
 
-	parse_errors = []
-	root, comments = jsparse.parse(script, parse_error)
-	ignores = []
-	start_ignore = None
-	declares = []
-	import_paths = []
-	for comment in comments:
-		cc = _parse_control_comment(comment)
-		if cc:
-			node, keyword, parms = cc
-			if keyword == 'declare':
-				if not _identifier.match(parms):
-					report(node, 'jsl_cc_not_understood')
-				else:
-					declares.append((parms, node))
-			elif keyword == 'ignore':
-				if start_ignore:
-					report(node, 'mismatch_ctrl_comments')
-				else:
-					start_ignore = node
-			elif keyword == 'end':
-				if start_ignore:
-					ignores.append((start_ignore.start_pos(), node.end_pos()))
-					start_ignore = None
-				else:
-					report(node, 'mismatch_ctrl_comments')
-			elif keyword == 'import':
-				if not parms:
-					report(node, 'jsl_cc_not_understood')
-				else:
-					import_paths.append(parms)
-		else:
-			if comment.opcode == 'c_comment':
-				if '/*' in comment.atom or comment.atom.endswith('/'):
-					report(comment, 'nested_comment')
-			if comment.atom.lower().startswith('jsl:'):
-				report(comment, 'jsl_cc_not_understood')
-			elif comment.atom.startswith('@'):
-				report(comment, 'legacy_cc_not_understood')
-	if start_ignore:
-		report(start_ignore, 'mismatch_ctrl_comments')
+    parse_errors = []
+    root, comments = jsparse.parse(script, parse_error)
+    ignores = []
+    start_ignore = None
+    declares = []
+    import_paths = []
+    for comment in comments:
+        cc = _parse_control_comment(comment)
+        if cc:
+            node, keyword, parms = cc
+            if keyword == 'declare':
+                if not _identifier.match(parms):
+                    report(node, 'jsl_cc_not_understood')
+                else:
+                    declares.append((parms, node))
+            elif keyword == 'ignore':
+                if start_ignore:
+                    report(node, 'mismatch_ctrl_comments')
+                else:
+                    start_ignore = node
+            elif keyword == 'end':
+                if start_ignore:
+                    ignores.append((start_ignore.start_pos(), node.end_pos()))
+                    start_ignore = None
+                else:
+                    report(node, 'mismatch_ctrl_comments')
+            elif keyword == 'import':
+                if not parms:
+                    report(node, 'jsl_cc_not_understood')
+                else:
+                    import_paths.append(parms)
+        else:
+            if comment.opcode == 'c_comment':
+                if '/*' in comment.atom or comment.atom.endswith('/'):
+                    report(comment, 'nested_comment')
+            if comment.atom.lower().startswith('jsl:'):
+                report(comment, 'jsl_cc_not_understood')
+            elif comment.atom.startswith('@'):
+                report(comment, 'legacy_cc_not_understood')
+    if start_ignore:
+        report(start_ignore, 'mismatch_ctrl_comments')
 
-	# Wait to report parse errors until loading jsl:ignore directives.
-	for pos, msg in parse_errors:
-		_report(pos, msg, False)
+    # Wait to report parse errors until loading jsl:ignore directives.
+    for pos, msg in parse_errors:
+        _report(pos, msg, False)
 
-	visitors = visitation.make_visitors(warnings.klasses)
+    visitors = visitation.make_visitors(warnings.klasses)
 
-	assert not script_cache
-	imports = script_cache['imports'] = set()
-	scope = script_cache['scope'] = Scope(root)
+    assert not script_cache
+    imports = script_cache['imports'] = set()
+    scope = script_cache['scope'] = Scope(root)
 
-	# kickoff!
-	_lint_node(root, visitors, report, scope)
+    # kickoff!
+    _lint_node(root, visitors, report, scope)
 
-	# Process imports by copying global declarations into the universal scope.
-	imports |= set(conf['declarations'])
-	imports |= _globals
-	for path in import_paths:
-		cache = import_callback(path)
-		imports |= cache['imports']
-		imports |= set(cache['scope'].get_identifiers())
+    # Process imports by copying global declarations into the universal scope.
+    imports |= set(conf['declarations'])
+    imports |= _globals
+    for path in import_paths:
+        cache = import_callback(path)
+        imports |= cache['imports']
+        imports |= set(cache['scope'].get_identifiers())
 
-	for name, node in declares:
-		declare_scope = scope.find_scope(node)
-		if declare_scope.get_identifier(name):
-			report(node, 'redeclared_var')
-		else:
-			declare_scope.add_declaration(name, node)
+    for name, node in declares:
+        declare_scope = scope.find_scope(node)
+        if declare_scope.get_identifier(name):
+            report(node, 'redeclared_var')
+        else:
+            declare_scope.add_declaration(name, node)
 
-	for node in scope.get_undeclared_identifiers():
-		if not node.atom in imports:
-			report(node, 'undeclared_identifier')
+    for node in scope.get_undeclared_identifiers():
+        if not node.atom in imports:
+            report(node, 'undeclared_identifier')
 
 def _lint_node(node, visitors, report, scope):
 
-	def warn_or_declare(name, node):
-		other = scope.get_identifier(name)
-		if other and other.kind == tok.FUNCTION and name in other.fn_args:
-			report(node, 'var_hides_arg')
-		elif other:
-			report(node, 'redeclared_var')
-		else:
-			scope.add_declaration(name, node)
+    def warn_or_declare(name, node):
+        other = scope.get_identifier(name)
+        if other and other.kind == tok.FUNCTION and name in other.fn_args:
+            report(node, 'var_hides_arg')
+        elif other:
+            report(node, 'redeclared_var')
+        else:
+            scope.add_declaration(name, node)
 
-	# Let the visitors warn.
-	for kind in (node.kind, (node.kind, node.opcode)):
-		if kind in visitors:
-			for visitor in visitors[kind]:
-				warning_node = visitor(node)
-				if warning_node:
-					report(warning_node, visitor.im_class.__name__)
+    # Let the visitors warn.
+    for kind in (node.kind, (node.kind, node.opcode)):
+        if kind in visitors:
+            for visitor in visitors[kind]:
+                warning_node = visitor(node)
+                if warning_node:
+                    report(warning_node, visitor.im_class.__name__)
 
-	if node.kind == tok.NAME:
-		if node.node_index == 0 and node.parent.kind == tok.COLON and node.parent.parent.kind == tok.RC:
-			pass # left side of object literal
-		elif node.parent.kind == tok.CATCH:
-			scope.add_declaration(node.atom, node)
-		else:
-			scope.add_reference(node.atom, node)
+    if node.kind == tok.NAME:
+        if node.node_index == 0 and node.parent.kind == tok.COLON and node.parent.parent.kind == tok.RC:
+            pass # left side of object literal
+        elif node.parent.kind == tok.CATCH:
+            scope.add_declaration(node.atom, node)
+        else:
+            scope.add_reference(node.atom, node)
 
-	# Push function identifiers
-	if node.kind == tok.FUNCTION:
-		if node.fn_name:
-			warn_or_declare(node.fn_name, node)
-		scope = scope.add_scope(node)
-		for var_name in node.fn_args:
-			scope.add_declaration(var_name, node)
-	elif node.kind == tok.LEXICALSCOPE:
-		scope = scope.add_scope(node)
-	elif node.kind == tok.WITH:
-		scope = scope.add_scope(node)
+    # Push function identifiers
+    if node.kind == tok.FUNCTION:
+        if node.fn_name:
+            warn_or_declare(node.fn_name, node)
+        scope = scope.add_scope(node)
+        for var_name in node.fn_args:
+            scope.add_declaration(var_name, node)
+    elif node.kind == tok.LEXICALSCOPE:
+        scope = scope.add_scope(node)
+    elif node.kind == tok.WITH:
+        scope = scope.add_scope(node)
 
-	if node.parent and node.parent.kind == tok.VAR:
-		warn_or_declare(node.atom, node)
+    if node.parent and node.parent.kind == tok.VAR:
+        warn_or_declare(node.atom, node)
 
-	for child in node.kids:
-		if child:
-			_lint_node(child, visitors, report, scope)
+    for child in node.kids:
+        if child:
+            _lint_node(child, visitors, report, scope)
 

Modified: trunk/pyjsl/util.py
===================================================================
--- trunk/pyjsl/util.py	2008-03-20 21:38:49 UTC (rev 177)
+++ trunk/pyjsl/util.py	2008-03-31 13:45:14 UTC (rev 178)
@@ -2,15 +2,15 @@
 import os.path
 
 def readfile(path):
-	file = codecs.open(path, 'r', 'utf-8')
-	contents = file.read()
-	if contents[0] == unicode(codecs.BOM_UTF8, 'utf8'):
-		contents = contents[1:]
-	return contents
+    file = codecs.open(path, 'r', 'utf-8')
+    contents = file.read()
+    if contents[0] == unicode(codecs.BOM_UTF8, 'utf8'):
+        contents = contents[1:]
+    return contents
 
 def normpath(path):
-	path = os.path.abspath(path)
-	path = os.path.normcase(path)
-	path = os.path.normpath(path)
-	return path
+    path = os.path.abspath(path)
+    path = os.path.normcase(path)
+    path = os.path.normpath(path)
+    return path
 

Modified: trunk/pyjsl/visitation.py
===================================================================
--- trunk/pyjsl/visitation.py	2008-03-20 21:38:49 UTC (rev 177)
+++ trunk/pyjsl/visitation.py	2008-03-31 13:45:14 UTC (rev 178)
@@ -3,33 +3,33 @@
 """
 
 def visit(*args):
-	""" This decorator is used to indicate which nodes the function should
-	examine. The function should accept (self, node) and return	the relevant
-	node or None. """
-	def _decorate(fn):
-		fn._visit_nodes = args
-		return fn
-	return _decorate
+    """ This decorator is used to indicate which nodes the function should
+    examine. The function should accept (self, node) and return the relevant
+    node or None. """
+    def _decorate(fn):
+        fn._visit_nodes = args
+        return fn
+    return _decorate
 
 def make_visitors(klasses):
-	""" Searches klasses for all member functions decorated with @visit and
-	returns a dictionary that maps from node type to visitor function. """
-	visitors = {}
+    """ Searches klasses for all member functions decorated with @visit and
+    returns a dictionary that maps from node type to visitor function. """
+    visitors = {}
 
-	# Intantiate an instance of each class
-	for klass in klasses:
-		if klass.__name__.lower() != klass.__name__:
-			raise ValueError, 'class names must be lowercase'
-		if not klass.__doc__:
-			raise ValueError, 'missing docstring on class'
+    # Intantiate an instance of each class
+    for klass in klasses:
+        if klass.__name__.lower() != klass.__name__:
+            raise ValueError, 'class names must be lowercase'
+        if not klass.__doc__:
+            raise ValueError, 'missing docstring on class'
 
-		# Look for functions with the "_visit_nodes" property.
-		visitor = klass()
-		for func in [getattr(visitor, name) for name in dir(visitor)]:
-			for node_kind in getattr(func, '_visit_nodes', ()):
-				# Map from node_kind to the function
-				if not node_kind in visitors:
-					visitors[node_kind] = []
-				visitors[node_kind].append(func)
-	return visitors
+        # Look for functions with the "_visit_nodes" property.
+        visitor = klass()
+        for func in [getattr(visitor, name) for name in dir(visitor)]:
+            for node_kind in getattr(func, '_visit_nodes', ()):
+                # Map from node_kind to the function
+                if not node_kind in visitors:
+                    visitors[node_kind] = []
+                visitors[node_kind].append(func)
+    return visitors
 

Modified: trunk/pyjsl/warnings.py
===================================================================
--- trunk/pyjsl/warnings.py	2008-03-20 21:38:49 UTC (rev 177)
+++ trunk/pyjsl/warnings.py	2008-03-31 13:45:14 UTC (rev 178)
@@ -10,12 +10,12 @@
 
 For example:
 
-	class warning_name:
-		'questionable JavaScript coding style'
-		@lookat(tok.NODEKIND, (tok.NODEKIND, op.OPCODE))
-		def _lint(self, node):
-			if questionable:
-				return node
+    class warning_name:
+        'questionable JavaScript coding style'
+        @lookat(tok.NODEKIND, (tok.NODEKIND, op.OPCODE))
+        def _lint(self, node):
+            if questionable:
+                return node
 """
 import re
 import sys
@@ -27,468 +27,468 @@
 # TODO: document inspect, node:opcode, etc
 
 def _get_branch_in_for(node):
-		" Returns None if this is not one of the branches in a 'for' "
-		if node.parent and node.parent.kind == tok.RESERVED and \
-			node.parent.parent.kind == tok.FOR:
-			return node.node_index
-		return None
+        " Returns None if this is not one of the branches in a 'for' "
+        if node.parent and node.parent.kind == tok.RESERVED and \
+            node.parent.parent.kind == tok.FOR:
+            return node.node_index
+        return None
 
 def _get_exit_points(node):
-	if node.kind == tok.LC:
-		# Only if the last child contains it
-		exit_points = set([None])
-		for kid in node.kids:
-			# "None" is only a valid exit point for the last statement.
-			if None in exit_points:
-				exit_points.remove(None)
-			if kid:
-				exit_points |= _get_exit_points(kid)
-	elif node.kind == tok.IF:
-		# Only if both branches have an exit point
-		cond_, if_, else_ = node.kids
-		exit_points = _get_exit_points(if_)
-		if else_:
-			exit_points |= _get_exit_points(else_)
-	elif node.kind == tok.SWITCH:
-		exit_points = set([None])
+    if node.kind == tok.LC:
+        # Only if the last child contains it
+        exit_points = set([None])
+        for kid in node.kids:
+            # "None" is only a valid exit point for the last statement.
+            if None in exit_points:
+                exit_points.remove(None)
+            if kid:
+                exit_points |= _get_exit_points(kid)
+    elif node.kind == tok.IF:
+        # Only if both branches have an exit point
+        cond_, if_, else_ = node.kids
+        exit_points = _get_exit_points(if_)
+        if else_:
+            exit_points |= _get_exit_points(else_)
+    elif node.kind == tok.SWITCH:
+        exit_points = set([None])
 
-		switch_has_default = False
-		switch_has_final_fallthru = True
+        switch_has_default = False
+        switch_has_final_fallthru = True
 
-		switch_var, switch_stmts = node.kids
-		for node in switch_stmts.kids:
-			case_val, case_stmt = node.kids
-			case_exit_points = _get_exit_points(case_stmt)
-			switch_has_default = switch_has_default or node.kind == tok.DEFAULT
-			switch_has_final_fallthru = None in case_exit_points
-			exit_points |= case_exit_points
+        switch_var, switch_stmts = node.kids
+        for node in switch_stmts.kids:
+            case_val, case_stmt = node.kids
+            case_exit_points = _get_exit_points(case_stmt)
+            switch_has_default = switch_has_default or node.kind == tok.DEFAULT
+            switch_has_final_fallthru = None in case_exit_points
+            exit_points |= case_exit_points
 
-		# Correct the "None" exit point.
-		exi...
 
[truncated message content]