check-code: check txt files for trailing whitespace

contrib/check-code.py

@@ -1,465 +1,475
 #!/usr/bin/env python
 #
 # check-code - a style and portability checker for Mercurial
 #
 # Copyright 2010 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import re, glob, os, sys
 import keyword
 import optparse
 
 def repquote(m):
     t = re.sub(r"\w", "x", m.group('text'))
     t = re.sub(r"[^\s\nx]", "o", t)
     return m.group('quote') + t + m.group('quote')
 
 def reppython(m):
     comment = m.group('comment')
     if comment:
         l = len(comment.rstrip())
         return "#" * l + comment[l:]
     return repquote(m)
 
 def repcomment(m):
     return m.group(1) + "#" * len(m.group(2))
 
 def repccomment(m):
     t = re.sub(r"((?<=\n) )|\S", "x", m.group(2))
     return m.group(1) + t + "*/"
 
 def repcallspaces(m):
     t = re.sub(r"\n\s+", "\n", m.group(2))
     return m.group(1) + t
 
 def repinclude(m):
     return m.group(1) + "<foo>"
 
 def rephere(m):
     t = re.sub(r"\S", "x", m.group(2))
     return m.group(1) + t
 
 
 testpats = [
   [
     (r'pushd|popd', "don't use 'pushd' or 'popd', use 'cd'"),
     (r'\W\$?\(\([^\)\n]*\)\)', "don't use (()) or $(()), use 'expr'"),
     (r'grep.*-q', "don't use 'grep -q', redirect to /dev/null"),
     (r'sed.*-i', "don't use 'sed -i', use a temporary file"),
     (r'\becho\b.*\\n', "don't use 'echo \\n', use printf"),
     (r'echo -n', "don't use 'echo -n', use printf"),
     (r'(^| )wc[^|]*$\n(?!.*\(re\))', "filter wc output"),
     (r'head -c', "don't use 'head -c', use 'dd'"),
     (r'sha1sum', "don't use sha1sum, use $TESTDIR/md5sum.py"),
     (r'ls.*-\w*R', "don't use 'ls -R', use 'find'"),
     (r'printf.*\\([1-9]|0\d)', "don't use 'printf \NNN', use Python"),
     (r'printf.*\\x', "don't use printf \\x, use Python"),
     (r'\$\(.*\)', "don't use $(expr), use `expr`"),
     (r'rm -rf \*', "don't use naked rm -rf, target a directory"),
     (r'(^|\|\s*)grep (-\w\s+)*[^|]*[(|]\w',
      "use egrep for extended grep syntax"),
     (r'/bin/', "don't use explicit paths for tools"),
     (r'[^\n]\Z', "no trailing newline"),
     (r'export.*=', "don't export and assign at once"),
     (r'^source\b', "don't use 'source', use '.'"),
     (r'touch -d', "don't use 'touch -d', use 'touch -t' instead"),
     (r'ls +[^|\n-]+ +-', "options to 'ls' must come before filenames"),
     (r'[^>\n]>\s*\$HGRCPATH', "don't overwrite $HGRCPATH, append to it"),
     (r'^stop\(\)', "don't use 'stop' as a shell function name"),
     (r'(\[|\btest\b).*-e ', "don't use 'test -e', use 'test -f'"),
     (r'^alias\b.*=', "don't use alias, use a function"),
     (r'if\s*!', "don't use '!' to negate exit status"),
     (r'/dev/u?random', "don't use entropy, use /dev/zero"),
     (r'do\s*true;\s*done', "don't use true as loop body, use sleep 0"),
     (r'^( *)\t', "don't use tabs to indent"),
   ],
   # warnings
   [
     (r'^function', "don't use 'function', use old style"),
     (r'^diff.*-\w*N', "don't use 'diff -N'"),
     (r'\$PWD|\${PWD}', "don't use $PWD, use `pwd`"),
     (r'^([^"\'\n]|("[^"\n]*")|(\'[^\'\n]*\'))*\^', "^ must be quoted"),
     (r'kill (`|\$\()', "don't use kill, use killdaemons.py")
   ]
 ]
 
 testfilters = [
     (r"( *)(#([^\n]*\S)?)", repcomment),
     (r"<<(\S+)((.|\n)*?\n\1)", rephere),
 ]
 
 winglobmsg = "use (glob) to match Windows paths too"
 uprefix = r"^  \$ "
 utestpats = [
   [
     (r'^(\S.*||  [$>] .*)[ \t]\n', "trailing whitespace on non-output"),
     (uprefix + r'.*\|\s*sed[^|>\n]*\n',
      "use regex test output patterns instead of sed"),
     (uprefix + r'(true|exit 0)', "explicit zero exit unnecessary"),
     (uprefix + r'.*(?<!\[)\$\?', "explicit exit code checks unnecessary"),
     (uprefix + r'.*\|\| echo.*(fail|error)',
      "explicit exit code checks unnecessary"),
     (uprefix + r'set -e', "don't use set -e"),
     (uprefix + r'\s', "don't indent commands, use > for continued lines"),
     (r'^  saved backup bundle to \$TESTTMP.*\.hg$', winglobmsg),
     (r'^  changeset .* references (corrupted|missing) \$TESTTMP/.*[^)]$',
      winglobmsg),
     (r'^  pulling from \$TESTTMP/.*[^)]$', winglobmsg, '\$TESTTMP/unix-repo$'),
   ],
   # warnings
   [
     (r'^  [^*?/\n]* \(glob\)$',
      "warning: glob match with no glob character (?*/)"),
   ]
 ]
 
 for i in [0, 1]:
     for p, m in testpats[i]:
         if p.startswith(r'^'):
             p = r"^  [$>] (%s)" % p[1:]
         else:
             p = r"^  [$>] .*(%s)" % p
         utestpats[i].append((p, m))
 
 utestfilters = [
     (r"<<(\S+)((.|\n)*?\n  > \1)", rephere),
     (r"( *)(#([^\n]*\S)?)", repcomment),
 ]
 
 pypats = [
   [
     (r'^\s*def\s*\w+\s*\(.*,\s*\(',
      "tuple parameter unpacking not available in Python 3+"),
     (r'lambda\s*\(.*,.*\)',
      "tuple parameter unpacking not available in Python 3+"),
     (r'(?<!def)\s+(cmp)\(', "cmp is not available in Python 3+"),
     (r'\breduce\s*\(.*', "reduce is not available in Python 3+"),
     (r'\.has_key\b', "dict.has_key is not available in Python 3+"),
     (r'\s<>\s', '<> operator is not available in Python 3+, use !='),
     (r'^\s*\t', "don't use tabs"),
     (r'\S;\s*\n', "semicolon"),
     (r'[^_]_\("[^"]+"\s*%', "don't use % inside _()"),
     (r"[^_]_\('[^']+'\s*%", "don't use % inside _()"),
     (r'(\w|\)),\w', "missing whitespace after ,"),
     (r'(\w|\))[+/*\-<>]\w', "missing whitespace in expression"),
     (r'^\s+(\w|\.)+=\w[^,()\n]*$', "missing whitespace in assignment"),
     (r'(\s+)try:\n((?:\n|\1\s.*\n)+?)\1except.*?:\n'
      r'((?:\n|\1\s.*\n)+?)\1finally:', 'no try/except/finally in Python 2.4'),
     (r'(\s+)try:\n((?:\n|\1\s.*\n)*?)\1\s*yield\b.*?'
      r'((?:\n|\1\s.*\n)+?)\1finally:',
      'no yield inside try/finally in Python 2.4'),
     (r'.{81}', "line too long"),
     (r' x+[xo][\'"]\n\s+[\'"]x', 'string join across lines with no space'),
     (r'[^\n]\Z', "no trailing newline"),
     (r'(\S[ \t]+|^[ \t]+)\n', "trailing whitespace"),
 #    (r'^\s+[^_ \n][^_. \n]+_[^_\n]+\s*=',
 #     "don't use underbars in identifiers"),
     (r'^\s+(self\.)?[A-za-z][a-z0-9]+[A-Z]\w* = ',
      "don't use camelcase in identifiers"),
     (r'^\s*(if|while|def|class|except|try)\s[^[\n]*:\s*[^\\n]#\s]+',
      "linebreak after :"),
     (r'class\s[^( \n]+:', "old-style class, use class foo(object)"),
     (r'class\s[^( \n]+\(\):',
      "class foo() not available in Python 2.4, use class foo(object)"),
     (r'\b(%s)\(' % '|'.join(keyword.kwlist),
      "Python keyword is not a function"),
     (r',]', "unneeded trailing ',' in list"),
 #    (r'class\s[A-Z][^\(]*\((?!Exception)',
 #     "don't capitalize non-exception classes"),
 #    (r'in range\(', "use xrange"),
 #    (r'^\s*print\s+', "avoid using print in core and extensions"),
     (r'[\x80-\xff]', "non-ASCII character literal"),
     (r'("\')\.format\(', "str.format() not available in Python 2.4"),
     (r'^\s*with\s+', "with not available in Python 2.4"),
     (r'\.isdisjoint\(', "set.isdisjoint not available in Python 2.4"),
     (r'^\s*except.* as .*:', "except as not available in Python 2.4"),
     (r'^\s*os\.path\.relpath', "relpath not available in Python 2.4"),
     (r'(?<!def)\s+(any|all|format)\(',
      "any/all/format not available in Python 2.4"),
     (r'(?<!def)\s+(callable)\(',
      "callable not available in Python 3, use getattr(f, '__call__', None)"),
     (r'if\s.*\selse', "if ... else form not available in Python 2.4"),
     (r'^\s*(%s)\s\s' % '|'.join(keyword.kwlist),
      "gratuitous whitespace after Python keyword"),
     (r'([\(\[][ \t]\S)|(\S[ \t][\)\]])', "gratuitous whitespace in () or []"),
 #    (r'\s\s=', "gratuitous whitespace before ="),
     (r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S',
      "missing whitespace around operator"),
     (r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\s',
      "missing whitespace around operator"),
     (r'\s(\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S',
      "missing whitespace around operator"),
     (r'[^^+=*/!<>&| %-](\s=|=\s)[^= ]',
      "wrong whitespace around ="),
     (r'raise Exception', "don't raise generic exceptions"),
     (r'raise [^,(]+, (\([^\)]+\)|[^,\(\)]+)$',
      "don't use old-style two-argument raise, use Exception(message)"),
     (r' is\s+(not\s+)?["\'0-9-]', "object comparison with literal"),
     (r' [=!]=\s+(True|False|None)',
      "comparison with singleton, use 'is' or 'is not' instead"),
     (r'^\s*(while|if) [01]:',
      "use True/False for constant Boolean expression"),
     (r'(?:(?<!def)\s+|\()hasattr',
      'hasattr(foo, bar) is broken, use util.safehasattr(foo, bar) instead'),
     (r'opener\([^)]*\).read\(',
      "use opener.read() instead"),
     (r'BaseException', 'not in Python 2.4, use Exception'),
     (r'os\.path\.relpath', 'os.path.relpath is not in Python 2.5'),
     (r'opener\([^)]*\).write\(',
      "use opener.write() instead"),
     (r'[\s\(](open|file)\([^)]*\)\.read\(',
      "use util.readfile() instead"),
     (r'[\s\(](open|file)\([^)]*\)\.write\(',
      "use util.readfile() instead"),
     (r'^[\s\(]*(open(er)?|file)\([^)]*\)',
      "always assign an opened file to a variable, and close it afterwards"),
     (r'[\s\(](open|file)\([^)]*\)\.',
      "always assign an opened file to a variable, and close it afterwards"),
     (r'(?i)descendent', "the proper spelling is descendAnt"),
     (r'\.debug\(\_', "don't mark debug messages for translation"),
     (r'\.strip\(\)\.split\(\)', "no need to strip before splitting"),
     (r'^\s*except\s*:', "naked except clause", r'#.*re-raises'),
     (r':\n(    )*( ){1,3}[^ ]', "must indent 4 spaces"),
     (r'ui\.(status|progress|write|note|warn)\([\'\"]x',
      "missing _() in ui message (use () to hide false-positives)"),
   ],
   # warnings
   [
   ]
 ]
 
 pyfilters = [
     (r"""(?msx)(?P<comment>\#.*?$)|
          ((?P<quote>('''|\"\"\"|(?<!')'(?!')|(?<!")"(?!")))
           (?P<text>(([^\\]|\\.)*?))
           (?P=quote))""", reppython),
 ]
 
+txtfilters = []
+
+txtpats = [
+  [
+    ('\s$', 'trailing whitespace'),
+  ],
+  []
+]
+
 cpats = [
   [
     (r'//', "don't use //-style comments"),
     (r'^  ', "don't use spaces to indent"),
     (r'\S\t', "don't use tabs except for indent"),
     (r'(\S[ \t]+|^[ \t]+)\n', "trailing whitespace"),
     (r'.{81}', "line too long"),
     (r'(while|if|do|for)\(', "use space after while/if/do/for"),
     (r'return\(', "return is not a function"),
     (r' ;', "no space before ;"),
     (r'\w+\* \w+', "use int *foo, not int* foo"),
     (r'\([^\)]+\) \w+', "use (int)foo, not (int) foo"),
     (r'\w+ (\+\+|--)', "use foo++, not foo ++"),
     (r'\w,\w', "missing whitespace after ,"),
     (r'^[^#]\w[+/*]\w', "missing whitespace in expression"),
     (r'^#\s+\w', "use #foo, not # foo"),
     (r'[^\n]\Z', "no trailing newline"),
     (r'^\s*#import\b', "use only #include in standard C code"),
   ],
   # warnings
   []
 ]
 
 cfilters = [
     (r'(/\*)(((\*(?!/))|[^*])*)\*/', repccomment),
     (r'''(?P<quote>(?<!")")(?P<text>([^"]|\\")+)"(?!")''', repquote),
     (r'''(#\s*include\s+<)([^>]+)>''', repinclude),
     (r'(\()([^)]+\))', repcallspaces),
 ]
 
 inutilpats = [
   [
     (r'\bui\.', "don't use ui in util"),
   ],
   # warnings
   []
 ]
 
 inrevlogpats = [
   [
     (r'\brepo\.', "don't use repo in revlog"),
   ],
   # warnings
   []
 ]
 
 checks = [
     ('python', r'.*\.(py|cgi)$', pyfilters, pypats),
     ('test script', r'(.*/)?test-[^.~]*$', testfilters, testpats),
     ('c', r'.*\.c$', cfilters, cpats),
     ('unified test', r'.*\.t$', utestfilters, utestpats),
     ('layering violation repo in revlog', r'mercurial/revlog\.py', pyfilters,
      inrevlogpats),
     ('layering violation ui in util', r'mercurial/util\.py', pyfilters,
      inutilpats),
+    ('txt', r'.*\.txt$', txtfilters, txtpats),
 ]
 
 class norepeatlogger(object):
     def __init__(self):
         self._lastseen = None
 
     def log(self, fname, lineno, line, msg, blame):
         """print error related a to given line of a given file.
 
         The faulty line will also be printed but only once in the case
         of multiple errors.
 
         :fname: filename
         :lineno: line number
         :line: actual content of the line
         :msg: error message
         """
         msgid = fname, lineno, line
         if msgid != self._lastseen:
             if blame:
                 print "%s:%d (%s):" % (fname, lineno, blame)
             else:
                 print "%s:%d:" % (fname, lineno)
             print " > %s" % line
             self._lastseen = msgid
         print " " + msg
 
 _defaultlogger = norepeatlogger()
 
 def getblame(f):
     lines = []
     for l in os.popen('hg annotate -un %s' % f):
         start, line = l.split(':', 1)
         user, rev = start.split()
         lines.append((line[1:-1], user, rev))
     return lines
 
 def checkfile(f, logfunc=_defaultlogger.log, maxerr=None, warnings=False,
               blame=False, debug=False, lineno=True):
     """checks style and portability of a given file
 
     :f: filepath
     :logfunc: function used to report error
               logfunc(filename, linenumber, linecontent, errormessage)
     :maxerr: number of error to display before aborting.
              Set to false (default) to report all errors
 
     return True if no error is found, False otherwise.
     """
     blamecache = None
     result = True
     for name, match, filters, pats in checks:
         if debug:
             print name, f
         fc = 0
         if not re.match(match, f):
             if debug:
                 print "Skipping %s for %s it doesn't match %s" % (
                        name, match, f)
             continue
         fp = open(f)
         pre = post = fp.read()
         fp.close()
         if "no-" + "check-code" in pre:
             if debug:
                 print "Skipping %s for %s it has no- and check-code" % (
                        name, f)
             break
         for p, r in filters:
             post = re.sub(p, r, post)
         if warnings:
             pats = pats[0] + pats[1]
         else:
             pats = pats[0]
         # print post # uncomment to show filtered version
 
         if debug:
             print "Checking %s for %s" % (name, f)
 
         prelines = None
         errors = []
         for pat in pats:
             if len(pat) == 3:
                 p, msg, ignore = pat
             else:
                 p, msg = pat
                 ignore = None
 
             # fix-up regexes for multi-line searches
             po = p
             # \s doesn't match \n
             p = re.sub(r'(?<!\\)\\s', r'[ \\t]', p)
             # [^...] doesn't match newline
             p = re.sub(r'(?<!\\)\[\^', r'[^\\n', p)
 
             #print po, '=>', p
 
             pos = 0
             n = 0
             for m in re.finditer(p, post, re.MULTILINE):
                 if prelines is None:
                     prelines = pre.splitlines()
                     postlines = post.splitlines(True)
 
                 start = m.start()
                 while n < len(postlines):
                     step = len(postlines[n])
                     if pos + step > start:
                         break
                     pos += step
                     n += 1
                 l = prelines[n]
 
                 if "check-code" + "-ignore" in l:
                     if debug:
                         print "Skipping %s for %s:%s (check-code -ignore)" % (
                             name, f, n)
                     continue
                 elif ignore and re.search(ignore, l, re.MULTILINE):
                     continue
                 bd = ""
                 if blame:
                     bd = 'working directory'
                     if not blamecache:
                         blamecache = getblame(f)
                     if n < len(blamecache):
                         bl, bu, br = blamecache[n]
                         if bl == l:
                             bd = '%s@%s' % (bu, br)
                 errors.append((f, lineno and n + 1, l, msg, bd))
                 result = False
 
         errors.sort()
         for e in errors:
             logfunc(*e)
             fc += 1
             if maxerr and fc >= maxerr:
                 print " (too many errors, giving up)"
                 break
 
     return result
 
 if __name__ == "__main__":
     parser = optparse.OptionParser("%prog [options] [files]")
     parser.add_option("-w", "--warnings", action="store_true",
                       help="include warning-level checks")
     parser.add_option("-p", "--per-file", type="int",
                       help="max warnings per file")
     parser.add_option("-b", "--blame", action="store_true",
                       help="use annotate to generate blame info")
     parser.add_option("", "--debug", action="store_true",
                       help="show debug information")
     parser.add_option("", "--nolineno", action="store_false",
                       dest='lineno', help="don't show line numbers")
 
     parser.set_defaults(per_file=15, warnings=False, blame=False, debug=False,
                         lineno=True)
     (options, args) = parser.parse_args()
 
     if len(args) == 0:
         check = glob.glob("*")
     else:
         check = args
 
     ret = 0
     for f in check:
         if not checkfile(f, maxerr=options.per_file, warnings=options.warnings,
                          blame=options.blame, debug=options.debug,
                          lineno=options.lineno):
             ret = 1
     sys.exit(ret)

contrib/win32/win32-build.txt

@@ -1,133 +1,133
 The standalone Windows installer for Mercurial is built in a somewhat
 jury-rigged fashion.
 
 It has the following prerequisites. Ensure to take the packages
 matching the mercurial version you want to build (32-bit or 64-bit).
 
   Python 2.6 for Windows
       http://www.python.org/download/releases/
 
   A compiler:
     either MinGW
       http://www.mingw.org/
     or Microsoft Visual C++ 2008 SP1 Express Edition
       http://www.microsoft.com/express/Downloads/Download-2008.aspx
 
   Python for Windows Extensions
       http://sourceforge.net/projects/pywin32/
 
   mfc71.dll (just download, don't install; not needed for Python 2.6)
       http://starship.python.net/crew/mhammond/win32/
 
   Visual C++ 2008 redistributable package (needed for >= Python 2.6 or if you compile with MSVC)
     for 32-bit:
       http://www.microsoft.com/downloads/details.aspx?FamilyID=9b2da534-3e03-4391-8a4d-074b9f2bc1bf
     for 64-bit:
       http://www.microsoft.com/downloads/details.aspx?familyid=bd2a6171-e2d6-4230-b809-9a8d7548c1b6
-      
+
   The py2exe distutils extension
       http://sourceforge.net/projects/py2exe/
 
   GnuWin32 gettext utility (if you want to build translations)
       http://gnuwin32.sourceforge.net/packages/gettext.htm
 
   Inno Setup
       http://www.jrsoftware.org/isdl.php#qsp
 
       Get and install ispack-5.3.10.exe or later (includes Inno Setup Processor),
       which is necessary to package Mercurial.
 
   ISTool - optional
       http://www.istool.org/default.aspx/
 
   add_path (you need only add_path.exe in the zip file)
       http://www.barisione.org/apps.html#add_path
 
   Docutils
       http://docutils.sourceforge.net/
 
   CA Certs file
       http://curl.haxx.se/ca/cacert.pem
 
 And, of course, Mercurial itself.
 
 Once you have all this installed and built, clone a copy of the
 Mercurial repository you want to package, and name the repo
 C:\hg\hg-release.
 
 In a shell, build a standalone copy of the hg.exe program.
 
 Building instructions for MinGW:
   python setup.py build -c mingw32
   python setup.py py2exe -b 2
 Note: the previously suggested combined command of "python setup.py build -c
 mingw32 py2exe -b 2" doesn't work correctly anymore as it doesn't include the
 extensions in the mercurial subdirectory.
 If you want to create a file named setup.cfg with the contents:
 [build]
 compiler=mingw32
 you can skip the first build step.
 
 Building instructions with MSVC 2008 Express Edition:
   for 32-bit:
     "C:\Program Files\Microsoft Visual Studio 9.0\VC\vcvarsall.bat" x86
     python setup.py py2exe -b 2
   for 64-bit:
     "C:\Program Files\Microsoft Visual Studio 9.0\VC\vcvarsall.bat" x86_amd64
     python setup.py py2exe -b 3
 
 Copy add_path.exe and cacert.pem files into the dist directory that just got created.
 
 If you are using Python up to version 2.5.4, copy mfc71.dll into the dist
 directory that just got created.
 
 If you are using Python 2.6 or later, or if you are using MSVC 2008 to compile
 mercurial, you must include the C runtime libraries in the installer. To do so,
 install the Visual C++ 2008 redistributable package. Then in your windows\winsxs
 folder, locate the folder containing the dlls version 9.0.21022.8.
 For x86, it should be named like x86_Microsoft.VC90.CRT_(...)_9.0.21022.8(...).
 For x64, it should be named like amd64_Microsoft.VC90.CRT_(...)_9.0.21022.8(...).
 Copy the files named msvcm90.dll, msvcp90.dll and msvcr90.dll into the dist
 directory.
 Then in the windows\winsxs\manifests folder, locate the corresponding manifest
 file (x86_Microsoft.VC90.CRT_(...)_9.0.21022.8(...).manifest for x86,
 amd64_Microsoft.VC90.CRT_(...)_9.0.21022.8(...).manifest for x64), copy it in the
 dist directory and rename it to Microsoft.VC90.CRT.manifest.
 
-Before building the installer, you have to build Mercurial HTML documentation 
+Before building the installer, you have to build Mercurial HTML documentation
 (or fix mercurial.iss to not reference the doc directory):
 
   cd doc
   mingw32-make html
   cd ..
 
 If you use ISTool, you open the C:\hg\hg-release\contrib\win32\mercurial.iss
 file and type Ctrl-F9 to compile the installer file.
 
 Otherwise you run the Inno Setup compiler.  Assuming it's in the path
 you should execute:
 
   iscc contrib\win32\mercurial.iss /dVERSION=foo
 
 Where 'foo' is the version number you would like to see in the
 'Add/Remove Applications' tool.  The installer will be placed into
 a directory named Output/ at the root of your repository.
 If the /dVERSION=foo parameter is not given in the command line, the
 installer will retrieve the version information from the __version__.py file.
 
 If you want to build an installer for a 64-bit mercurial, add /dARCH=x64 to
 your command line:
   iscc contrib\win32\mercurial.iss /dARCH=x64
 
 To automate the steps above you may want to create a batchfile based on the
 following (MinGW build chain):
 
   echo [build] > setup.cfg
   echo compiler=mingw32 >> setup.cfg
   python setup.py py2exe -b 2
   cd doc
   mingw32-make html
   cd ..
   iscc contrib\win32\mercurial.iss /dVERSION=snapshot
 
 and run it from the root of the hg repository (c:\hg\hg-release).

doc/hg.1.txt

@@ -1,119 +1,119
 ====
  hg
 ====
 
 ---------------------------------------
 Mercurial source code management system
 ---------------------------------------
 
 :Author:         Matt Mackall <[e-mail]>
 :Organization:   Mercurial
 :Manual section: 1
 :Manual group:   Mercurial Manual
 
 .. contents::
    :backlinks: top
    :class: htmlonly
    :depth: 1
 
 
 Synopsis
 """"""""
 **hg** *command* [*option*]... [*argument*]...
 
 Description
 """""""""""
 The **hg** command provides a command line interface to the Mercurial
 system.
 
 Command Elements
 """"""""""""""""
 
 files...
     indicates one or more filename or relative path filenames; see
     `File Name Patterns`_ for information on pattern matching
 
 path
     indicates a path on the local machine
 
 revision
     indicates a changeset which can be specified as a changeset
     revision number, a tag, or a unique substring of the changeset
     hash value
 
 repository path
     either the pathname of a local repository or the URI of a remote
     repository.
 
 .. include:: hg.1.gendoc.txt
 
 Files
 """""
 
 ``/etc/mercurial/hgrc``, ``$HOME/.hgrc``, ``.hg/hgrc``
     This file contains defaults and configuration. Values in
     ``.hg/hgrc`` override those in ``$HOME/.hgrc``, and these override
     settings made in the global ``/etc/mercurial/hgrc`` configuration.
     See |hgrc(5)|_ for details of the contents and format of these
     files.
 
 ``.hgignore``
     This file contains regular expressions (one per line) that
     describe file names that should be ignored by **hg**. For details,
     see |hgignore(5)|_.
 
 ``.hgsub``
     This file defines the locations of all subrepositories, and
     tells where the subrepository checkouts came from. For details, see
     :hg:`help subrepos`.
 
 ``.hgsubstate``
     This file is where Mercurial stores all nested repository states. *NB: This
     file should not be edited manually.*
 
 ``.hgtags``
     This file contains changeset hash values and text tag names (one
     of each separated by spaces) that correspond to tagged versions of
     the repository contents. The file content is encoded using UTF-8.
 
 ``.hg/last-message.txt``
     This file is used by :hg:`commit` to store a backup of the commit message
     in case the commit fails.
 
 ``.hg/localtags``
     This file can be used to define local tags which are not shared among
     repositories. The file format is the same as for ``.hgtags``, but it is
     encoded using the local system encoding.
-    
+
 Some commands (e.g. revert) produce backup files ending in ``.orig``,
 if the ``.orig`` file already exists and is not tracked by Mercurial,
 it will be overwritten.
 
 Bugs
 """"
 Probably lots, please post them to the mailing list (see Resources_
 below) when you find them.
 
 See Also
 """"""""
 |hgignore(5)|_, |hgrc(5)|_
 
 Author
 """"""
 Written by Matt Mackall <[e-mail]>
 
 Resources
 """""""""
 Main Web Site: http://mercurial.selenic.com/
 
 Source code repository: http://selenic.com/hg
 
 Mailing list: http://selenic.com/mailman/listinfo/mercurial
 
 Copying
 """""""
 Copyright (C) 2005-2012 Matt Mackall.
 Free use of this software is granted under the terms of the GNU General
 Public License version 2 or any later version.
 
 .. include:: common.txt

mercurial/help/filesets.txt

@@ -1,65 +1,65
 Mercurial supports a functional language for selecting a set of
-files. 
+files.
 
 Like other file patterns, this pattern type is indicated by a prefix,
 'set:'. The language supports a number of predicates which are joined
 by infix operators. Parenthesis can be used for grouping.
 
 Identifiers such as filenames or patterns must be quoted with single
 or double quotes if they contain characters outside of
 ``[.*{}[]?/\_a-zA-Z0-9\x80-\xff]`` or if they match one of the
 predefined predicates. This generally applies to file patterns other
 than globs and arguments for predicates.
 
 Special characters can be used in quoted identifiers by escaping them,
 e.g., ``\n`` is interpreted as a newline. To prevent them from being
 interpreted, strings can be prefixed with ``r``, e.g. ``r'...'``.
 
 There is a single prefix operator:
 
 ``not x``
   Files not in x. Short form is ``! x``.
 
 These are the supported infix operators:
 
 ``x and y``
   The intersection of files in x and y. Short form is ``x & y``.
 
 ``x or y``
   The union of files in x and y. There are two alternative short
   forms: ``x | y`` and ``x + y``.
 
 ``x - y``
   Files in x but not in y.
 
 The following predicates are supported:
 
 .. predicatesmarker
 
 Some sample queries:
 
 - Show status of files that appear to be binary in the working directory::
 
     hg status -A "set:binary()"
 
 - Forget files that are in .hgignore but are already tracked::
 
     hg forget "set:hgignore() and not ignored()"
 
 - Find text files that contain a string::
 
     hg locate "set:grep(magic) and not binary()"
 
 - Find C files in a non-standard encoding::
 
     hg locate "set:**.c and not encoding('UTF-8')"
 
 - Revert copies of large binary files::
 
     hg revert "set:copied() and binary() and size('>1M')"
 
 - Remove files listed in foo.lst that contain the letter a or b::
 
     hg remove "set: 'listfile:foo.lst' and (**a* or **b*)"
 
 See also :hg:`help patterns`.

mercurial/help/patterns.txt

@@ -1,57 +1,57
 Mercurial accepts several notations for identifying one or more files
 at a time.
 
 By default, Mercurial treats filenames as shell-style extended glob
 patterns.
 
 Alternate pattern notations must be specified explicitly.
 
 .. note::
-  Patterns specified in ``.hgignore`` are not rooted. 
+  Patterns specified in ``.hgignore`` are not rooted.
   Please see :hg:`help hgignore` for details.
 
 To use a plain path name without any pattern matching, start it with
 ``path:``. These path names must completely match starting at the
 current repository root.
 
 To use an extended glob, start a name with ``glob:``. Globs are rooted
 at the current directory; a glob such as ``*.c`` will only match files
 in the current directory ending with ``.c``.
 
 The supported glob syntax extensions are ``**`` to match any string
 across path separators and ``{a,b}`` to mean "a or b".
 
 To use a Perl/Python regular expression, start a name with ``re:``.
 Regexp pattern matching is anchored at the root of the repository.
 
 To read name patterns from a file, use ``listfile:`` or ``listfile0:``.
 The latter expects null delimited patterns while the former expects line
 feeds. Each string read from the file is itself treated as a file
 pattern.
 
 Plain examples::
 
   path:foo/bar   a name bar in a directory named foo in the root
                  of the repository
   path:path:name a file or directory named "path:name"
 
 Glob examples::
 
   glob:*.c       any name ending in ".c" in the current directory
   *.c            any name ending in ".c" in the current directory
   **.c           any name ending in ".c" in any subdirectory of the
                  current directory including itself.
   foo/*.c        any name ending in ".c" in the directory foo
   foo/**.c       any name ending in ".c" in any subdirectory of foo
                  including itself.
 
 Regexp examples::
 
   re:.*\.c$      any name ending in ".c", anywhere in the repository
 
 File examples::
 
   listfile:list.txt  read list from list.txt with one file pattern per line
   listfile0:list.txt read list from list.txt with null byte delimiters
 
 See also :hg:`help filesets`.

mercurial/help/phases.txt

@@ -1,84 +1,84
 What are phases?
 ================
 
 Phases are a system for tracking which changesets have been or should
 be shared. This helps prevent common mistakes when modifying history
 (for instance, with the mq or rebase extensions).
 
 Each changeset in a repository is in one of the following phases:
 
  - public : changeset is visible on a public server
  - draft : changeset is not yet published
  - secret : changeset should not be pushed, pulled, or cloned
 
 These phases are ordered (public < draft < secret) and no changeset
 can be in a lower phase than its ancestors. For instance, if a
 changeset is public, all its ancestors are also public. Lastly,
 changeset phases should only be changed towards the public phase.
 
 How are phases managed?
 =======================
 
 For the most part, phases should work transparently. By default, a
 changeset is created in the draft phase and is moved into the public
 phase when it is pushed to another repository.
 
 Once changesets become public, extensions like mq and rebase will
 refuse to operate on them to prevent creating duplicate changesets.
 Phases can also be manually manipulated with the :hg:`phase` command
 if needed. See :hg:`help -v phase` for examples.
 
 Phases and servers
 ==================
 
 Normally, all servers are ``publishing`` by default. This means::
 
  - all draft changesets that are pulled or cloned appear in phase
  public on the client
 
  - all draft changesets that are pushed appear as public on both
  client and server
 
  - secret changesets are neither pushed, pulled, or cloned
 
 .. note::
   Pulling a draft changeset from a publishing server does not mark it
   as public on the server side due to the read-only nature of pull.
 
 Sometimes it may be desirable to push and pull changesets in the draft
 phase to share unfinished work. This can be done by setting a
 repository to disable publishing in its configuration file::
 
   [phases]
   publish = False
 
 See :hg:`help config` for more information on config files.
 
 .. note::
   Servers running older versions of Mercurial are treated as
   publishing.
 
 Examples
 ========
 
  - list changesets in draft or secret phase::
 
      hg log -r "not public()"
 
  - change all secret changesets to draft::
 
      hg phase --draft "secret()"
 
  - forcibly move the current changeset and descendants from public to draft::
 
      hg phase --force --draft .
 
  - show a list of changeset revision and phase::
 
      hg log --template "{rev} {phase}\n"
 
  - resynchronize draft changesets relative to a remote repository::
 
-     hg phase -fd 'outgoing(URL)' 
+     hg phase -fd 'outgoing(URL)'
 
 See :hg:`help phase` for more information on manually manipulating phases.