mercurial-crew-with-dirclash: comparison mercurial/commands.py

equal deleted inserted replaced

-:32a4e6802864
+:b3e94785ab69
 demandload(globals(), "fnmatch hgweb mdiff random signal time traceback")
 demandload(globals(), "errno socket version struct atexit sets bz2")
 class UnknownCommand(Exception):
 """Exception raised if command is not in the command table."""
+class AmbiguousCommand(Exception):
+"""Exception raised if command shortcut matches more than one command."""
 def filterfiles(filters, files):
 l = [x for x in files if x in filters]
 for t in filters:
 cwd = repo.getcwd()
 if cwd:
 return [util.normpath(os.path.join(cwd, x)) for x in args]
 return args
-def matchpats(repo, cwd, pats=[], opts={}, head=''):
+def matchpats(repo, pats=[], opts={}, head=''):
+cwd = repo.getcwd()
+if not pats and cwd:
+opts['include'] = [os.path.join(cwd, i) for i in opts['include']]
+opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]
+cwd = ''
 return util.cmdmatcher(repo.root, cwd, pats or ['.'], opts.get('include'),
-opts.get('exclude'), head)
+opts.get('exclude'), head) + (cwd,)
-def makewalk(repo, pats, opts, head=''):
+def makewalk(repo, pats, opts, node=None, head=''):
-cwd = repo.getcwd()
+files, matchfn, anypats, cwd = matchpats(repo, pats, opts, head)
-files, matchfn, anypats = matchpats(repo, cwd, pats, opts, head)
 exact = dict(zip(files, files))
 def walk():
-for src, fn in repo.walk(files=files, match=matchfn):
+for src, fn in repo.walk(node=node, files=files, match=matchfn):
 yield src, fn, util.pathto(cwd, fn), fn in exact
 return files, matchfn, walk()
-def walk(repo, pats, opts, head=''):
+def walk(repo, pats, opts, node=None, head=''):
-files, matchfn, results = makewalk(repo, pats, opts, head)
+files, matchfn, results = makewalk(repo, pats, opts, node, head)
 for r in results:
 yield r
-def walkchangerevs(ui, repo, cwd, pats, opts):
+def walkchangerevs(ui, repo, pats, opts):
 '''Iterate over files and the revs they changed in.
 Callers most commonly need to iterate backwards over the history
 it is interested in.  Doing so has awful (quadratic-looking)
 performance, so we use iterators in a "windowed" way.
 over with "add" - use to display data'''
 if repo.changelog.count() == 0:
 return [], False
-cwd = repo.getcwd()
+files, matchfn, anypats, cwd = matchpats(repo, pats, opts)
-if not pats and cwd:
-opts['include'] = [os.path.join(cwd, i) for i in opts['include']]
-opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]
-files, matchfn, anypats = matchpats(repo, (pats and cwd) or '',
-pats, opts)
 revs = map(int, revrange(ui, repo, opts['rev'] or ['tip:0']))
 wanted = {}
 slowpath = anypats
 window = 300
 fncache = {}
 option_lists = []
 if cmd and cmd != 'shortlist':
 if with_version:
 show_version(ui)
 ui.write('\n')
-key, i = find(cmd)
+aliases, i = find(cmd)
 # synopsis
 ui.write("%s\n\n" % i[2])
 # description
 doc = i[0].__doc__
 doc = doc.splitlines(0)[0]
 ui.write("%s\n" % doc.rstrip())
 if not ui.quiet:
 # aliases
-aliases = ', '.join(key.split('|')[1:])
+if len(aliases) > 1:
-if aliases:
+ui.write(_("\naliases: %s\n") % ', '.join(aliases[1:]))
-ui.write(_("\naliases: %s\n") % aliases)
 # options
 if i[1]:
 option_lists.append(("options", i[1]))
 Schedule files to be version controlled and added to the repository.
 The files will be added to the repository at the next commit.
-If no names are given, add all files in the current directory and
+If no names are given, add all files in the repository.
-its subdirectories.
 """
 names = []
 for src, abs, rel, exact in walk(repo, pats, opts):
 if exact:
 ucache = {}
 def getname(rev):
 cl = repo.changelog.read(repo.changelog.node(rev))
 return trimuser(ui, cl[1], rev, ucache)
+dcache = {}
+def getdate(rev):
+	datestr = dcache.get(rev)
+if datestr is None:
+cl = repo.changelog.read(repo.changelog.node(rev))
+datestr = dcache[rev] = util.datestr(cl[2])
+	return datestr
 if not pats:
 raise util.Abort(_('at least one file name or pattern required'))
-opmap = [['user', getname], ['number', str], ['changeset', getnode]]
+opmap = [['user', getname], ['number', str], ['changeset', getnode],
-if not opts['user'] and not opts['changeset']:
+['date', getdate]]
+if not opts['user'] and not opts['changeset'] and not opts['date']:
 opts['number'] = 1
 if opts['rev']:
 node = repo.changelog.lookup(opts['rev'])
 else:
 %s   basename of file being printed
 %d   dirname of file being printed, or '.' if in repo root
 %p   root-relative path name of file being printed
 """
 mf = {}
-if opts['rev']:
+rev = opts['rev']
-change = repo.changelog.read(repo.lookup(opts['rev']))
+if rev:
-mf = repo.manifest.read(change[0])
+node = repo.lookup(rev)
-for src, abs, rel, exact in walk(repo, (file1,) + pats, opts):
+else:
+node = repo.changelog.tip()
+change = repo.changelog.read(node)
+mf = repo.manifest.read(change[0])
+for src, abs, rel, exact in walk(repo, (file1,) + pats, opts, node):
 r = repo.file(abs)
-if opts['rev']:
+n = mf[abs]
-try:
-n = mf[abs]
-except (hg.RepoError, KeyError):
-try:
-n = r.lookup(rev)
-except KeyError, inst:
-raise util.Abort(_('cannot find file %s in rev %s'), rel, rev)
-else:
-n = r.tip()
 fp = make_file(repo, r, opts['output'], node=n, pathname=abs)
 fp.write(r.read(n))
 def clone(ui, source, dest=None, **opts):
 """make a copy of an existing repository
 if os.path.exists(dest):
 raise util.Abort(_("destination '%s' already exists"), dest)
 dest = os.path.realpath(dest)
-class Dircleanup:
+class Dircleanup(object):
 def __init__(self, dir_):
 self.rmtree = shutil.rmtree
 self.dir_ = dir_
 os.mkdir(dir_)
 def close(self):
 repo.pull(other, heads = revs)
 f = repo.opener("hgrc", "w", text=True)
 f.write("[paths]\n")
 f.write("default = %s\n" % abspath)
+f.close()
 if not opts['noupdate']:
 update(ui, repo)
 d.close()
 """commit the specified files or all outstanding changes
 Commit changes to the given files into the repository.
 If a list of files is omitted, all changes reported by "hg status"
-from the root of the repository will be commited.
+will be commited.
 The HGEDITOR or EDITOR environment variables are used to start an
 editor to add a commit comment.
 """
 message = opts['message']
 raise util.Abort(_("can't read commit message '%s': %s") %
 (logfile, inst.strerror))
 if opts['addremove']:
 addremove(ui, repo, *pats, **opts)
-cwd = repo.getcwd()
+fns, match, anypats, cwd = matchpats(repo, pats, opts)
-if not pats and cwd:
-opts['include'] = [os.path.join(cwd, i) for i in opts['include']]
-opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]
-fns, match, anypats = matchpats(repo, (pats and repo.getcwd()) or '',
-pats, opts)
 if pats:
 c, a, d, u = repo.changes(files=fns, match=match)
 files = c + a + [fn for fn in d if repo.dirstate.state(fn) == 'r']
 else:
 files = []
 repo.commit(files, message, opts['user'], opts['date'], match)
 except ValueError, inst:
 raise util.Abort(str(inst))
 def docopy(ui, repo, pats, opts):
-if not pats:
+cwd = repo.getcwd()
-raise util.Abort(_('no source or destination specified'))
+errors = 0
-elif len(pats) == 1:
+copied = []
-raise util.Abort(_('no destination specified'))
+targets = {}
-pats = list(pats)
-dest = pats.pop()
-sources = []
-dir2dir = len(pats) == 1 and os.path.isdir(pats[0])
 def okaytocopy(abs, rel, exact):
 reasons = {'?': _('is not managed'),
 'a': _('has been marked for add')}
 reason = reasons.get(repo.dirstate.state(abs))
 if reason:
 if exact: ui.warn(_('%s: not copying - file %s\n') % (rel, reason))
 else:
 return True
-for src, abs, rel, exact in walk(repo, pats, opts):
+def copy(abssrc, relsrc, target, exact):
-if okaytocopy(abs, rel, exact):
+abstarget = util.canonpath(repo.root, cwd, target)
-sources.append((abs, rel, exact))
+reltarget = util.pathto(cwd, abstarget)
-if not sources:
+prevsrc = targets.get(abstarget)
-raise util.Abort(_('no files to copy'))
+if prevsrc is not None:
+ui.warn(_('%s: not overwriting - %s collides with %s\n') %
-cwd = repo.getcwd()
+(reltarget, abssrc, prevsrc))
-absdest = util.canonpath(repo.root, cwd, dest)
+return
-reldest = util.pathto(cwd, absdest)
+if (not opts['after'] and os.path.exists(reltarget) or
-if os.path.exists(reldest):
+opts['after'] and repo.dirstate.state(abstarget) not in '?r'):
-destisfile = not os.path.isdir(reldest)
+if not opts['force']:
-else:
+ui.warn(_('%s: not overwriting - file exists\n') %
-destisfile = not dir2dir and (len(sources) == 1
+reltarget)
-or repo.dirstate.state(absdest) != '?')
+return
+if not opts['after']:
-if destisfile and len(sources) > 1:
+os.unlink(reltarget)
-raise util.Abort(_('with multiple sources, destination must be a '
+if opts['after']:
-'directory'))
+if not os.path.exists(reltarget):
+return
-srcpfxlen = 0
-if dir2dir:
-srcpfx = util.pathto(cwd, util.canonpath(repo.root, cwd, pats[0]))
-if os.path.exists(reldest):
-srcpfx = os.path.split(srcpfx)[0]
-if srcpfx:
-srcpfx += os.sep
-srcpfxlen = len(srcpfx)
-errs, copied = 0, []
-for abs, rel, exact in sources:
-if destisfile:
-mydest = reldest
-elif dir2dir:
-mydest = os.path.join(dest, rel[srcpfxlen:])
 else:
-mydest = os.path.join(dest, os.path.basename(rel))
+targetdir = os.path.dirname(reltarget) or '.'
-myabsdest = util.canonpath(repo.root, cwd, mydest)
+if not os.path.isdir(targetdir):
-myreldest = util.pathto(cwd, myabsdest)
+os.makedirs(targetdir)
-if not opts['force'] and repo.dirstate.state(myabsdest) not in 'a?':
-ui.warn(_('%s: not overwriting - file already managed\n') % myreldest)
-continue
-mydestdir = os.path.dirname(myreldest) or '.'
-if not opts['after']:
 try:
-if dir2dir: os.makedirs(mydestdir)
+shutil.copyfile(relsrc, reltarget)
-elif not destisfile: os.mkdir(mydestdir)
+shutil.copymode(relsrc, reltarget)
-except OSError, inst:
-if inst.errno != errno.EEXIST: raise
-if ui.verbose or not exact:
-ui.status(_('copying %s to %s\n') % (rel, myreldest))
-if not opts['after']:
-try:
-shutil.copyfile(rel, myreldest)
-shutil.copymode(rel, myreldest)
 except shutil.Error, inst:
 raise util.Abort(str(inst))
 except IOError, inst:
 if inst.errno == errno.ENOENT:
-ui.warn(_('%s: deleted in working copy\n') % rel)
+ui.warn(_('%s: deleted in working copy\n') % relsrc)
 else:
-ui.warn(_('%s: cannot copy - %s\n') % (rel, inst.strerror))
+ui.warn(_('%s: cannot copy - %s\n') %
-errs += 1
+(relsrc, inst.strerror))
-continue
+errors += 1
-repo.copy(abs, myabsdest)
+return
-copied.append((abs, rel, exact))
+if ui.verbose or not exact:
-if errs:
+ui.status(_('copying %s to %s\n') % (relsrc, reltarget))
+targets[abstarget] = abssrc
+repo.copy(abssrc, abstarget)
+copied.append((abssrc, relsrc, exact))
+def targetpathfn(pat, dest, srcs):
+if os.path.isdir(pat):
+if pat.endswith(os.sep):
+pat = pat[:-len(os.sep)]
+if destdirexists:
+striplen = len(os.path.split(pat)[0])
+else:
+striplen = len(pat)
+if striplen:
+striplen += len(os.sep)
+res = lambda p: os.path.join(dest, p[striplen:])
+elif destdirexists:
+res = lambda p: os.path.join(dest, os.path.basename(p))
+else:
+res = lambda p: dest
+return res
+def targetpathafterfn(pat, dest, srcs):
+if util.patkind(pat, None)[0]:
+# a mercurial pattern
+res = lambda p: os.path.join(dest, os.path.basename(p))
+elif len(util.canonpath(repo.root, cwd, pat)) < len(srcs[0][0]):
+# A directory. Either the target path contains the last
+# component of the source path or it does not.
+def evalpath(striplen):
+score = 0
+for s in srcs:
+t = os.path.join(dest, s[1][striplen:])
+if os.path.exists(t):
+score += 1
+return score
+if pat.endswith(os.sep):
+pat = pat[:-len(os.sep)]
+striplen = len(pat) + len(os.sep)
+if os.path.isdir(os.path.join(dest, os.path.split(pat)[1])):
+score = evalpath(striplen)
+striplen1 = len(os.path.split(pat)[0])
+if striplen1:
+striplen1 += len(os.sep)
+if evalpath(striplen1) > score:
+striplen = striplen1
+res = lambda p: os.path.join(dest, p[striplen:])
+else:
+# a file
+if destdirexists:
+res = lambda p: os.path.join(dest, os.path.basename(p))
+else:
+res = lambda p: dest
+return res
+pats = list(pats)
+if not pats:
+raise util.Abort(_('no source or destination specified'))
+if len(pats) == 1:
+raise util.Abort(_('no destination specified'))
+dest = pats.pop()
+destdirexists = os.path.isdir(dest)
+if (len(pats) > 1 or util.patkind(pats[0], None)[0]) and not destdirexists:
+raise util.Abort(_('with multiple sources, destination must be an '
+'existing directory'))
+if opts['after']:
+tfn = targetpathafterfn
+else:
+tfn = targetpathfn
+copylist = []
+for pat in pats:
+srcs = []
+for tag, abssrc, relsrc, exact in walk(repo, [pat], opts):
+if okaytocopy(abssrc, relsrc, exact):
+srcs.append((abssrc, relsrc, exact))
+if not srcs:
+continue
+copylist.append((tfn(pat, dest, srcs), srcs))
+if not copylist:
+raise util.Abort(_('no files to copy'))
+for targetpath, srcs in copylist:
+for abssrc, relsrc, exact in srcs:
+copy(abssrc, relsrc, targetpath(relsrc), exact)
+if errors:
 ui.warn(_('(consider using --after)\n'))
-return errs, copied
+return errors, copied
 def copy(ui, repo, *pats, **opts):
 """mark files as copied for the next commit
 Mark dest as having copies of source files.  If dest is a
 # assume all revision numbers are for changesets
 n = repo.lookup(rev)
 change = repo.changelog.read(n)
 m = repo.manifest.read(change[0])
 n = m[relpath(repo, [file])[0]]
-except hg.RepoError, KeyError:
+except (hg.RepoError, KeyError):
 n = r.lookup(rev)
 else:
 n = r.tip()
 m = r.renamed(n)
 if m:
 for src, abs, rel, exact in items:
 line = fmt % (src, abs, rel, exact and 'exact' or '')
 ui.write("%s\n" % line.rstrip())
 def diff(ui, repo, *pats, **opts):
-"""diff working directory (or selected files)
+"""diff repository (or selected files)
 Show differences between revisions for the specified files.
 Differences between files are shown using the unified diff format.
 if len(revs) > 1:
 node2 = revs[1]
 if len(revs) > 2:
 raise util.Abort(_("too many revisions to diff"))
-fns, matchfn, anypats = matchpats(repo, repo.getcwd(), pats, opts)
+fns, matchfn, anypats, cwd = matchpats(repo, pats, opts)
 dodiff(sys.stdout, ui, repo, node1, node2, fns, match=matchfn,
 text=opts['text'])
 def doexport(ui, repo, changeset, seqno, total, revwidth, opts):
 lstart = body.rfind('\n', begin, mstart) + 1 or begin
 lend = body.find('\n', mend)
 yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]
 begin = lend + 1
-class linestate:
+class linestate(object):
 def __init__(self, line, linenum, colstart, colend):
 self.line = line
 self.linenum = linenum
 self.colstart = colstart
 self.colend = colend
 counts[change] += 1
 return counts['+'], counts['-']
 fstate = {}
 skip = {}
-changeiter, getchange = walkchangerevs(ui, repo, repo.getcwd(), pats, opts)
+changeiter, getchange = walkchangerevs(ui, repo, pats, opts)
 count = 0
 incrementing = False
 for st, rev, fns in changeiter:
 if st == 'window':
 incrementing = rev
 Repository "heads" are changesets that don't have children
 changesets. They are where development generally takes place and
 are the usual targets for update and merge operations.
 """
-heads = repo.changelog.heads()
+if opts['rev']:
+heads = repo.heads(repo.lookup(opts['rev']))
+else:
+heads = repo.heads()
 br = None
 if opts['branches']:
 br = repo.branchlookup(heads)
-for n in repo.changelog.heads():
+for n in heads:
 show_changeset(ui, repo, changenode=n, brinfo=br)
 def identify(ui, repo):
 """print information about the working copy
 """show revision history of entire repository or files
 Print the revision history of the specified files or the entire project.
 By default this command outputs: changeset id and hash, tags,
-parents, user, date and time, and a summary for each commit. The
+non-trivial parents, user, date and time, and a summary for each
--v switch adds some more detail, such as changed files, manifest
+commit. When the -v/--verbose switch is used, the list of changed
-hashes or message signatures.
+files and full commit message is shown.
 """
-class dui:
+class dui(object):
 # Implement and delegate some ui protocol.  Save hunks of
 # output for later display in the desired order.
 def __init__(self, ui):
 self.ui = ui
 self.hunk = {}
 def debug(self, *args):
 if self.debugflag:
 self.write(*args)
 def __getattr__(self, key):
 return getattr(self.ui, key)
-cwd = repo.getcwd()
+changeiter, getchange = walkchangerevs(ui, repo, pats, opts)
-if not pats and cwd:
-opts['include'] = [os.path.join(cwd, i) for i in opts['include']]
-opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]
-changeiter, getchange = walkchangerevs(ui, repo, (pats and cwd) or '',
-pats, opts)
 for st, rev, fns in changeiter:
 if st == 'window':
 du = dui(ui)
 elif st == 'add':
 du.bump(rev)
 Recover from an interrupted commit or pull.
 This command tries to fix the repository status after an interrupted
 operation. It should only be necessary when Mercurial suggests it.
 """
-repo.recover()
+if repo.recover():
+return repo.verify()
+return False
 def remove(ui, repo, pat, *pats, **opts):
 """remove the specified files on the next commit
 Schedule the indicated files for removal from the repository.
 If a file has been deleted, it is recreated.  If the executable
 mode of a file was changed, it is reset.
 If names are given, all files matching the names are reverted.
-If no names are given, all files in the current directory and
+If no arguments are given, all files in the repository are reverted.
-its subdirectories are reverted.
 """
 node = opts['rev'] and repo.lookup(opts['rev']) or \
 repo.dirstate.parents()[0]
-files, choose, anypats = matchpats(repo, repo.getcwd(), pats, opts)
+files, choose, anypats, cwd = matchpats(repo, pats, opts)
 (c, a, d, u) = repo.changes(match=choose)
 repo.forget(a)
 repo.undelete(d)
 return repo.update(node, False, True, choose, False)
 httpd.serve_forever()
 def status(ui, repo, *pats, **opts):
 """show changed files in the working directory
-Show changed files in the working directory.  If no names are
+Show changed files in the repository.  If names are
-given, all files are shown.  Otherwise, only files matching the
+given, only files that match are shown.
-given names are shown.
 The codes used to show the status of files are:
 M = modified
 A = added
 R = removed
 ? = not tracked
 """
-cwd = repo.getcwd()
+files, matchfn, anypats, cwd = matchpats(repo, pats, opts)
-files, matchfn, anypats = matchpats(repo, cwd, pats, opts)
 (c, a, d, u) = [[util.pathto(cwd, x) for x in n]
 for n in repo.changes(files=files, match=matchfn)]
 changetypes = [(_('modified'), 'M', c),
 (_('added'), 'A', a),
 if rev:
 r = hex(repo.lookup(rev))
 else:
 r = hex(repo.changelog.tip())
-if name.find(revrangesep) >= 0:
+disallowed = (revrangesep, '\r', '\n')
-raise util.Abort(_("'%s' cannot be used in a tag name") % revrangesep)
+for c in disallowed:
+if name.find(c) >= 0:
+raise util.Abort(_("%s cannot be used in a tag name") % repr(c))
 if opts['local']:
 repo.opener("localtags", "a").write("%s %s\n" % (r, name))
 return
 "^annotate":
 (annotate,
 [('r', 'rev', '', _('annotate the specified revision')),
 ('a', 'text', None, _('treat all files as text')),
 ('u', 'user', None, _('list the author')),
+('d', 'date', None, _('list the date')),
 ('n', 'number', None, _('list the revision number (default)')),
 ('c', 'changeset', None, _('list the changeset')),
 ('I', 'include', [], _('include names matching the given patterns')),
 ('X', 'exclude', [], _('exclude names matching the given patterns'))],
 _('hg annotate [OPTION]... FILE...')),
 ('r', 'rev', [], _('search in given revision range')),
 ('u', 'user', None, _('print user who committed change'))],
 "hg grep [OPTION]... PATTERN [FILE]..."),
 "heads":
 (heads,
-[('b', 'branches', None, _('find branch info'))],
+[('b', 'branches', None, _('find branch info')),
-_('hg heads [-b]')),
+('r', 'rev', "", _('show only heads which are descendants of rev'))],
+_('hg heads [-b] [-r <rev>]')),
 "help": (help_, [], _('hg help [COMMAND]')),
 "identify|id": (identify, [], _('hg identify')),
 "import|patch":
 (import_,
 [('p', 'strip', 1, _('directory strip option for patch. This has the same\n') +
 norepo = ("clone init version help debugancestor debugconfig debugdata"
 " debugindex debugindexdot paths")
 def find(cmd):
-choice = []
+"""Return (aliases, command table entry) for command string."""
+choice = None
 for e in table.keys():
 aliases = e.lstrip("^").split("|")
 if cmd in aliases:
-return e, table[e]
+return aliases, table[e]
 for a in aliases:
 if a.startswith(cmd):
-choice.append(e)
+if choice:
-if len(choice) == 1:
+raise AmbiguousCommand(cmd)
-e = choice[0]
+else:
-return e, table[e]
+choice = aliases, table[e]
+break
+if choice:
+return choice
 raise UnknownCommand(cmd)
 class SignalInterrupt(Exception):
 """Exception raised on SIGTERM and SIGHUP."""
 except fancyopts.getopt.GetoptError, inst:
 raise ParseError(None, inst)
 if args:
 cmd, args = args[0], args[1:]
+aliases, i = find(cmd)
+cmd = aliases[0]
 defaults = ui.config("defaults", cmd)
 if defaults:
-# reparse with command defaults added
+args = defaults.split() + args
-args = [cmd] + defaults.split() + args
-try:
-args = fancyopts.fancyopts(args, globalopts, options)
-except fancyopts.getopt.GetoptError, inst:
-raise ParseError(None, inst)
-cmd, args = args[0], args[1:]
-i = find(cmd)[1]
 c = list(i[1])
 else:
 cmd = None
 c = []
 sys.stderr.write(_("abort: %s\n") % inst)
 sys.exit(1)
 external = []
 for x in u.extensions():
-def on_exception(Exception, inst):
+def on_exception(exc, inst):
 u.warn(_("*** failed to import extension %s\n") % x[1])
 u.warn("%s\n" % inst)
 if "--traceback" in sys.argv[1:]:
 traceback.print_exc()
 if x[1]:
 help_(u, inst.args[0])
 else:
 u.warn(_("hg: %s\n") % inst.args[1])
 help_(u, 'shortlist')
 sys.exit(-1)
+except AmbiguousCommand, inst:
+u.warn(_("hg: command '%s' is ambiguous.\n") % inst.args[0])
+sys.exit(1)
 except UnknownCommand, inst:
 u.warn(_("hg: unknown command '%s'\n") % inst.args[0])
 help_(u, 'shortlist')
 sys.exit(1)
 if len(tb) > 2: # no
 raise
 u.debug(inst, "\n")
 u.warn(_("%s: invalid arguments\n") % cmd)
 help_(u, cmd)
+except AmbiguousCommand, inst:
+u.warn(_("hg: command '%s' is ambiguous.\n") % inst.args[0])
+help_(u, 'shortlist')
 except UnknownCommand, inst:
 u.warn(_("hg: unknown command '%s'\n") % inst.args[0])
 help_(u, 'shortlist')
 except SystemExit:
 # don't catch this in the catch-all below
 raise
 except:
 u.warn(_("** unknown exception encountered, details follow\n"))
 u.warn(_("** report bug details to mercurial@selenic.com\n"))
+u.warn(_("** Mercurial Distributed SCM (version %s)\n")
+% version.get_version())
 raise
 sys.exit(-1)

changeset 1584	b3e94785ab69
parent 1582	63799b01985c
child 1586	5c5aaaa9ab6f