upstream/mercurial-mirror Commit - r1413:1c64c628

1

# commands.py - command processing for mercurial

1

# commands.py - command processing for mercurial

2

#

2

#

3

4

#

4

#

5

# This software may be used and distributed according to the terms

5

# This software may be used and distributed according to the terms

6

# of the GNU General Public License, incorporated herein by reference.

6

# of the GNU General Public License, incorporated herein by reference.

7

8

from demandload import demandload

8

from demandload import demandload

9

from node import *

9

from node import *

10

from i18n import gettext as _

10

from i18n import gettext as _

11

demandload(globals(), "os re sys signal shutil imp urllib pdb")

11

demandload(globals(), "os re sys signal shutil imp urllib pdb")

12

demandload(globals(), "fancyopts ui hg util lock revlog")

12

demandload(globals(), "fancyopts ui hg util lock revlog")

13

demandload(globals(), "fnmatch hgweb mdiff random signal time traceback")

13

demandload(globals(), "fnmatch hgweb mdiff random signal time traceback")

14

demandload(globals(), "errno socket version struct atexit sets bz2")

14

demandload(globals(), "errno socket version struct atexit sets bz2")

15

16

class UnknownCommand(Exception):

16

class UnknownCommand(Exception):

17

"""Exception raised if command is not in the command table."""

17

"""Exception raised if command is not in the command table."""

18

19

def filterfiles(filters, files):

19

def filterfiles(filters, files):

20

l = [x for x in files if x in filters]

20

l = [x for x in files if x in filters]

21

22

for t in filters:

22

for t in filters:

23

if t and t[-1] != "/":

23

if t and t[-1] != "/":

24

t += "/"

24

t += "/"

25

l += [x for x in files if x.startswith(t)]

25

l += [x for x in files if x.startswith(t)]

26

return l

26

return l

27

28

def relpath(repo, args):

28

def relpath(repo, args):

29

cwd = repo.getcwd()

29

cwd = repo.getcwd()

30

if cwd:

30

if cwd:

31

return [util.normpath(os.path.join(cwd, x)) for x in args]

31

return [util.normpath(os.path.join(cwd, x)) for x in args]

32

return args

32

return args

33

34

def matchpats(repo, cwd, pats=[], opts={}, head=''):

34

def matchpats(repo, cwd, pats=[], opts={}, head=''):

35

return util.matcher(repo.root, cwd, pats or ['.'], opts.get('include'),

35

return util.cmdmatcher(repo.root, cwd, pats or ['.'], opts.get('include'),

36

opts.get('exclude'), head)

36

opts.get('exclude'), head)

37

38

def makewalk(repo, pats, opts, head=''):

38

def makewalk(repo, pats, opts, head=''):

39

cwd = repo.getcwd()

39

cwd = repo.getcwd()

40

files, matchfn, anypats = matchpats(repo, cwd, pats, opts, head)

40

files, matchfn, anypats = matchpats(repo, cwd, pats, opts, head)

41

exact = dict(zip(files, files))

41

exact = dict(zip(files, files))

42

def walk():

42

def walk():

43

for src, fn in repo.walk(files=files, match=matchfn):

43

for src, fn in repo.walk(files=files, match=matchfn):

44

yield src, fn, util.pathto(cwd, fn), fn in exact

44

yield src, fn, util.pathto(cwd, fn), fn in exact

45

return files, matchfn, walk()

45

return files, matchfn, walk()

46

47

def walk(repo, pats, opts, head=''):

47

def walk(repo, pats, opts, head=''):

48

files, matchfn, results = makewalk(repo, pats, opts, head)

48

files, matchfn, results = makewalk(repo, pats, opts, head)

49

for r in results:

49

for r in results:

50

yield r

50

yield r

51

52

def walkchangerevs(ui, repo, cwd, pats, opts):

52

def walkchangerevs(ui, repo, cwd, pats, opts):

53

'''Iterate over files and the revs they changed in.

53

'''Iterate over files and the revs they changed in.

54

55

Callers most commonly need to iterate backwards over the history

55

Callers most commonly need to iterate backwards over the history

56

it is interested in. Doing so has awful (quadratic-looking)

56

it is interested in. Doing so has awful (quadratic-looking)

57

performance, so we use iterators in a "windowed" way.

57

performance, so we use iterators in a "windowed" way.

58

59

We walk a window of revisions in the desired order. Within the

59

We walk a window of revisions in the desired order. Within the

60

window, we first walk forwards to gather data, then in the desired

60

window, we first walk forwards to gather data, then in the desired

61

order (usually backwards) to display it.

61

order (usually backwards) to display it.

62

63

This function returns an (iterator, getchange) pair. The

63

This function returns an (iterator, getchange) pair. The

64

getchange function returns the changelog entry for a numeric

64

getchange function returns the changelog entry for a numeric

65

revision. The iterator yields 3-tuples. They will be of one of

65

revision. The iterator yields 3-tuples. They will be of one of

66

the following forms:

66

the following forms:

67

68

"window", incrementing, lastrev: stepping through a window,

68

"window", incrementing, lastrev: stepping through a window,

69

positive if walking forwards through revs, last rev in the

69

positive if walking forwards through revs, last rev in the

70

sequence iterated over - use to reset state for the current window

70

sequence iterated over - use to reset state for the current window

71

72

"add", rev, fns: out-of-order traversal of the given file names

72

"add", rev, fns: out-of-order traversal of the given file names

73

fns, which changed during revision rev - use to gather data for

73

fns, which changed during revision rev - use to gather data for

74

possible display

74

possible display

75

76

"iter", rev, None: in-order traversal of the revs earlier iterated

76

"iter", rev, None: in-order traversal of the revs earlier iterated

77

over with "add" - use to display data'''

77

over with "add" - use to display data'''

78

79

if repo.changelog.count() == 0:

79

if repo.changelog.count() == 0:

80

return [], False

80

return [], False

81

82

cwd = repo.getcwd()

82

cwd = repo.getcwd()

83

if not pats and cwd:

83

if not pats and cwd:

84

opts['include'] = [os.path.join(cwd, i) for i in opts['include']]

84

opts['include'] = [os.path.join(cwd, i) for i in opts['include']]

85

opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]

85

opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]

86

files, matchfn, anypats = matchpats(repo, (pats and cwd) or '',

86

files, matchfn, anypats = matchpats(repo, (pats and cwd) or '',

87

pats, opts)

87

pats, opts)

88

revs = map(int, revrange(ui, repo, opts['rev'] or ['tip:0']))

88

revs = map(int, revrange(ui, repo, opts['rev'] or ['tip:0']))

89

wanted = {}

89

wanted = {}

90

slowpath = anypats

90

slowpath = anypats

91

window = 300

91

window = 300

92

fncache = {}

92

fncache = {}

93

94

chcache = {}

94

chcache = {}

95

def getchange(rev):

95

def getchange(rev):

96

ch = chcache.get(rev)

96

ch = chcache.get(rev)

97

if ch is None:

97

if ch is None:

98

chcache[rev] = ch = repo.changelog.read(repo.lookup(str(rev)))

98

chcache[rev] = ch = repo.changelog.read(repo.lookup(str(rev)))

99

return ch

99

return ch

100

101

if not slowpath and not files:

101

if not slowpath and not files:

102

# No files, no patterns. Display all revs.

102

# No files, no patterns. Display all revs.

103

wanted = dict(zip(revs, revs))

103

wanted = dict(zip(revs, revs))

104

if not slowpath:

104

if not slowpath:

105

# Only files, no patterns. Check the history of each file.

105

# Only files, no patterns. Check the history of each file.

106

def filerevgen(filelog):

106

def filerevgen(filelog):

107

for i in xrange(filelog.count() - 1, -1, -window):

107

for i in xrange(filelog.count() - 1, -1, -window):

108

revs = []

108

revs = []

109

for j in xrange(max(0, i - window), i + 1):

109

for j in xrange(max(0, i - window), i + 1):

110

revs.append(filelog.linkrev(filelog.node(j)))

110

revs.append(filelog.linkrev(filelog.node(j)))

111

revs.reverse()

111

revs.reverse()

112

for rev in revs:

112

for rev in revs:

113

yield rev

113

yield rev

114

115

minrev, maxrev = min(revs), max(revs)

115

minrev, maxrev = min(revs), max(revs)

116

for file in files:

116

for file in files:

117

filelog = repo.file(file)

117

filelog = repo.file(file)

118

# A zero count may be a directory or deleted file, so

118

# A zero count may be a directory or deleted file, so

119

# try to find matching entries on the slow path.

119

# try to find matching entries on the slow path.

120

if filelog.count() == 0:

120

if filelog.count() == 0:

121

slowpath = True

121

slowpath = True

122

break

122

break

123

for rev in filerevgen(filelog):

123

for rev in filerevgen(filelog):

124

if rev <= maxrev:

124

if rev <= maxrev:

125

if rev < minrev:

125

if rev < minrev:

126

break

126

break

127

fncache.setdefault(rev, [])

127

fncache.setdefault(rev, [])

128

fncache[rev].append(file)

128

fncache[rev].append(file)

129

wanted[rev] = 1

129

wanted[rev] = 1

130

if slowpath:

130

if slowpath:

131

# The slow path checks files modified in every changeset.

131

# The slow path checks files modified in every changeset.

132

def changerevgen():

132

def changerevgen():

133

for i in xrange(repo.changelog.count() - 1, -1, -window):

133

for i in xrange(repo.changelog.count() - 1, -1, -window):

134

for j in xrange(max(0, i - window), i + 1):

134

for j in xrange(max(0, i - window), i + 1):

135

yield j, getchange(j)[3]

135

yield j, getchange(j)[3]

136

137

for rev, changefiles in changerevgen():

137

for rev, changefiles in changerevgen():

138

matches = filter(matchfn, changefiles)

138

matches = filter(matchfn, changefiles)

139

if matches:

139

if matches:

140

fncache[rev] = matches

140

fncache[rev] = matches

141

wanted[rev] = 1

141

wanted[rev] = 1

142

143

def iterate():

143

def iterate():

144

for i in xrange(0, len(revs), window):

144

for i in xrange(0, len(revs), window):

145

yield 'window', revs[0] < revs[-1], revs[-1]

145

yield 'window', revs[0] < revs[-1], revs[-1]

146

nrevs = [rev for rev in revs[i:min(i+window, len(revs))]

146

nrevs = [rev for rev in revs[i:min(i+window, len(revs))]

147

if rev in wanted]

147

if rev in wanted]

148

srevs = list(nrevs)

148

srevs = list(nrevs)

149

srevs.sort()

149

srevs.sort()

150

for rev in srevs:

150

for rev in srevs:

151

fns = fncache.get(rev) or filter(matchfn, getchange(rev)[3])

151

fns = fncache.get(rev) or filter(matchfn, getchange(rev)[3])

152

yield 'add', rev, fns

152

yield 'add', rev, fns

153

for rev in nrevs:

153

for rev in nrevs:

154

yield 'iter', rev, None

154

yield 'iter', rev, None

155

return iterate(), getchange

155

return iterate(), getchange

156

157

revrangesep = ':'

157

revrangesep = ':'

158

159

def revrange(ui, repo, revs, revlog=None):

159

def revrange(ui, repo, revs, revlog=None):

160

"""Yield revision as strings from a list of revision specifications."""

160

"""Yield revision as strings from a list of revision specifications."""

161

if revlog is None:

161

if revlog is None:

162

revlog = repo.changelog

162

revlog = repo.changelog

163

revcount = revlog.count()

163

revcount = revlog.count()

164

def fix(val, defval):

164

def fix(val, defval):

165

if not val:

165

if not val:

166

return defval

166

return defval

167

try:

167

try:

168

num = int(val)

168

num = int(val)

169

if str(num) != val:

169

if str(num) != val:

170

raise ValueError

170

raise ValueError

171

if num < 0: num += revcount

171

if num < 0: num += revcount

172

if num < 0: num = 0

172

if num < 0: num = 0

173

elif num >= revcount:

173

elif num >= revcount:

174

raise ValueError

174

raise ValueError

175

except ValueError:

175

except ValueError:

176

try:

176

try:

177

num = repo.changelog.rev(repo.lookup(val))

177

num = repo.changelog.rev(repo.lookup(val))

178

except KeyError:

178

except KeyError:

179

try:

179

try:

180

num = revlog.rev(revlog.lookup(val))

180

num = revlog.rev(revlog.lookup(val))

181

except KeyError:

181

except KeyError:

182

raise util.Abort(_('invalid revision identifier %s'), val)

182

raise util.Abort(_('invalid revision identifier %s'), val)

183

return num

183

return num

184

seen = {}

184

seen = {}

185

for spec in revs:

185

for spec in revs:

186

if spec.find(revrangesep) >= 0:

186

if spec.find(revrangesep) >= 0:

187

start, end = spec.split(revrangesep, 1)

187

start, end = spec.split(revrangesep, 1)

188

start = fix(start, 0)

188

start = fix(start, 0)

189

end = fix(end, revcount - 1)

189

end = fix(end, revcount - 1)

190

step = start > end and -1 or 1

190

step = start > end and -1 or 1

191

for rev in xrange(start, end+step, step):

191

for rev in xrange(start, end+step, step):

192

if rev in seen: continue

192

if rev in seen: continue

193

seen[rev] = 1

193

seen[rev] = 1

194

yield str(rev)

194

yield str(rev)

195

else:

195

else:

196

rev = fix(spec, None)

196

rev = fix(spec, None)

197

if rev in seen: continue

197

if rev in seen: continue

198

seen[rev] = 1

198

seen[rev] = 1

199

yield str(rev)

199

yield str(rev)

200

201

def make_filename(repo, r, pat, node=None,

201

def make_filename(repo, r, pat, node=None,

202

total=None, seqno=None, revwidth=None, pathname=None):

202

total=None, seqno=None, revwidth=None, pathname=None):

203

node_expander = {

203

node_expander = {

204

'H': lambda: hex(node),

204

'H': lambda: hex(node),

205

'R': lambda: str(r.rev(node)),

205

'R': lambda: str(r.rev(node)),

206

'h': lambda: short(node),

206

'h': lambda: short(node),

207

}

207

}

208

expander = {

208

expander = {

209

'%': lambda: '%',

209

'%': lambda: '%',

210

'b': lambda: os.path.basename(repo.root),

210

'b': lambda: os.path.basename(repo.root),

211

}

211

}

212

213

try:

213

try:

214

if node:

214

if node:

215

expander.update(node_expander)

215

expander.update(node_expander)

216

if node and revwidth is not None:

216

if node and revwidth is not None:

217

expander['r'] = lambda: str(r.rev(node)).zfill(revwidth)

217

expander['r'] = lambda: str(r.rev(node)).zfill(revwidth)

218

if total is not None:

218

if total is not None:

219

expander['N'] = lambda: str(total)

219

expander['N'] = lambda: str(total)

220

if seqno is not None:

220

if seqno is not None:

221

expander['n'] = lambda: str(seqno)

221

expander['n'] = lambda: str(seqno)

222

if total is not None and seqno is not None:

222

if total is not None and seqno is not None:

223

expander['n'] = lambda:str(seqno).zfill(len(str(total)))

223

expander['n'] = lambda:str(seqno).zfill(len(str(total)))

224

if pathname is not None:

224

if pathname is not None:

225

expander['s'] = lambda: os.path.basename(pathname)

225

expander['s'] = lambda: os.path.basename(pathname)

226

expander['d'] = lambda: os.path.dirname(pathname) or '.'

226

expander['d'] = lambda: os.path.dirname(pathname) or '.'

227

expander['p'] = lambda: pathname

227

expander['p'] = lambda: pathname

228

229

newname = []

229

newname = []

230

patlen = len(pat)

230

patlen = len(pat)

231

i = 0

231

i = 0

232

while i < patlen:

232

while i < patlen:

233

c = pat[i]

233

c = pat[i]

234

if c == '%':

234

if c == '%':

235

i += 1

235

i += 1

236

c = pat[i]

236

c = pat[i]

237

c = expander[c]()

237

c = expander[c]()

238

newname.append(c)

238

newname.append(c)

239

i += 1

239

i += 1

240

return ''.join(newname)

240

return ''.join(newname)

241

except KeyError, inst:

241

except KeyError, inst:

242

raise util.Abort(_("invalid format spec '%%%s' in output file name"),

242

raise util.Abort(_("invalid format spec '%%%s' in output file name"),

243

inst.args[0])

243

inst.args[0])

244

245

def make_file(repo, r, pat, node=None,

245

def make_file(repo, r, pat, node=None,

246

total=None, seqno=None, revwidth=None, mode='wb', pathname=None):

246

total=None, seqno=None, revwidth=None, mode='wb', pathname=None):

247

if not pat or pat == '-':

247

if not pat or pat == '-':

248

return 'w' in mode and sys.stdout or sys.stdin

248

return 'w' in mode and sys.stdout or sys.stdin

249

if hasattr(pat, 'write') and 'w' in mode:

249

if hasattr(pat, 'write') and 'w' in mode:

250

return pat

250

return pat

251

if hasattr(pat, 'read') and 'r' in mode:

251

if hasattr(pat, 'read') and 'r' in mode:

252

return pat

252

return pat

253

return open(make_filename(repo, r, pat, node, total, seqno, revwidth,

253

return open(make_filename(repo, r, pat, node, total, seqno, revwidth,

254

pathname),

254

pathname),

255

mode)

255

mode)

256

257

def dodiff(fp, ui, repo, node1, node2, files=None, match=util.always,

257

def dodiff(fp, ui, repo, node1, node2, files=None, match=util.always,

258

changes=None, text=False):

258

changes=None, text=False):

259

if not changes:

259

if not changes:

260

(c, a, d, u) = repo.changes(node1, node2, files, match=match)

260

(c, a, d, u) = repo.changes(node1, node2, files, match=match)

261

else:

261

else:

262

(c, a, d, u) = changes

262

(c, a, d, u) = changes

263

if files:

263

if files:

264

c, a, d = map(lambda x: filterfiles(files, x), (c, a, d))

264

c, a, d = map(lambda x: filterfiles(files, x), (c, a, d))

265

266

if not c and not a and not d:

266

if not c and not a and not d:

267

return

267

return

268

269

if node2:

269

if node2:

270

change = repo.changelog.read(node2)

270

change = repo.changelog.read(node2)

271

mmap2 = repo.manifest.read(change[0])

271

mmap2 = repo.manifest.read(change[0])

272

date2 = util.datestr(change[2])

272

date2 = util.datestr(change[2])

273

def read(f):

273

def read(f):

274

return repo.file(f).read(mmap2[f])

274

return repo.file(f).read(mmap2[f])

275

else:

275

else:

276

date2 = util.datestr()

276

date2 = util.datestr()

277

if not node1:

277

if not node1:

278

node1 = repo.dirstate.parents()[0]

278

node1 = repo.dirstate.parents()[0]

279

def read(f):

279

def read(f):

280

return repo.wfile(f).read()

280

return repo.wfile(f).read()

281

282

if ui.quiet:

282

if ui.quiet:

283

r = None

283

r = None

284

else:

284

else:

285

hexfunc = ui.verbose and hex or short

285

hexfunc = ui.verbose and hex or short

286

r = [hexfunc(node) for node in [node1, node2] if node]

286

r = [hexfunc(node) for node in [node1, node2] if node]

287

288

change = repo.changelog.read(node1)

288

change = repo.changelog.read(node1)

289

mmap = repo.manifest.read(change[0])

289

mmap = repo.manifest.read(change[0])

290

date1 = util.datestr(change[2])

290

date1 = util.datestr(change[2])

291

292

for f in c:

292

for f in c:

293

to = None

293

to = None

294

if f in mmap:

294

if f in mmap:

295

to = repo.file(f).read(mmap[f])

295

to = repo.file(f).read(mmap[f])

296

tn = read(f)

296

tn = read(f)

297

fp.write(mdiff.unidiff(to, date1, tn, date2, f, r, text=text))

297

fp.write(mdiff.unidiff(to, date1, tn, date2, f, r, text=text))

298

for f in a:

298

for f in a:

299

to = None

299

to = None

300

tn = read(f)

300

tn = read(f)

301

fp.write(mdiff.unidiff(to, date1, tn, date2, f, r, text=text))

301

fp.write(mdiff.unidiff(to, date1, tn, date2, f, r, text=text))

302

for f in d:

302

for f in d:

303

to = repo.file(f).read(mmap[f])

303

to = repo.file(f).read(mmap[f])

304

tn = None

304

tn = None

305

fp.write(mdiff.unidiff(to, date1, tn, date2, f, r, text=text))

305

fp.write(mdiff.unidiff(to, date1, tn, date2, f, r, text=text))

306

307

def trimuser(ui, name, rev, revcache):

307

def trimuser(ui, name, rev, revcache):

308

"""trim the name of the user who committed a change"""

308

"""trim the name of the user who committed a change"""

309

user = revcache.get(rev)

309

user = revcache.get(rev)

310

if user is None:

310

if user is None:

311

user = revcache[rev] = ui.shortuser(name)

311

user = revcache[rev] = ui.shortuser(name)

312

return user

312

return user

313

314

def show_changeset(ui, repo, rev=0, changenode=None, brinfo=None):

314

def show_changeset(ui, repo, rev=0, changenode=None, brinfo=None):

315

"""show a single changeset or file revision"""

315

"""show a single changeset or file revision"""

316

log = repo.changelog

316

log = repo.changelog

317

if changenode is None:

317

if changenode is None:

318

changenode = log.node(rev)

318

changenode = log.node(rev)

319

elif not rev:

319

elif not rev:

320

rev = log.rev(changenode)

320

rev = log.rev(changenode)

321

322

if ui.quiet:

322

if ui.quiet:

323

ui.write("%d:%s\n" % (rev, short(changenode)))

323

ui.write("%d:%s\n" % (rev, short(changenode)))

324

return

324

return

325

326

changes = log.read(changenode)

326

changes = log.read(changenode)

327

date = util.datestr(changes[2])

327

date = util.datestr(changes[2])

328

329

parents = [(log.rev(p), ui.verbose and hex(p) or short(p))

329

parents = [(log.rev(p), ui.verbose and hex(p) or short(p))

330

for p in log.parents(changenode)

330

for p in log.parents(changenode)

331

if ui.debugflag or p != nullid]

331

if ui.debugflag or p != nullid]

332

if not ui.debugflag and len(parents) == 1 and parents[0][0] == rev-1:

332

if not ui.debugflag and len(parents) == 1 and parents[0][0] == rev-1:

333

parents = []

333

parents = []

334

335

if ui.verbose:

335

if ui.verbose:

336

ui.write(_("changeset: %d:%s\n") % (rev, hex(changenode)))

336

ui.write(_("changeset: %d:%s\n") % (rev, hex(changenode)))

337

else:

337

else:

338

ui.write(_("changeset: %d:%s\n") % (rev, short(changenode)))

338

ui.write(_("changeset: %d:%s\n") % (rev, short(changenode)))

339

340

for tag in repo.nodetags(changenode):

340

for tag in repo.nodetags(changenode):

341

ui.status(_("tag: %s\n") % tag)

341

ui.status(_("tag: %s\n") % tag)

342

for parent in parents:

342

for parent in parents:

343

ui.write(_("parent: %d:%s\n") % parent)

343

ui.write(_("parent: %d:%s\n") % parent)

344

345

if brinfo and changenode in brinfo:

345

if brinfo and changenode in brinfo:

346

br = brinfo[changenode]

346

br = brinfo[changenode]

347

ui.write(_("branch: %s\n") % " ".join(br))

347

ui.write(_("branch: %s\n") % " ".join(br))

348

349

ui.debug(_("manifest: %d:%s\n") % (repo.manifest.rev(changes[0]),

349

ui.debug(_("manifest: %d:%s\n") % (repo.manifest.rev(changes[0]),

350

hex(changes[0])))

350

hex(changes[0])))

351

ui.status(_("user: %s\n") % changes[1])

351

ui.status(_("user: %s\n") % changes[1])

352

ui.status(_("date: %s\n") % date)

352

ui.status(_("date: %s\n") % date)

353

354

if ui.debugflag:

354

if ui.debugflag:

355

files = repo.changes(log.parents(changenode)[0], changenode)

355

files = repo.changes(log.parents(changenode)[0], changenode)

356

for key, value in zip([_("files:"), _("files+:"), _("files-:")], files):

356

for key, value in zip([_("files:"), _("files+:"), _("files-:")], files):

357

if value:

357

if value:

358

ui.note("%-12s %s\n" % (key, " ".join(value)))

358

ui.note("%-12s %s\n" % (key, " ".join(value)))

359

else:

359

else:

360

ui.note(_("files: %s\n") % " ".join(changes[3]))

360

ui.note(_("files: %s\n") % " ".join(changes[3]))

361

362

description = changes[4].strip()

362

description = changes[4].strip()

363

if description:

363

if description:

364

if ui.verbose:

364

if ui.verbose:

365

ui.status(_("description:\n"))

365

ui.status(_("description:\n"))

366

ui.status(description)

366

ui.status(description)

367

ui.status("\n\n")

367

ui.status("\n\n")

368

else:

368

else:

369

ui.status(_("summary: %s\n") % description.splitlines()[0])

369

ui.status(_("summary: %s\n") % description.splitlines()[0])

370

ui.status("\n")

370

ui.status("\n")

371

372

def show_version(ui):

372

def show_version(ui):

373

"""output version and copyright information"""

373

"""output version and copyright information"""

374

ui.write(_("Mercurial Distributed SCM (version %s)\n")

374

ui.write(_("Mercurial Distributed SCM (version %s)\n")

375

% version.get_version())

375

% version.get_version())

376

ui.status(_(

376

ui.status(_(

377

378

"This is free software; see the source for copying conditions. "

378

"This is free software; see the source for copying conditions. "

379

"There is NO\nwarranty; "

379

"There is NO\nwarranty; "

380

"not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"

380

"not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"

381

))

381

))

382

383

def help_(ui, cmd=None, with_version=False):

383

def help_(ui, cmd=None, with_version=False):

384

"""show help for a given command or all commands"""

384

"""show help for a given command or all commands"""

385

option_lists = []

385

option_lists = []

386

if cmd and cmd != 'shortlist':

386

if cmd and cmd != 'shortlist':

387

if with_version:

387

if with_version:

388

show_version(ui)

388

show_version(ui)

389

ui.write('\n')

389

ui.write('\n')

390

key, i = find(cmd)

390

key, i = find(cmd)

391

# synopsis

391

# synopsis

392

ui.write("%s\n\n" % i[2])

392

ui.write("%s\n\n" % i[2])

393

394

# description

394

# description

395

doc = i[0].__doc__

395

doc = i[0].__doc__

396

if ui.quiet:

396

if ui.quiet:

397

doc = doc.splitlines(0)[0]

397

doc = doc.splitlines(0)[0]

398

ui.write("%s\n" % doc.rstrip())

398

ui.write("%s\n" % doc.rstrip())

399

400

if not ui.quiet:

400

if not ui.quiet:

401

# aliases

401

# aliases

402

aliases = ', '.join(key.split('|')[1:])

402

aliases = ', '.join(key.split('|')[1:])

403

if aliases:

403

if aliases:

404

ui.write(_("\naliases: %s\n") % aliases)

404

ui.write(_("\naliases: %s\n") % aliases)

405

406

# options

406

# options

407

if i[1]:

407

if i[1]:

408

option_lists.append(("options", i[1]))

408

option_lists.append(("options", i[1]))

409

410

else:

410

else:

411

# program name

411

# program name

412

if ui.verbose or with_version:

412

if ui.verbose or with_version:

413

show_version(ui)

413

show_version(ui)

414

else:

414

else:

415

ui.status(_("Mercurial Distributed SCM\n"))

415

ui.status(_("Mercurial Distributed SCM\n"))

416

ui.status('\n')

416

ui.status('\n')

417

418

# list of commands

418

# list of commands

419

if cmd == "shortlist":

419

if cmd == "shortlist":

420

ui.status(_('basic commands (use "hg help" '

420

ui.status(_('basic commands (use "hg help" '

421

'for the full list or option "-v" for details):\n\n'))

421

'for the full list or option "-v" for details):\n\n'))

422

elif ui.verbose:

422

elif ui.verbose:

423

ui.status(_('list of commands:\n\n'))

423

ui.status(_('list of commands:\n\n'))

424

else:

424

else:

425

ui.status(_('list of commands (use "hg help -v" '

425

ui.status(_('list of commands (use "hg help -v" '

426

'to show aliases and global options):\n\n'))

426

'to show aliases and global options):\n\n'))

427

428

h = {}

428

h = {}

429

cmds = {}

429

cmds = {}

430

for c, e in table.items():

430

for c, e in table.items():

431

f = c.split("|")[0]

431

f = c.split("|")[0]

432

if cmd == "shortlist" and not f.startswith("^"):

432

if cmd == "shortlist" and not f.startswith("^"):

433

continue

433

continue

434

f = f.lstrip("^")

434

f = f.lstrip("^")

435

if not ui.debugflag and f.startswith("debug"):

435

if not ui.debugflag and f.startswith("debug"):

436

continue

436

continue

437

d = ""

437

d = ""

438

if e[0].__doc__:

438

if e[0].__doc__:

439

d = e[0].__doc__.splitlines(0)[0].rstrip()

439

d = e[0].__doc__.splitlines(0)[0].rstrip()

440

h[f] = d

440

h[f] = d

441

cmds[f]=c.lstrip("^")

441

cmds[f]=c.lstrip("^")

442

443

fns = h.keys()

443

fns = h.keys()

444

fns.sort()

444

fns.sort()

445

m = max(map(len, fns))

445

m = max(map(len, fns))

446

for f in fns:

446

for f in fns:

447

if ui.verbose:

447

if ui.verbose:

448

commands = cmds[f].replace("|",", ")

448

commands = cmds[f].replace("|",", ")

449

ui.write(" %s:\n %s\n"%(commands,h[f]))

449

ui.write(" %s:\n %s\n"%(commands,h[f]))

450

else:

450

else:

451

ui.write(' %-*s %s\n' % (m, f, h[f]))

451

ui.write(' %-*s %s\n' % (m, f, h[f]))

452

453

# global options

453

# global options

454

if ui.verbose:

454

if ui.verbose:

455

option_lists.append(("global options", globalopts))

455

option_lists.append(("global options", globalopts))

456

457

# list all option lists

457

# list all option lists

458

opt_output = []

458

opt_output = []

459

for title, options in option_lists:

459

for title, options in option_lists:

460

opt_output.append(("\n%s:\n" % title, None))

460

opt_output.append(("\n%s:\n" % title, None))

461

for shortopt, longopt, default, desc in options:

461

for shortopt, longopt, default, desc in options:

462

opt_output.append(("%2s%s" % (shortopt and "-%s" % shortopt,

462

opt_output.append(("%2s%s" % (shortopt and "-%s" % shortopt,

463

longopt and " --%s" % longopt),

463

longopt and " --%s" % longopt),

464

"%s%s" % (desc,

464

"%s%s" % (desc,

465

default and _(" (default: %s)") % default

465

default and _(" (default: %s)") % default

466

or "")))

466

or "")))

467

468

if opt_output:

468

if opt_output:

469

opts_len = max([len(line[0]) for line in opt_output if line[1]])

469

opts_len = max([len(line[0]) for line in opt_output if line[1]])

470

for first, second in opt_output:

470

for first, second in opt_output:

471

if second:

471

if second:

472

ui.write(" %-*s %s\n" % (opts_len, first, second))

472

ui.write(" %-*s %s\n" % (opts_len, first, second))

473

else:

473

else:

474

ui.write("%s\n" % first)

474

ui.write("%s\n" % first)

475

476

# Commands start here, listed alphabetically

476

# Commands start here, listed alphabetically

477

478

def add(ui, repo, *pats, **opts):

478

def add(ui, repo, *pats, **opts):

479

'''add the specified files on the next commit'''

479

'''add the specified files on the next commit'''

480

names = []

480

names = []

481

for src, abs, rel, exact in walk(repo, pats, opts):

481

for src, abs, rel, exact in walk(repo, pats, opts):

482

if exact:

482

if exact:

483

if ui.verbose: ui.status(_('adding %s\n') % rel)

483

if ui.verbose: ui.status(_('adding %s\n') % rel)

484

names.append(abs)

484

names.append(abs)

485

elif repo.dirstate.state(abs) == '?':

485

elif repo.dirstate.state(abs) == '?':

486

ui.status(_('adding %s\n') % rel)

486

ui.status(_('adding %s\n') % rel)

487

names.append(abs)

487

names.append(abs)

488

repo.add(names)

488

repo.add(names)

489

490

def addremove(ui, repo, *pats, **opts):

490

def addremove(ui, repo, *pats, **opts):

491

"""add all new files, delete all missing files"""

491

"""add all new files, delete all missing files"""

492

add, remove = [], []

492

add, remove = [], []

493

for src, abs, rel, exact in walk(repo, pats, opts):

493

for src, abs, rel, exact in walk(repo, pats, opts):

494

if src == 'f' and repo.dirstate.state(abs) == '?':

494

if src == 'f' and repo.dirstate.state(abs) == '?':

495

add.append(abs)

495

add.append(abs)

496

if ui.verbose or not exact:

496

if ui.verbose or not exact:

497

ui.status(_('adding %s\n') % rel)

497

ui.status(_('adding %s\n') % rel)

498

if repo.dirstate.state(abs) != 'r' and not os.path.exists(rel):

498

if repo.dirstate.state(abs) != 'r' and not os.path.exists(rel):

499

remove.append(abs)

499

remove.append(abs)

500

if ui.verbose or not exact:

500

if ui.verbose or not exact:

501

ui.status(_('removing %s\n') % rel)

501

ui.status(_('removing %s\n') % rel)

502

repo.add(add)

502

repo.add(add)

503

repo.remove(remove)

503

repo.remove(remove)

504

505

def annotate(ui, repo, *pats, **opts):

505

def annotate(ui, repo, *pats, **opts):

506

"""show changeset information per file line"""

506

"""show changeset information per file line"""

507

def getnode(rev):

507

def getnode(rev):

508

return short(repo.changelog.node(rev))

508

return short(repo.changelog.node(rev))

509

510

ucache = {}

510

ucache = {}

511

def getname(rev):

511

def getname(rev):

512

cl = repo.changelog.read(repo.changelog.node(rev))

512

cl = repo.changelog.read(repo.changelog.node(rev))

513

return trimuser(ui, cl[1], rev, ucache)

513

return trimuser(ui, cl[1], rev, ucache)

514

515

if not pats:

515

if not pats:

516

raise util.Abort(_('at least one file name or pattern required'))

516

raise util.Abort(_('at least one file name or pattern required'))

517

518

opmap = [['user', getname], ['number', str], ['changeset', getnode]]

518

opmap = [['user', getname], ['number', str], ['changeset', getnode]]

519

if not opts['user'] and not opts['changeset']:

519

if not opts['user'] and not opts['changeset']:

520

opts['number'] = 1

520

opts['number'] = 1

521

522

if opts['rev']:

522

if opts['rev']:

523

node = repo.changelog.lookup(opts['rev'])

523

node = repo.changelog.lookup(opts['rev'])

524

else:

524

else:

525

node = repo.dirstate.parents()[0]

525

node = repo.dirstate.parents()[0]

526

change = repo.changelog.read(node)

526

change = repo.changelog.read(node)

527

mmap = repo.manifest.read(change[0])

527

mmap = repo.manifest.read(change[0])

528

529

for src, abs, rel, exact in walk(repo, pats, opts):

529

for src, abs, rel, exact in walk(repo, pats, opts):

530

if abs not in mmap:

530

if abs not in mmap:

531

ui.warn(_("warning: %s is not in the repository!\n") % rel)

531

ui.warn(_("warning: %s is not in the repository!\n") % rel)

532

continue

532

continue

533

534

f = repo.file(abs)

534

f = repo.file(abs)

535

if not opts['text'] and util.binary(f.read(mmap[abs])):

535

if not opts['text'] and util.binary(f.read(mmap[abs])):

536

ui.write(_("%s: binary file\n") % rel)

536

ui.write(_("%s: binary file\n") % rel)

537

continue

537

continue

538

539

lines = f.annotate(mmap[abs])

539

lines = f.annotate(mmap[abs])

540

pieces = []

540

pieces = []

541

542

for o, f in opmap:

542

for o, f in opmap:

543

if opts[o]:

543

if opts[o]:

544

l = [f(n) for n, dummy in lines]

544

l = [f(n) for n, dummy in lines]

545

if l:

545

if l:

546

m = max(map(len, l))

546

m = max(map(len, l))

547

pieces.append(["%*s" % (m, x) for x in l])

547

pieces.append(["%*s" % (m, x) for x in l])

548

549

if pieces:

549

if pieces:

550

for p, l in zip(zip(*pieces), lines):

550

for p, l in zip(zip(*pieces), lines):

551

ui.write("%s: %s" % (" ".join(p), l[1]))

551

ui.write("%s: %s" % (" ".join(p), l[1]))

552

553

def bundle(ui, repo, fname, dest="default-push", **opts):

553

def bundle(ui, repo, fname, dest="default-push", **opts):

554

"""create a changegroup file"""

554

"""create a changegroup file"""

555

f = open(fname, "wb")

555

f = open(fname, "wb")

556

dest = ui.expandpath(dest)

556

dest = ui.expandpath(dest)

557

other = hg.repository(ui, dest)

557

other = hg.repository(ui, dest)

558

o = repo.findoutgoing(other)

558

o = repo.findoutgoing(other)

559

cg = repo.changegroup(o)

559

cg = repo.changegroup(o)

560

561

try:

561

try:

562

f.write("HG10")

562

f.write("HG10")

563

z = bz2.BZ2Compressor(9)

563

z = bz2.BZ2Compressor(9)

564

while 1:

564

while 1:

565

chunk = cg.read(4096)

565

chunk = cg.read(4096)

566

if not chunk:

566

if not chunk:

567

break

567

break

568

f.write(z.compress(chunk))

568

f.write(z.compress(chunk))

569

f.write(z.flush())

569

f.write(z.flush())

570

except:

570

except:

571

os.unlink(fname)

571

os.unlink(fname)

572

raise

572

raise

573

574

def cat(ui, repo, file1, *pats, **opts):

574

def cat(ui, repo, file1, *pats, **opts):

575

"""output the latest or given revisions of files"""

575

"""output the latest or given revisions of files"""

576

mf = {}

576

mf = {}

577

if opts['rev']:

577

if opts['rev']:

578

change = repo.changelog.read(repo.lookup(opts['rev']))

578

change = repo.changelog.read(repo.lookup(opts['rev']))

579

mf = repo.manifest.read(change[0])

579

mf = repo.manifest.read(change[0])

580

for src, abs, rel, exact in walk(repo, (file1,) + pats, opts):

580

for src, abs, rel, exact in walk(repo, (file1,) + pats, opts):

581

r = repo.file(abs)

581

r = repo.file(abs)

582

if opts['rev']:

582

if opts['rev']:

583

try:

583

try:

584

n = mf[abs]

584

n = mf[abs]

585

except (hg.RepoError, KeyError):

585

except (hg.RepoError, KeyError):

586

try:

586

try:

587

n = r.lookup(rev)

587

n = r.lookup(rev)

588

except KeyError, inst:

588

except KeyError, inst:

589

raise util.Abort(_('cannot find file %s in rev %s'), rel, rev)

589

raise util.Abort(_('cannot find file %s in rev %s'), rel, rev)

590

else:

590

else:

591

n = r.tip()

591

n = r.tip()

592

fp = make_file(repo, r, opts['output'], node=n, pathname=abs)

592

fp = make_file(repo, r, opts['output'], node=n, pathname=abs)

593

fp.write(r.read(n))

593

fp.write(r.read(n))

594

595

def clone(ui, source, dest=None, **opts):

595

def clone(ui, source, dest=None, **opts):

596

"""make a copy of an existing repository"""

596

"""make a copy of an existing repository"""

597

if dest is None:

597

if dest is None:

598

dest = os.path.basename(os.path.normpath(source))

598

dest = os.path.basename(os.path.normpath(source))

599

600

if os.path.exists(dest):

600

if os.path.exists(dest):

601

raise util.Abort(_("destination '%s' already exists"), dest)

601

raise util.Abort(_("destination '%s' already exists"), dest)

602

603

dest = os.path.realpath(dest)

603

dest = os.path.realpath(dest)

604

605

class Dircleanup:

605

class Dircleanup:

606

def __init__(self, dir_):

606

def __init__(self, dir_):

607

self.rmtree = shutil.rmtree

607

self.rmtree = shutil.rmtree

608

self.dir_ = dir_

608

self.dir_ = dir_

609

os.mkdir(dir_)

609

os.mkdir(dir_)

610

def close(self):

610

def close(self):

611

self.dir_ = None

611

self.dir_ = None

612

def __del__(self):

612

def __del__(self):

613

if self.dir_:

613

if self.dir_:

614

self.rmtree(self.dir_, True)

614

self.rmtree(self.dir_, True)

615

616

if opts['ssh']:

616

if opts['ssh']:

617

ui.setconfig("ui", "ssh", opts['ssh'])

617

ui.setconfig("ui", "ssh", opts['ssh'])

618

if opts['remotecmd']:

618

if opts['remotecmd']:

619

ui.setconfig("ui", "remotecmd", opts['remotecmd'])

619

ui.setconfig("ui", "remotecmd", opts['remotecmd'])

620

621

if not os.path.exists(source):

621

if not os.path.exists(source):

622

source = ui.expandpath(source)

622

source = ui.expandpath(source)

623

624

d = Dircleanup(dest)

624

d = Dircleanup(dest)

625

abspath = source

625

abspath = source

626

other = hg.repository(ui, source)

626

other = hg.repository(ui, source)

627

628

copy = False

628

copy = False

629

if other.dev() != -1:

629

if other.dev() != -1:

630

abspath = os.path.abspath(source)

630

abspath = os.path.abspath(source)

631

if not opts['pull']:

631

if not opts['pull']:

632

copy = True

632

copy = True

633

634

if copy:

634

if copy:

635

try:

635

try:

636

# we use a lock here because if we race with commit, we

636

# we use a lock here because if we race with commit, we

637

# can end up with extra data in the cloned revlogs that's

637

# can end up with extra data in the cloned revlogs that's

638

# not pointed to by changesets, thus causing verify to

638

# not pointed to by changesets, thus causing verify to

639

# fail

639

# fail

640

l1 = lock.lock(os.path.join(source, ".hg", "lock"))

640

l1 = lock.lock(os.path.join(source, ".hg", "lock"))

641

except OSError:

641

except OSError:

642

copy = False

642

copy = False

643

644

if copy:

644

if copy:

645

# we lock here to avoid premature writing to the target

645

# we lock here to avoid premature writing to the target

646

os.mkdir(os.path.join(dest, ".hg"))

646

os.mkdir(os.path.join(dest, ".hg"))

647

l2 = lock.lock(os.path.join(dest, ".hg", "lock"))

647

l2 = lock.lock(os.path.join(dest, ".hg", "lock"))

648

649

files = "data 00manifest.d 00manifest.i 00changelog.d 00changelog.i"

649

files = "data 00manifest.d 00manifest.i 00changelog.d 00changelog.i"

650

for f in files.split():

650

for f in files.split():

651

src = os.path.join(source, ".hg", f)

651

src = os.path.join(source, ".hg", f)

652

dst = os.path.join(dest, ".hg", f)

652

dst = os.path.join(dest, ".hg", f)

653

util.copyfiles(src, dst)

653

util.copyfiles(src, dst)

654

655

repo = hg.repository(ui, dest)

655

repo = hg.repository(ui, dest)

656

657

else:

657

else:

658

repo = hg.repository(ui, dest, create=1)

658

repo = hg.repository(ui, dest, create=1)

659

repo.pull(other)

659

repo.pull(other)

660

661

f = repo.opener("hgrc", "w", text=True)

661

f = repo.opener("hgrc", "w", text=True)

662

f.write("[paths]\n")

662

f.write("[paths]\n")

663

f.write("default = %s\n" % abspath)

663

f.write("default = %s\n" % abspath)

664

665

if not opts['noupdate']:

665

if not opts['noupdate']:

666

update(ui, repo)

666

update(ui, repo)

667

668

d.close()

668

d.close()

669

670

def commit(ui, repo, *pats, **opts):

670

def commit(ui, repo, *pats, **opts):

671

"""commit the specified files or all outstanding changes"""

671

"""commit the specified files or all outstanding changes"""

672

if opts['text']:

672

if opts['text']:

673

ui.warn(_("Warning: -t and --text is deprecated,"

673

ui.warn(_("Warning: -t and --text is deprecated,"

674

" please use -m or --message instead.\n"))

674

" please use -m or --message instead.\n"))

675

message = opts['message'] or opts['text']

675

message = opts['message'] or opts['text']

676

logfile = opts['logfile']

676

logfile = opts['logfile']

677

678

if message and logfile:

678

if message and logfile:

679

raise util.Abort(_('options --message and --logfile are mutually '

679

raise util.Abort(_('options --message and --logfile are mutually '

680

'exclusive'))

680

'exclusive'))

681

if not message and logfile:

681

if not message and logfile:

682

try:

682

try:

683

if logfile == '-':

683

if logfile == '-':

684

message = sys.stdin.read()

684

message = sys.stdin.read()

685

else:

685

else:

686

message = open(logfile).read()

686

message = open(logfile).read()

687

except IOError, inst:

687

except IOError, inst:

688

raise util.Abort(_("can't read commit message '%s': %s") %

688

raise util.Abort(_("can't read commit message '%s': %s") %

689

(logfile, inst.strerror))

689

(logfile, inst.strerror))

690

691

if opts['addremove']:

691

if opts['addremove']:

692

addremove(ui, repo, *pats, **opts)

692

addremove(ui, repo, *pats, **opts)

693

cwd = repo.getcwd()

693

cwd = repo.getcwd()

694

if not pats and cwd:

694

if not pats and cwd:

695

opts['include'] = [os.path.join(cwd, i) for i in opts['include']]

695

opts['include'] = [os.path.join(cwd, i) for i in opts['include']]

696

opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]

696

opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]

697

fns, match, anypats = matchpats(repo, (pats and repo.getcwd()) or '',

697

fns, match, anypats = matchpats(repo, (pats and repo.getcwd()) or '',

698

pats, opts)

698

pats, opts)

699

if pats:

699

if pats:

700

c, a, d, u = repo.changes(files=fns, match=match)

700

c, a, d, u = repo.changes(files=fns, match=match)

701

files = c + a + [fn for fn in d if repo.dirstate.state(fn) == 'r']

701

files = c + a + [fn for fn in d if repo.dirstate.state(fn) == 'r']

702

else:

702

else:

703

files = []

703

files = []

704

try:

704

try:

705

repo.commit(files, message, opts['user'], opts['date'], match)

705

repo.commit(files, message, opts['user'], opts['date'], match)

706

except ValueError, inst:

706

except ValueError, inst:

707

raise util.Abort(str(inst))

707

raise util.Abort(str(inst))

708

709

def docopy(ui, repo, pats, opts):

709

def docopy(ui, repo, pats, opts):

710

if not pats:

710

if not pats:

711

raise util.Abort(_('no source or destination specified'))

711

raise util.Abort(_('no source or destination specified'))

712

elif len(pats) == 1:

712

elif len(pats) == 1:

713

raise util.Abort(_('no destination specified'))

713

raise util.Abort(_('no destination specified'))

714

pats = list(pats)

714

pats = list(pats)

715

dest = pats.pop()

715

dest = pats.pop()

716

sources = []

716

sources = []

717

718

def okaytocopy(abs, rel, exact):

718

def okaytocopy(abs, rel, exact):

719

reasons = {'?': _('is not managed'),

719

reasons = {'?': _('is not managed'),

720

'a': _('has been marked for add')}

720

'a': _('has been marked for add')}

721

reason = reasons.get(repo.dirstate.state(abs))

721

reason = reasons.get(repo.dirstate.state(abs))

722

if reason:

722

if reason:

723

if exact: ui.warn(_('%s: not copying - file %s\n') % (rel, reason))

723

if exact: ui.warn(_('%s: not copying - file %s\n') % (rel, reason))

724

else:

724

else:

725

return True

725

return True

726

727

for src, abs, rel, exact in walk(repo, pats, opts):

727

for src, abs, rel, exact in walk(repo, pats, opts):

728

if okaytocopy(abs, rel, exact):

728

if okaytocopy(abs, rel, exact):

729

sources.append((abs, rel, exact))

729

sources.append((abs, rel, exact))

730

if not sources:

730

if not sources:

731

raise util.Abort(_('no files to copy'))

731

raise util.Abort(_('no files to copy'))

732

733

cwd = repo.getcwd()

733

cwd = repo.getcwd()

734

absdest = util.canonpath(repo.root, cwd, dest)

734

absdest = util.canonpath(repo.root, cwd, dest)

735

reldest = util.pathto(cwd, absdest)

735

reldest = util.pathto(cwd, absdest)

736

if os.path.exists(reldest):

736

if os.path.exists(reldest):

737

destisfile = not os.path.isdir(reldest)

737

destisfile = not os.path.isdir(reldest)

738

else:

738

else:

739

destisfile = len(sources) == 1 or repo.dirstate.state(absdest) != '?'

739

destisfile = len(sources) == 1 or repo.dirstate.state(absdest) != '?'

740

741

if destisfile:

741

if destisfile:

742

if opts['parents']:

742

if opts['parents']:

743

raise util.Abort(_('with --parents, destination must be a directory'))

743

raise util.Abort(_('with --parents, destination must be a directory'))

744

elif len(sources) > 1:

744

elif len(sources) > 1:

745

raise util.Abort(_('with multiple sources, destination must be a '

745

raise util.Abort(_('with multiple sources, destination must be a '

746

'directory'))

746

'directory'))

747

errs, copied = 0, []

747

errs, copied = 0, []

748

for abs, rel, exact in sources:

748

for abs, rel, exact in sources:

749

if opts['parents']:

749

if opts['parents']:

750

mydest = os.path.join(dest, rel)

750

mydest = os.path.join(dest, rel)

751

elif destisfile:

751

elif destisfile:

752

mydest = reldest

752

mydest = reldest

753

else:

753

else:

754

mydest = os.path.join(dest, os.path.basename(rel))

754

mydest = os.path.join(dest, os.path.basename(rel))

755

myabsdest = util.canonpath(repo.root, cwd, mydest)

755

myabsdest = util.canonpath(repo.root, cwd, mydest)

756

myreldest = util.pathto(cwd, myabsdest)

756

myreldest = util.pathto(cwd, myabsdest)

757

if not opts['force'] and repo.dirstate.state(myabsdest) not in 'a?':

757

if not opts['force'] and repo.dirstate.state(myabsdest) not in 'a?':

758

ui.warn(_('%s: not overwriting - file already managed\n') % myreldest)

758

ui.warn(_('%s: not overwriting - file already managed\n') % myreldest)

759

continue

759

continue

760

mydestdir = os.path.dirname(myreldest) or '.'

760

mydestdir = os.path.dirname(myreldest) or '.'

761

if not opts['after']:

761

if not opts['after']:

762

try:

762

try:

763

if opts['parents']: os.makedirs(mydestdir)

763

if opts['parents']: os.makedirs(mydestdir)

764

elif not destisfile: os.mkdir(mydestdir)

764

elif not destisfile: os.mkdir(mydestdir)

765

except OSError, inst:

765

except OSError, inst:

766

if inst.errno != errno.EEXIST: raise

766

if inst.errno != errno.EEXIST: raise

767

if ui.verbose or not exact:

767

if ui.verbose or not exact:

768

ui.status(_('copying %s to %s\n') % (rel, myreldest))

768

ui.status(_('copying %s to %s\n') % (rel, myreldest))

769

if not opts['after']:

769

if not opts['after']:

770

try:

770

try:

771

shutil.copyfile(rel, myreldest)

771

shutil.copyfile(rel, myreldest)

772

shutil.copymode(rel, myreldest)

772

shutil.copymode(rel, myreldest)

773

except shutil.Error, inst:

773

except shutil.Error, inst:

774

raise util.Abort(str(inst))

774

raise util.Abort(str(inst))

775

except IOError, inst:

775

except IOError, inst:

776

if inst.errno == errno.ENOENT:

776

if inst.errno == errno.ENOENT:

777

ui.warn(_('%s: deleted in working copy\n') % rel)

777

ui.warn(_('%s: deleted in working copy\n') % rel)

778

else:

778

else:

779

ui.warn(_('%s: cannot copy - %s\n') % (rel, inst.strerror))

779

ui.warn(_('%s: cannot copy - %s\n') % (rel, inst.strerror))

780

errs += 1

780

errs += 1

781

continue

781

continue

782

repo.copy(abs, myabsdest)

782

repo.copy(abs, myabsdest)

783

copied.append((abs, rel, exact))

783

copied.append((abs, rel, exact))

784

if errs:

784

if errs:

785

ui.warn(_('(consider using --after)\n'))

785

ui.warn(_('(consider using --after)\n'))

786

return errs, copied

786

return errs, copied

787

788

def copy(ui, repo, *pats, **opts):

788

def copy(ui, repo, *pats, **opts):

789

"""mark files as copied for the next commit"""

789

"""mark files as copied for the next commit"""

790

errs, copied = docopy(ui, repo, pats, opts)

790

errs, copied = docopy(ui, repo, pats, opts)

791

return errs

791

return errs

792

793

def debugancestor(ui, index, rev1, rev2):

793

def debugancestor(ui, index, rev1, rev2):

794

"""find the ancestor revision of two revisions in a given index"""

794

"""find the ancestor revision of two revisions in a given index"""

795

r = revlog.revlog(file, index, "")

795

r = revlog.revlog(file, index, "")

796

a = r.ancestor(r.lookup(rev1), r.lookup(rev2))

796

a = r.ancestor(r.lookup(rev1), r.lookup(rev2))

797

ui.write("%d:%s\n" % (r.rev(a), hex(a)))

797

ui.write("%d:%s\n" % (r.rev(a), hex(a)))

798

799

def debugcheckstate(ui, repo):

799

def debugcheckstate(ui, repo):

800

"""validate the correctness of the current dirstate"""

800

"""validate the correctness of the current dirstate"""

801

parent1, parent2 = repo.dirstate.parents()

801

parent1, parent2 = repo.dirstate.parents()

802

repo.dirstate.read()

802

repo.dirstate.read()

803

dc = repo.dirstate.map

803

dc = repo.dirstate.map

804

keys = dc.keys()

804

keys = dc.keys()

805

keys.sort()

805

keys.sort()

806

m1n = repo.changelog.read(parent1)[0]

806

m1n = repo.changelog.read(parent1)[0]

807

m2n = repo.changelog.read(parent2)[0]

807

m2n = repo.changelog.read(parent2)[0]

808

m1 = repo.manifest.read(m1n)

808

m1 = repo.manifest.read(m1n)

809

m2 = repo.manifest.read(m2n)

809

m2 = repo.manifest.read(m2n)

810

errors = 0

810

errors = 0

811

for f in dc:

811

for f in dc:

812

state = repo.dirstate.state(f)

812

state = repo.dirstate.state(f)

813

if state in "nr" and f not in m1:

813

if state in "nr" and f not in m1:

814

ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))

814

ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))

815

errors += 1

815

errors += 1

816

if state in "a" and f in m1:

816

if state in "a" and f in m1:

817

ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))

817

ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))

818

errors += 1

818

errors += 1

819

if state in "m" and f not in m1 and f not in m2:

819

if state in "m" and f not in m1 and f not in m2:

820

ui.warn(_("%s in state %s, but not in either manifest\n") %

820

ui.warn(_("%s in state %s, but not in either manifest\n") %

821

(f, state))

821

(f, state))

822

errors += 1

822

errors += 1

823

for f in m1:

823

for f in m1:

824

state = repo.dirstate.state(f)

824

state = repo.dirstate.state(f)

825

if state not in "nrm":

825

if state not in "nrm":

826

ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))

826

ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))

827

errors += 1

827

errors += 1

828

if errors:

828

if errors:

829

raise util.Abort(_(".hg/dirstate inconsistent with current parent's manifest"))

829

raise util.Abort(_(".hg/dirstate inconsistent with current parent's manifest"))

830

831

def debugconfig(ui):

831

def debugconfig(ui):

832

"""show combined config settings from all hgrc files"""

832

"""show combined config settings from all hgrc files"""

833

try:

833

try:

834

repo = hg.repository(ui)

834

repo = hg.repository(ui)

835

except hg.RepoError:

835

except hg.RepoError:

836

pass

836

pass

837

for section, name, value in ui.walkconfig():

837

for section, name, value in ui.walkconfig():

838

ui.write('%s.%s=%s\n' % (section, name, value))

838

ui.write('%s.%s=%s\n' % (section, name, value))

839

840

def debugsetparents(ui, repo, rev1, rev2=None):

840

def debugsetparents(ui, repo, rev1, rev2=None):

841

"""

841

"""

842

manually set the parents of the current working directory

842

manually set the parents of the current working directory

843

844

This is useful for writing repository conversion tools, but should

844

This is useful for writing repository conversion tools, but should

845

be used with care.

845

be used with care.

846

"""

846

"""

847

848

if not rev2:

848

if not rev2:

849

rev2 = hex(nullid)

849

rev2 = hex(nullid)

850

851

repo.dirstate.setparents(repo.lookup(rev1), repo.lookup(rev2))

851

repo.dirstate.setparents(repo.lookup(rev1), repo.lookup(rev2))

852

853

def debugstate(ui, repo):

853

def debugstate(ui, repo):

854

"""show the contents of the current dirstate"""

854

"""show the contents of the current dirstate"""

855

repo.dirstate.read()

855

repo.dirstate.read()

856

dc = repo.dirstate.map

856

dc = repo.dirstate.map

857

keys = dc.keys()

857

keys = dc.keys()

858

keys.sort()

858

keys.sort()

859

for file_ in keys:

859

for file_ in keys:

860

ui.write("%c %3o %10d %s %s\n"

860

ui.write("%c %3o %10d %s %s\n"

861

% (dc[file_][0], dc[file_][1] & 0777, dc[file_][2],

861

% (dc[file_][0], dc[file_][1] & 0777, dc[file_][2],

862

time.strftime("%x %X",

862

time.strftime("%x %X",

863

time.localtime(dc[file_][3])), file_))

863

time.localtime(dc[file_][3])), file_))

864

for f in repo.dirstate.copies:

864

for f in repo.dirstate.copies:

865

ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copies[f], f))

865

ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copies[f], f))

866

867

def debugdata(ui, file_, rev):

867

def debugdata(ui, file_, rev):

868

"""dump the contents of an data file revision"""

868

"""dump the contents of an data file revision"""

869

r = revlog.revlog(file, file_[:-2] + ".i", file_)

869

r = revlog.revlog(file, file_[:-2] + ".i", file_)

870

try:

870

try:

871

ui.write(r.revision(r.lookup(rev)))

871

ui.write(r.revision(r.lookup(rev)))

872

except KeyError:

872

except KeyError:

873

raise util.Abort(_('invalid revision identifier %s'), rev)

873

raise util.Abort(_('invalid revision identifier %s'), rev)

874

875

def debugindex(ui, file_):

875

def debugindex(ui, file_):

876

"""dump the contents of an index file"""

876

"""dump the contents of an index file"""

877

r = revlog.revlog(file, file_, "")

877

r = revlog.revlog(file, file_, "")

878

ui.write(" rev offset length base linkrev" +

878

ui.write(" rev offset length base linkrev" +

879

" nodeid p1 p2\n")

879

" nodeid p1 p2\n")

880

for i in range(r.count()):

880

for i in range(r.count()):

881

e = r.index[i]

881

e = r.index[i]

882

ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (

882

ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (

883

i, e[0], e[1], e[2], e[3],

883

i, e[0], e[1], e[2], e[3],

884

short(e[6]), short(e[4]), short(e[5])))

884

short(e[6]), short(e[4]), short(e[5])))

885

886

def debugindexdot(ui, file_):

886

def debugindexdot(ui, file_):

887

"""dump an index DAG as a .dot file"""

887

"""dump an index DAG as a .dot file"""

888

r = revlog.revlog(file, file_, "")

888

r = revlog.revlog(file, file_, "")

889

ui.write("digraph G {\n")

889

ui.write("digraph G {\n")

890

for i in range(r.count()):

890

for i in range(r.count()):

891

e = r.index[i]

891

e = r.index[i]

892

ui.write("\t%d -> %d\n" % (r.rev(e[4]), i))

892

ui.write("\t%d -> %d\n" % (r.rev(e[4]), i))

893

if e[5] != nullid:

893

if e[5] != nullid:

894

ui.write("\t%d -> %d\n" % (r.rev(e[5]), i))

894

ui.write("\t%d -> %d\n" % (r.rev(e[5]), i))

895

ui.write("}\n")

895

ui.write("}\n")

896

897

def debugrename(ui, repo, file, rev=None):

897

def debugrename(ui, repo, file, rev=None):

898

"""dump rename information"""

898

"""dump rename information"""

899

r = repo.file(relpath(repo, [file])[0])

899

r = repo.file(relpath(repo, [file])[0])

900

if rev:

900

if rev:

901

try:

901

try:

902

# assume all revision numbers are for changesets

902

# assume all revision numbers are for changesets

903

n = repo.lookup(rev)

903

n = repo.lookup(rev)

904

change = repo.changelog.read(n)

904

change = repo.changelog.read(n)

905

m = repo.manifest.read(change[0])

905

m = repo.manifest.read(change[0])

906

n = m[relpath(repo, [file])[0]]

906

n = m[relpath(repo, [file])[0]]

907

except hg.RepoError, KeyError:

907

except hg.RepoError, KeyError:

908

n = r.lookup(rev)

908

n = r.lookup(rev)

909

else:

909

else:

910

n = r.tip()

910

n = r.tip()

911

m = r.renamed(n)

911

m = r.renamed(n)

912

if m:

912

if m:

913

ui.write(_("renamed from %s:%s\n") % (m[0], hex(m[1])))

913

ui.write(_("renamed from %s:%s\n") % (m[0], hex(m[1])))

914

else:

914

else:

915

ui.write(_("not renamed\n"))

915

ui.write(_("not renamed\n"))

916

917

def debugwalk(ui, repo, *pats, **opts):

917

def debugwalk(ui, repo, *pats, **opts):

918

"""show how files match on given patterns"""

918

"""show how files match on given patterns"""

919

items = list(walk(repo, pats, opts))

919

items = list(walk(repo, pats, opts))

920

if not items:

920

if not items:

921

return

921

return

922

fmt = '%%s %%-%ds %%-%ds %%s' % (

922

fmt = '%%s %%-%ds %%-%ds %%s' % (

923

max([len(abs) for (src, abs, rel, exact) in items]),

923

max([len(abs) for (src, abs, rel, exact) in items]),

924

max([len(rel) for (src, abs, rel, exact) in items]))

924

max([len(rel) for (src, abs, rel, exact) in items]))

925

for src, abs, rel, exact in items:

925

for src, abs, rel, exact in items:

926

line = fmt % (src, abs, rel, exact and 'exact' or '')

926

line = fmt % (src, abs, rel, exact and 'exact' or '')

927

ui.write("%s\n" % line.rstrip())

927

ui.write("%s\n" % line.rstrip())

928

929

def diff(ui, repo, *pats, **opts):

929

def diff(ui, repo, *pats, **opts):

930

"""diff working directory (or selected files)"""

930

"""diff working directory (or selected files)"""

931

node1, node2 = None, None

931

node1, node2 = None, None

932

revs = [repo.lookup(x) for x in opts['rev']]

932

revs = [repo.lookup(x) for x in opts['rev']]

933

934

if len(revs) > 0:

934

if len(revs) > 0:

935

node1 = revs[0]

935

node1 = revs[0]

936

if len(revs) > 1:

936

if len(revs) > 1:

937

node2 = revs[1]

937

node2 = revs[1]

938

if len(revs) > 2:

938

if len(revs) > 2:

939

raise util.Abort(_("too many revisions to diff"))

939

raise util.Abort(_("too many revisions to diff"))

940

941

fns, matchfn, anypats = matchpats(repo, repo.getcwd(), pats, opts)

941

fns, matchfn, anypats = matchpats(repo, repo.getcwd(), pats, opts)

942

943

dodiff(sys.stdout, ui, repo, node1, node2, fns, match=matchfn,

943

dodiff(sys.stdout, ui, repo, node1, node2, fns, match=matchfn,

944

text=opts['text'])

944

text=opts['text'])

945

946

def doexport(ui, repo, changeset, seqno, total, revwidth, opts):

946

def doexport(ui, repo, changeset, seqno, total, revwidth, opts):

947

node = repo.lookup(changeset)

947

node = repo.lookup(changeset)

948

prev, other = repo.changelog.parents(node)

948

prev, other = repo.changelog.parents(node)

949

change = repo.changelog.read(node)

949

change = repo.changelog.read(node)

950

951

fp = make_file(repo, repo.changelog, opts['output'],

951

fp = make_file(repo, repo.changelog, opts['output'],

952

node=node, total=total, seqno=seqno,

952

node=node, total=total, seqno=seqno,

953

revwidth=revwidth)

953

revwidth=revwidth)

954

if fp != sys.stdout:

954

if fp != sys.stdout:

955

ui.note("%s\n" % fp.name)

955

ui.note("%s\n" % fp.name)

956

957

fp.write("# HG changeset patch\n")

957

fp.write("# HG changeset patch\n")

958

fp.write("# User %s\n" % change[1])

958

fp.write("# User %s\n" % change[1])

959

fp.write("# Node ID %s\n" % hex(node))

959

fp.write("# Node ID %s\n" % hex(node))

960

fp.write("# Parent %s\n" % hex(prev))

960

fp.write("# Parent %s\n" % hex(prev))

961

if other != nullid:

961

if other != nullid:

962

fp.write("# Parent %s\n" % hex(other))

962

fp.write("# Parent %s\n" % hex(other))

963

fp.write(change[4].rstrip())

963

fp.write(change[4].rstrip())

964

fp.write("\n\n")

964

fp.write("\n\n")

965

966

dodiff(fp, ui, repo, prev, node, text=opts['text'])

966

dodiff(fp, ui, repo, prev, node, text=opts['text'])

967

if fp != sys.stdout:

967

if fp != sys.stdout:

968

fp.close()

968

fp.close()

969

970

def export(ui, repo, *changesets, **opts):

970

def export(ui, repo, *changesets, **opts):

971

"""dump the header and diffs for one or more changesets"""

971

"""dump the header and diffs for one or more changesets"""

972

if not changesets:

972

if not changesets:

973

raise util.Abort(_("export requires at least one changeset"))

973

raise util.Abort(_("export requires at least one changeset"))

974

seqno = 0

974

seqno = 0

975

revs = list(revrange(ui, repo, changesets))

975

revs = list(revrange(ui, repo, changesets))

976

total = len(revs)

976

total = len(revs)

977

revwidth = max(map(len, revs))

977

revwidth = max(map(len, revs))

978

ui.note(len(revs) > 1 and _("Exporting patches:\n") or _("Exporting patch:\n"))

978

ui.note(len(revs) > 1 and _("Exporting patches:\n") or _("Exporting patch:\n"))

979

for cset in revs:

979

for cset in revs:

980

seqno += 1

980

seqno += 1

981

doexport(ui, repo, cset, seqno, total, revwidth, opts)

981

doexport(ui, repo, cset, seqno, total, revwidth, opts)

982

983

def forget(ui, repo, *pats, **opts):

983

def forget(ui, repo, *pats, **opts):

984

"""don't add the specified files on the next commit"""

984

"""don't add the specified files on the next commit"""

985

forget = []

985

forget = []

986

for src, abs, rel, exact in walk(repo, pats, opts):

986

for src, abs, rel, exact in walk(repo, pats, opts):

987

if repo.dirstate.state(abs) == 'a':

987

if repo.dirstate.state(abs) == 'a':

988

forget.append(abs)

988

forget.append(abs)

989

if ui.verbose or not exact:

989

if ui.verbose or not exact:

990

ui.status(_('forgetting %s\n') % rel)

990

ui.status(_('forgetting %s\n') % rel)

991

repo.forget(forget)

991

repo.forget(forget)

992

993

def grep(ui, repo, pattern, *pats, **opts):

993

def grep(ui, repo, pattern, *pats, **opts):

994

"""search for a pattern in specified files and revisions"""

994

"""search for a pattern in specified files and revisions"""

995

reflags = 0

995

reflags = 0

996

if opts['ignore_case']:

996

if opts['ignore_case']:

997

reflags |= re.I

997

reflags |= re.I

998

regexp = re.compile(pattern, reflags)

998

regexp = re.compile(pattern, reflags)

999

sep, eol = ':', '\n'

999

sep, eol = ':', '\n'

1000

if opts['print0']:

1000

if opts['print0']:

1001

sep = eol = '\0'

1001

sep = eol = '\0'

1002

1003

fcache = {}

1003

fcache = {}

1004

def getfile(fn):

1004

def getfile(fn):

1005

if fn not in fcache:

1005

if fn not in fcache:

1006

fcache[fn] = repo.file(fn)

1006

fcache[fn] = repo.file(fn)

1007

return fcache[fn]

1007

return fcache[fn]

1008

1009

def matchlines(body):

1009

def matchlines(body):

1010

begin = 0

1010

begin = 0

1011

linenum = 0

1011

linenum = 0

1012

while True:

1012

while True:

1013

match = regexp.search(body, begin)

1013

match = regexp.search(body, begin)

1014

if not match:

1014

if not match:

1015

break

1015

break

1016

mstart, mend = match.span()

1016

mstart, mend = match.span()

1017

linenum += body.count('\n', begin, mstart) + 1

1017

linenum += body.count('\n', begin, mstart) + 1

1018

lstart = body.rfind('\n', begin, mstart) + 1 or begin

1018

lstart = body.rfind('\n', begin, mstart) + 1 or begin

1019

lend = body.find('\n', mend)

1019

lend = body.find('\n', mend)

1020

yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]

1020

yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]

1021

begin = lend + 1

1021

begin = lend + 1

1022

1023

class linestate:

1023

class linestate:

1024

def __init__(self, line, linenum, colstart, colend):

1024

def __init__(self, line, linenum, colstart, colend):

1025

self.line = line

1025

self.line = line

1026

self.linenum = linenum

1026

self.linenum = linenum

1027

self.colstart = colstart

1027

self.colstart = colstart

1028

self.colend = colend

1028

self.colend = colend

1029

def __eq__(self, other):

1029

def __eq__(self, other):

1030

return self.line == other.line

1030

return self.line == other.line

1031

def __hash__(self):

1031

def __hash__(self):

1032

return hash(self.line)

1032

return hash(self.line)

1033

1034

matches = {}

1034

matches = {}

1035

def grepbody(fn, rev, body):

1035

def grepbody(fn, rev, body):

1036

matches[rev].setdefault(fn, {})

1036

matches[rev].setdefault(fn, {})

1037

m = matches[rev][fn]

1037

m = matches[rev][fn]

1038

for lnum, cstart, cend, line in matchlines(body):

1038

for lnum, cstart, cend, line in matchlines(body):

1039

s = linestate(line, lnum, cstart, cend)

1039

s = linestate(line, lnum, cstart, cend)

1040

m[s] = s

1040

m[s] = s

1041

1042

prev = {}

1042

prev = {}

1043

ucache = {}

1043

ucache = {}

1044

def display(fn, rev, states, prevstates):

1044

def display(fn, rev, states, prevstates):

1045

diff = list(sets.Set(states).symmetric_difference(sets.Set(prevstates)))

1045

diff = list(sets.Set(states).symmetric_difference(sets.Set(prevstates)))

1046

diff.sort(lambda x, y: cmp(x.linenum, y.linenum))

1046

diff.sort(lambda x, y: cmp(x.linenum, y.linenum))

1047

counts = {'-': 0, '+': 0}

1047

counts = {'-': 0, '+': 0}

1048

filerevmatches = {}

1048

filerevmatches = {}

1049

for l in diff:

1049

for l in diff:

1050

if incrementing or not opts['all']:

1050

if incrementing or not opts['all']:

1051

change = ((l in prevstates) and '-') or '+'

1051

change = ((l in prevstates) and '-') or '+'

1052

r = rev

1052

r = rev

1053

else:

1053

else:

1054

change = ((l in states) and '-') or '+'

1054

change = ((l in states) and '-') or '+'

1055

r = prev[fn]

1055

r = prev[fn]

1056

cols = [fn, str(rev)]

1056

cols = [fn, str(rev)]

1057

if opts['line_number']: cols.append(str(l.linenum))

1057

if opts['line_number']: cols.append(str(l.linenum))

1058

if opts['all']: cols.append(change)

1058

if opts['all']: cols.append(change)

1059

if opts['user']: cols.append(trimuser(ui, getchange(rev)[1], rev,

1059

if opts['user']: cols.append(trimuser(ui, getchange(rev)[1], rev,

1060

ucache))

1060

ucache))

1061

if opts['files_with_matches']:

1061

if opts['files_with_matches']:

1062

c = (fn, rev)

1062

c = (fn, rev)

1063

if c in filerevmatches: continue

1063

if c in filerevmatches: continue

1064

filerevmatches[c] = 1

1064

filerevmatches[c] = 1

1065

else:

1065

else:

1066

cols.append(l.line)

1066

cols.append(l.line)

1067

ui.write(sep.join(cols), eol)

1067

ui.write(sep.join(cols), eol)

1068

counts[change] += 1

1068

counts[change] += 1

1069

return counts['+'], counts['-']

1069

return counts['+'], counts['-']

1070

1071

fstate = {}

1071

fstate = {}

1072

skip = {}

1072

skip = {}

1073

changeiter, getchange = walkchangerevs(ui, repo, repo.getcwd(), pats, opts)

1073

changeiter, getchange = walkchangerevs(ui, repo, repo.getcwd(), pats, opts)

1074

count = 0

1074

count = 0

1075

incrementing = False

1075

incrementing = False

1076

for st, rev, fns in changeiter:

1076

for st, rev, fns in changeiter:

1077

if st == 'window':

1077

if st == 'window':

1078

incrementing = rev

1078

incrementing = rev

1079

matches.clear()

1079

matches.clear()

1080

elif st == 'add':

1080

elif st == 'add':

1081

change = repo.changelog.read(repo.lookup(str(rev)))

1081

change = repo.changelog.read(repo.lookup(str(rev)))

1082

mf = repo.manifest.read(change[0])

1082

mf = repo.manifest.read(change[0])

1083

matches[rev] = {}

1083

matches[rev] = {}

1084

for fn in fns:

1084

for fn in fns:

1085

if fn in skip: continue

1085

if fn in skip: continue

1086

fstate.setdefault(fn, {})

1086

fstate.setdefault(fn, {})

1087

try:

1087

try:

1088

grepbody(fn, rev, getfile(fn).read(mf[fn]))

1088

grepbody(fn, rev, getfile(fn).read(mf[fn]))

1089

except KeyError:

1089

except KeyError:

1090

pass

1090

pass

1091

elif st == 'iter':

1091

elif st == 'iter':

1092

states = matches[rev].items()

1092

states = matches[rev].items()

1093

states.sort()

1093

states.sort()

1094

for fn, m in states:

1094

for fn, m in states:

1095

if fn in skip: continue

1095

if fn in skip: continue

1096

if incrementing or not opts['all'] or fstate[fn]:

1096

if incrementing or not opts['all'] or fstate[fn]:

1097

pos, neg = display(fn, rev, m, fstate[fn])

1097

pos, neg = display(fn, rev, m, fstate[fn])

1098

count += pos + neg

1098

count += pos + neg

1099

if pos and not opts['all']:

1099

if pos and not opts['all']:

1100

skip[fn] = True

1100

skip[fn] = True

1101

fstate[fn] = m

1101

fstate[fn] = m

1102

prev[fn] = rev

1102

prev[fn] = rev

1103

1104

if not incrementing:

1104

if not incrementing:

1105

fstate = fstate.items()

1105

fstate = fstate.items()

1106

fstate.sort()

1106

fstate.sort()

1107

for fn, state in fstate:

1107

for fn, state in fstate:

1108

if fn in skip: continue

1108

if fn in skip: continue

1109

display(fn, rev, {}, state)

1109

display(fn, rev, {}, state)

1110

return (count == 0 and 1) or 0

1110

return (count == 0 and 1) or 0

1111

1112

def heads(ui, repo, **opts):

1112

def heads(ui, repo, **opts):

1113

"""show current repository heads"""

1113

"""show current repository heads"""

1114

heads = repo.changelog.heads()

1114

heads = repo.changelog.heads()

1115

br = None

1115

br = None

1116

if opts['branches']:

1116

if opts['branches']:

1117

br = repo.branchlookup(heads)

1117

br = repo.branchlookup(heads)

1118

for n in repo.changelog.heads():

1118

for n in repo.changelog.heads():

1119

show_changeset(ui, repo, changenode=n, brinfo=br)

1119

show_changeset(ui, repo, changenode=n, brinfo=br)

1120

1121

def identify(ui, repo):

1121

def identify(ui, repo):

1122

"""print information about the working copy"""

1122

"""print information about the working copy"""

1123

parents = [p for p in repo.dirstate.parents() if p != nullid]

1123

parents = [p for p in repo.dirstate.parents() if p != nullid]

1124

if not parents:

1124

if not parents:

1125

ui.write(_("unknown\n"))

1125

ui.write(_("unknown\n"))

1126

return

1126

return

1127

1128

hexfunc = ui.verbose and hex or short

1128

hexfunc = ui.verbose and hex or short

1129

(c, a, d, u) = repo.changes()

1129

(c, a, d, u) = repo.changes()

1130

output = ["%s%s" % ('+'.join([hexfunc(parent) for parent in parents]),

1130

output = ["%s%s" % ('+'.join([hexfunc(parent) for parent in parents]),

1131

(c or a or d) and "+" or "")]

1131

(c or a or d) and "+" or "")]

1132

1133

if not ui.quiet:

1133

if not ui.quiet:

1134

# multiple tags for a single parent separated by '/'

1134

# multiple tags for a single parent separated by '/'

1135

parenttags = ['/'.join(tags)

1135

parenttags = ['/'.join(tags)

1136

for tags in map(repo.nodetags, parents) if tags]

1136

for tags in map(repo.nodetags, parents) if tags]

1137

# tags for multiple parents separated by ' + '

1137

# tags for multiple parents separated by ' + '

1138

if parenttags:

1138

if parenttags:

1139

output.append(' + '.join(parenttags))

1139

output.append(' + '.join(parenttags))

1140

1141

ui.write("%s\n" % ' '.join(output))

1141

ui.write("%s\n" % ' '.join(output))

1142

1143

def import_(ui, repo, patch1, *patches, **opts):

1143

def import_(ui, repo, patch1, *patches, **opts):

1144

"""import an ordered set of patches"""

1144

"""import an ordered set of patches"""

1145

patches = (patch1,) + patches

1145

patches = (patch1,) + patches

1146

1147

if not opts['force']:

1147

if not opts['force']:

1148

(c, a, d, u) = repo.changes()

1148

(c, a, d, u) = repo.changes()

1149

if c or a or d:

1149

if c or a or d:

1150

raise util.Abort(_("outstanding uncommitted changes"))

1150

raise util.Abort(_("outstanding uncommitted changes"))

1151

1152

d = opts["base"]

1152

d = opts["base"]

1153

strip = opts["strip"]

1153

strip = opts["strip"]

1154

1155

mailre = re.compile(r'(?:From |[\w-]+:)')

1155

mailre = re.compile(r'(?:From |[\w-]+:)')

1156

1157

# attempt to detect the start of a patch

1157

# attempt to detect the start of a patch

1158

# (this heuristic is borrowed from quilt)

1158

# (this heuristic is borrowed from quilt)

1159

diffre = re.compile(r'(?:Index:[ \t]|diff[ \t]|RCS file: |' +

1159

diffre = re.compile(r'(?:Index:[ \t]|diff[ \t]|RCS file: |' +

1160

'retrieving revision [0-9]+(\.[0-9]+)*$|' +

1160

'retrieving revision [0-9]+(\.[0-9]+)*$|' +

1161

'(---|\*\*\*)[ \t])')

1161

'(---|\*\*\*)[ \t])')

1162

1163

for patch in patches:

1163

for patch in patches:

1164

ui.status(_("applying %s\n") % patch)

1164

ui.status(_("applying %s\n") % patch)

1165

pf = os.path.join(d, patch)

1165

pf = os.path.join(d, patch)

1166

1167

message = []

1167

message = []

1168

user = None

1168

user = None

1169

hgpatch = False

1169

hgpatch = False

1170

for line in file(pf):

1170

for line in file(pf):

1171

line = line.rstrip()

1171

line = line.rstrip()

1172

if (not message and not hgpatch and

1172

if (not message and not hgpatch and

1173

mailre.match(line) and not opts['force']):

1173

mailre.match(line) and not opts['force']):

1174

if len(line) > 35: line = line[:32] + '...'

1174

if len(line) > 35: line = line[:32] + '...'

1175

raise util.Abort(_('first line looks like a '

1175

raise util.Abort(_('first line looks like a '

1176

'mail header: ') + line)

1176

'mail header: ') + line)

1177

if diffre.match(line):

1177

if diffre.match(line):

1178

break

1178

break

1179

elif hgpatch:

1179

elif hgpatch:

1180

# parse values when importing the result of an hg export

1180

# parse values when importing the result of an hg export

1181

if line.startswith("# User "):

1181

if line.startswith("# User "):

1182

user = line[7:]

1182

user = line[7:]

1183

ui.debug(_('User: %s\n') % user)

1183

ui.debug(_('User: %s\n') % user)

1184

elif not line.startswith("# ") and line:

1184

elif not line.startswith("# ") and line:

1185

message.append(line)

1185

message.append(line)

1186

hgpatch = False

1186

hgpatch = False

1187

elif line == '# HG changeset patch':

1187

elif line == '# HG changeset patch':

1188

hgpatch = True

1188

hgpatch = True

1189

message = [] # We may have collected garbage

1189

message = [] # We may have collected garbage

1190

else:

1190

else:

1191

message.append(line)

1191

message.append(line)

1192

1193

# make sure message isn't empty

1193

# make sure message isn't empty

1194

if not message:

1194

if not message:

1195

message = _("imported patch %s\n") % patch

1195

message = _("imported patch %s\n") % patch

1196

else:

1196

else:

1197

message = "%s\n" % '\n'.join(message)

1197

message = "%s\n" % '\n'.join(message)

1198

ui.debug(_('message:\n%s\n') % message)

1198

ui.debug(_('message:\n%s\n') % message)

1199

1200

files = util.patch(strip, pf, ui)

1200

files = util.patch(strip, pf, ui)

1201

1202

if len(files) > 0:

1202

if len(files) > 0:

1203

addremove(ui, repo, *files)

1203

addremove(ui, repo, *files)

1204

repo.commit(files, message, user)

1204

repo.commit(files, message, user)

1205

1206

def incoming(ui, repo, source="default", **opts):

1206

def incoming(ui, repo, source="default", **opts):

1207

"""show new changesets found in source"""

1207

"""show new changesets found in source"""

1208

source = ui.expandpath(source)

1208

source = ui.expandpath(source)

1209

other = hg.repository(ui, source)

1209

other = hg.repository(ui, source)

1210

if not other.local():

1210

if not other.local():

1211

raise util.Abort(_("incoming doesn't work for remote repositories yet"))

1211

raise util.Abort(_("incoming doesn't work for remote repositories yet"))

1212

o = repo.findincoming(other)

1212

o = repo.findincoming(other)

1213

if not o:

1213

if not o:

1214

return

1214

return

1215

o = other.newer(o)

1215

o = other.newer(o)

1216

for n in o:

1216

for n in o:

1217

show_changeset(ui, other, changenode=n)

1217

show_changeset(ui, other, changenode=n)

1218

if opts['patch']:

1218

if opts['patch']:

1219

prev = other.changelog.parents(n)[0]

1219

prev = other.changelog.parents(n)[0]

1220

dodiff(ui, ui, other, prev, n)

1220

dodiff(ui, ui, other, prev, n)

1221

ui.write("\n")

1221

ui.write("\n")

1222

1223

def init(ui, dest="."):

1223

def init(ui, dest="."):

1224

"""create a new repository in the given directory"""

1224

"""create a new repository in the given directory"""

1225

if not os.path.exists(dest):

1225

if not os.path.exists(dest):

1226

os.mkdir(dest)

1226

os.mkdir(dest)

1227

hg.repository(ui, dest, create=1)

1227

hg.repository(ui, dest, create=1)

1228

1229

def locate(ui, repo, *pats, **opts):

1229

def locate(ui, repo, *pats, **opts):

1230

"""locate files matching specific patterns"""

1230

"""locate files matching specific patterns"""

1231

end = opts['print0'] and '\0' or '\n'

1231

end = opts['print0'] and '\0' or '\n'

1232

1233

for src, abs, rel, exact in walk(repo, pats, opts, '(?:.*/|)'):

1233

for src, abs, rel, exact in walk(repo, pats, opts, '(?:.*/|)'):

1234

if repo.dirstate.state(abs) == '?':

1234

if repo.dirstate.state(abs) == '?':

1235

continue

1235

continue

1236

if opts['fullpath']:

1236

if opts['fullpath']:

1237

ui.write(os.path.join(repo.root, abs), end)

1237

ui.write(os.path.join(repo.root, abs), end)

1238

else:

1238

else:

1239

ui.write(rel, end)

1239

ui.write(rel, end)

1240

1241

def log(ui, repo, *pats, **opts):

1241

def log(ui, repo, *pats, **opts):

1242

"""show revision history of entire repository or files"""

1242

"""show revision history of entire repository or files"""

1243

class dui:

1243

class dui:

1244

# Implement and delegate some ui protocol. Save hunks of

1244

# Implement and delegate some ui protocol. Save hunks of

1245

# output for later display in the desired order.

1245

# output for later display in the desired order.

1246

def __init__(self, ui):

1246

def __init__(self, ui):

1247

self.ui = ui

1247

self.ui = ui

1248

self.hunk = {}

1248

self.hunk = {}

1249

def bump(self, rev):

1249

def bump(self, rev):

1250

self.rev = rev

1250

self.rev = rev

1251

self.hunk[rev] = []

1251

self.hunk[rev] = []

1252

def note(self, *args):

1252

def note(self, *args):

1253

if self.verbose:

1253

if self.verbose:

1254

self.write(*args)

1254

self.write(*args)

1255

def status(self, *args):

1255

def status(self, *args):

1256

if not self.quiet:

1256

if not self.quiet:

1257

self.write(*args)

1257

self.write(*args)

1258

def write(self, *args):

1258

def write(self, *args):

1259

self.hunk[self.rev].append(args)

1259

self.hunk[self.rev].append(args)

1260

def debug(self, *args):

1260

def debug(self, *args):

1261

if self.debugflag:

1261

if self.debugflag:

1262

self.write(*args)

1262

self.write(*args)

1263

def __getattr__(self, key):

1263

def __getattr__(self, key):

1264

return getattr(self.ui, key)

1264

return getattr(self.ui, key)

1265

cwd = repo.getcwd()

1265

cwd = repo.getcwd()

1266

if not pats and cwd:

1266

if not pats and cwd:

1267

opts['include'] = [os.path.join(cwd, i) for i in opts['include']]

1267

opts['include'] = [os.path.join(cwd, i) for i in opts['include']]

1268

opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]

1268

opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]

1269

changeiter, getchange = walkchangerevs(ui, repo, (pats and cwd) or '',

1269

changeiter, getchange = walkchangerevs(ui, repo, (pats and cwd) or '',

1270

pats, opts)

1270

pats, opts)

1271

for st, rev, fns in changeiter:

1271

for st, rev, fns in changeiter:

1272

if st == 'window':

1272

if st == 'window':

1273

du = dui(ui)

1273

du = dui(ui)

1274

elif st == 'add':

1274

elif st == 'add':

1275

du.bump(rev)

1275

du.bump(rev)

1276

br = None

1276

br = None

1277

if opts['keyword']:

1277

if opts['keyword']:

1278

changes = repo.changelog.read(repo.changelog.node(rev))

1278

changes = repo.changelog.read(repo.changelog.node(rev))

1279

miss = 0

1279

miss = 0

1280

for k in [kw.lower() for kw in opts['keyword']]:

1280

for k in [kw.lower() for kw in opts['keyword']]:

1281

if not (k in changes[1].lower() or

1281

if not (k in changes[1].lower() or

1282

k in changes[4].lower() or

1282

k in changes[4].lower() or

1283

k in " ".join(changes[3][:20]).lower()):

1283

k in " ".join(changes[3][:20]).lower()):

1284

miss = 1

1284

miss = 1

1285

break

1285

break

1286

if miss:

1286

if miss:

1287

continue

1287

continue

1288

1289

if opts['branch']:

1289

if opts['branch']:

1290

br = repo.branchlookup([repo.changelog.node(rev)])

1290

br = repo.branchlookup([repo.changelog.node(rev)])

1291

1292

show_changeset(du, repo, rev, brinfo=br)

1292

show_changeset(du, repo, rev, brinfo=br)

1293

if opts['patch']:

1293

if opts['patch']:

1294

changenode = repo.changelog.node(rev)

1294

changenode = repo.changelog.node(rev)

1295

prev, other = repo.changelog.parents(changenode)

1295

prev, other = repo.changelog.parents(changenode)

1296

dodiff(du, du, repo, prev, changenode, fns)

1296

dodiff(du, du, repo, prev, changenode, fns)

1297

du.write("\n\n")

1297

du.write("\n\n")

1298

elif st == 'iter':

1298

elif st == 'iter':

1299

for args in du.hunk[rev]:

1299

for args in du.hunk[rev]:

1300

ui.write(*args)

1300

ui.write(*args)

1301

1302

def manifest(ui, repo, rev=None):

1302

def manifest(ui, repo, rev=None):

1303

"""output the latest or given revision of the project manifest"""

1303

"""output the latest or given revision of the project manifest"""

1304

if rev:

1304

if rev:

1305

try:

1305

try:

1306

# assume all revision numbers are for changesets

1306

# assume all revision numbers are for changesets

1307

n = repo.lookup(rev)

1307

n = repo.lookup(rev)

1308

change = repo.changelog.read(n)

1308

change = repo.changelog.read(n)

1309

n = change[0]

1309

n = change[0]

1310

except hg.RepoError:

1310

except hg.RepoError:

1311

n = repo.manifest.lookup(rev)

1311

n = repo.manifest.lookup(rev)

1312

else:

1312

else:

1313

n = repo.manifest.tip()

1313

n = repo.manifest.tip()

1314

m = repo.manifest.read(n)

1314

m = repo.manifest.read(n)

1315

mf = repo.manifest.readflags(n)

1315

mf = repo.manifest.readflags(n)

1316

files = m.keys()

1316

files = m.keys()

1317

files.sort()

1317

files.sort()

1318

1319

for f in files:

1319

for f in files:

1320

ui.write("%40s %3s %s\n" % (hex(m[f]), mf[f] and "755" or "644", f))

1320

ui.write("%40s %3s %s\n" % (hex(m[f]), mf[f] and "755" or "644", f))

1321

1322

def outgoing(ui, repo, dest="default-push", **opts):

1322

def outgoing(ui, repo, dest="default-push", **opts):

1323

"""show changesets not found in destination"""

1323

"""show changesets not found in destination"""

1324

dest = ui.expandpath(dest)

1324

dest = ui.expandpath(dest)

1325

other = hg.repository(ui, dest)

1325

other = hg.repository(ui, dest)

1326

o = repo.findoutgoing(other)

1326

o = repo.findoutgoing(other)

1327

o = repo.newer(o)

1327

o = repo.newer(o)

1328

for n in o:

1328

for n in o:

1329

show_changeset(ui, repo, changenode=n)

1329

show_changeset(ui, repo, changenode=n)

1330

if opts['patch']:

1330

if opts['patch']:

1331

prev = repo.changelog.parents(n)[0]

1331

prev = repo.changelog.parents(n)[0]

1332

dodiff(ui, ui, repo, prev, n)

1332

dodiff(ui, ui, repo, prev, n)

1333

ui.write("\n")

1333

ui.write("\n")

1334

1335

def parents(ui, repo, rev=None):

1335

def parents(ui, repo, rev=None):

1336

"""show the parents of the working dir or revision"""

1336

"""show the parents of the working dir or revision"""

1337

if rev:

1337

if rev:

1338

p = repo.changelog.parents(repo.lookup(rev))

1338

p = repo.changelog.parents(repo.lookup(rev))

1339

else:

1339

else:

1340

p = repo.dirstate.parents()

1340

p = repo.dirstate.parents()

1341

1342

for n in p:

1342

for n in p:

1343

if n != nullid:

1343

if n != nullid:

1344

show_changeset(ui, repo, changenode=n)

1344

show_changeset(ui, repo, changenode=n)

1345

1346

def paths(ui, search=None):

1346

def paths(ui, search=None):

1347

"""show definition of symbolic path names"""

1347

"""show definition of symbolic path names"""

1348

try:

1348

try:

1349

repo = hg.repository(ui=ui)

1349

repo = hg.repository(ui=ui)

1350

except hg.RepoError:

1350

except hg.RepoError:

1351

pass

1351

pass

1352

1353

if search:

1353

if search:

1354

for name, path in ui.configitems("paths"):

1354

for name, path in ui.configitems("paths"):

1355

if name == search:

1355

if name == search:

1356

ui.write("%s\n" % path)

1356

ui.write("%s\n" % path)

1357

return

1357

return

1358

ui.warn(_("not found!\n"))

1358

ui.warn(_("not found!\n"))

1359

return 1

1359

return 1

1360

else:

1360

else:

1361

for name, path in ui.configitems("paths"):

1361

for name, path in ui.configitems("paths"):

1362

ui.write("%s = %s\n" % (name, path))

1362

ui.write("%s = %s\n" % (name, path))

1363

1364

def pull(ui, repo, source="default", **opts):

1364

def pull(ui, repo, source="default", **opts):

1365

"""pull changes from the specified source"""

1365

"""pull changes from the specified source"""

1366

source = ui.expandpath(source)

1366

source = ui.expandpath(source)

1367

ui.status(_('pulling from %s\n') % (source))

1367

ui.status(_('pulling from %s\n') % (source))

1368

1369

if opts['ssh']:

1369

if opts['ssh']:

1370

ui.setconfig("ui", "ssh", opts['ssh'])

1370

ui.setconfig("ui", "ssh", opts['ssh'])

1371

if opts['remotecmd']:

1371

if opts['remotecmd']:

1372

ui.setconfig("ui", "remotecmd", opts['remotecmd'])

1372

ui.setconfig("ui", "remotecmd", opts['remotecmd'])

1373

1374

other = hg.repository(ui, source)

1374

other = hg.repository(ui, source)

1375

r = repo.pull(other)

1375

r = repo.pull(other)

1376

if not r:

1376

if not r:

1377

if opts['update']:

1377

if opts['update']:

1378

return update(ui, repo)

1378

return update(ui, repo)

1379

else:

1379

else:

1380

ui.status(_("(run 'hg update' to get a working copy)\n"))

1380

ui.status(_("(run 'hg update' to get a working copy)\n"))

1381

1382

return r

1382

return r

1383

1384

def push(ui, repo, dest="default-push", force=False, ssh=None, remotecmd=None):

1384

def push(ui, repo, dest="default-push", force=False, ssh=None, remotecmd=None):

1385

"""push changes to the specified destination"""

1385

"""push changes to the specified destination"""

1386

dest = ui.expandpath(dest)

1386

dest = ui.expandpath(dest)

1387

ui.status('pushing to %s\n' % (dest))

1387

ui.status('pushing to %s\n' % (dest))

1388

1389

if ssh:

1389

if ssh:

1390

ui.setconfig("ui", "ssh", ssh)

1390

ui.setconfig("ui", "ssh", ssh)

1391

if remotecmd:

1391

if remotecmd:

1392

ui.setconfig("ui", "remotecmd", remotecmd)

1392

ui.setconfig("ui", "remotecmd", remotecmd)

1393

1394

other = hg.repository(ui, dest)

1394

other = hg.repository(ui, dest)

1395

r = repo.push(other, force)

1395

r = repo.push(other, force)

1396

return r

1396

return r

1397

1398

def rawcommit(ui, repo, *flist, **rc):

1398

def rawcommit(ui, repo, *flist, **rc):

1399

"raw commit interface"

1399

"raw commit interface"

1400

if rc['text']:

1400

if rc['text']:

1401

ui.warn(_("Warning: -t and --text is deprecated,"

1401

ui.warn(_("Warning: -t and --text is deprecated,"

1402

" please use -m or --message instead.\n"))

1402

" please use -m or --message instead.\n"))

1403

message = rc['message'] or rc['text']

1403

message = rc['message'] or rc['text']

1404

if not message and rc['logfile']:

1404

if not message and rc['logfile']:

1405

try:

1405

try:

1406

message = open(rc['logfile']).read()

1406

message = open(rc['logfile']).read()

1407

except IOError:

1407

except IOError:

1408

pass

1408

pass

1409

if not message and not rc['logfile']:

1409

if not message and not rc['logfile']:

1410

raise util.Abort(_("missing commit message"))

1410

raise util.Abort(_("missing commit message"))

1411

1412

files = relpath(repo, list(flist))

1412

files = relpath(repo, list(flist))

1413

if rc['files']:

1413

if rc['files']:

1414

files += open(rc['files']).read().splitlines()

1414

files += open(rc['files']).read().splitlines()

1415

1416

rc['parent'] = map(repo.lookup, rc['parent'])

1416

rc['parent'] = map(repo.lookup, rc['parent'])

1417

1418

try:

1418

try:

1419

repo.rawcommit(files, message, rc['user'], rc['date'], *rc['parent'])

1419

repo.rawcommit(files, message, rc['user'], rc['date'], *rc['parent'])

1420

except ValueError, inst:

1420

except ValueError, inst:

1421

raise util.Abort(str(inst))

1421

raise util.Abort(str(inst))

1422

1423

def recover(ui, repo):

1423

def recover(ui, repo):

1424

"""roll back an interrupted transaction"""

1424

"""roll back an interrupted transaction"""

1425

repo.recover()

1425

repo.recover()

1426

1427

def remove(ui, repo, pat, *pats, **opts):

1427

def remove(ui, repo, pat, *pats, **opts):

1428

"""remove the specified files on the next commit"""

1428

"""remove the specified files on the next commit"""

1429

names = []

1429

names = []

1430

def okaytoremove(abs, rel, exact):

1430

def okaytoremove(abs, rel, exact):

1431

c, a, d, u = repo.changes(files = [abs])

1431

c, a, d, u = repo.changes(files = [abs])

1432

reason = None

1432

reason = None

1433

if c: reason = _('is modified')

1433

if c: reason = _('is modified')

1434

elif a: reason = _('has been marked for add')

1434

elif a: reason = _('has been marked for add')

1435

elif u: reason = _('is not managed')

1435

elif u: reason = _('is not managed')

1436

if reason:

1436

if reason:

1437

if exact: ui.warn(_('not removing %s: file %s\n') % (rel, reason))

1437

if exact: ui.warn(_('not removing %s: file %s\n') % (rel, reason))

1438

else:

1438

else:

1439

return True

1439

return True

1440

for src, abs, rel, exact in walk(repo, (pat,) + pats, opts):

1440

for src, abs, rel, exact in walk(repo, (pat,) + pats, opts):

1441

if okaytoremove(abs, rel, exact):

1441

if okaytoremove(abs, rel, exact):

1442

if ui.verbose or not exact: ui.status(_('removing %s\n') % rel)

1442

if ui.verbose or not exact: ui.status(_('removing %s\n') % rel)

1443

names.append(abs)

1443

names.append(abs)

1444

for name in names:

1444

for name in names:

1445

try:

1445

try:

1446

os.unlink(name)

1446

os.unlink(name)

1447

except OSError, inst:

1447

except OSError, inst:

1448

if inst.errno != errno.ENOENT: raise

1448

if inst.errno != errno.ENOENT: raise

1449

repo.remove(names)

1449

repo.remove(names)

1450

1451

def rename(ui, repo, *pats, **opts):

1451

def rename(ui, repo, *pats, **opts):

1452

"""rename files; equivalent of copy + remove"""

1452

"""rename files; equivalent of copy + remove"""

1453

errs, copied = docopy(ui, repo, pats, opts)

1453

errs, copied = docopy(ui, repo, pats, opts)

1454

names = []

1454

names = []

1455

for abs, rel, exact in copied:

1455

for abs, rel, exact in copied:

1456

if ui.verbose or not exact: ui.status(_('removing %s\n') % rel)

1456

if ui.verbose or not exact: ui.status(_('removing %s\n') % rel)

1457

try:

1457

try:

1458

os.unlink(rel)

1458

os.unlink(rel)

1459

except OSError, inst:

1459

except OSError, inst:

1460

if inst.errno != errno.ENOENT: raise

1460

if inst.errno != errno.ENOENT: raise

1461

names.append(abs)

1461

names.append(abs)

1462

repo.remove(names)

1462

repo.remove(names)

1463

return errs

1463

return errs

1464

1465

def revert(ui, repo, *names, **opts):

1465

def revert(ui, repo, *names, **opts):

1466

"""revert modified files or dirs back to their unmodified states"""

1466

"""revert modified files or dirs back to their unmodified states"""

1467

node = opts['rev'] and repo.lookup(opts['rev']) or \

1467

node = opts['rev'] and repo.lookup(opts['rev']) or \

1468

repo.dirstate.parents()[0]

1468

repo.dirstate.parents()[0]

1469

root = os.path.realpath(repo.root)

1469

root = os.path.realpath(repo.root)

1470

1471

def trimpath(p):

1471

def trimpath(p):

1472

p = os.path.realpath(p)

1472

p = os.path.realpath(p)

1473

if p.startswith(root):

1473

if p.startswith(root):

1474

rest = p[len(root):]

1474

rest = p[len(root):]

1475

if not rest:

1475

if not rest:

1476

return rest

1476

return rest

1477

if p.startswith(os.sep):

1477

if p.startswith(os.sep):

1478

return rest[1:]

1478

return rest[1:]

1479

return p

1479

return p

1480

1481

relnames = map(trimpath, names or [os.getcwd()])

1481

relnames = map(trimpath, names or [os.getcwd()])

1482

chosen = {}

1482

chosen = {}

1483

1484

def choose(name):

1484

def choose(name):

1485

def body(name):

1485

def body(name):

1486

for r in relnames:

1486

for r in relnames:

1487

if not name.startswith(r):

1487

if not name.startswith(r):

1488

continue

1488

continue

1489

rest = name[len(r):]

1489

rest = name[len(r):]

1490

if not rest:

1490

if not rest:

1491

return r, True

1491

return r, True

1492

depth = rest.count(os.sep)

1492

depth = rest.count(os.sep)

1493

if not r:

1493

if not r:

1494

if depth == 0 or not opts['nonrecursive']:

1494

if depth == 0 or not opts['nonrecursive']:

1495

return r, True

1495

return r, True

1496

elif rest[0] == os.sep:

1496

elif rest[0] == os.sep:

1497

if depth == 1 or not opts['nonrecursive']:

1497

if depth == 1 or not opts['nonrecursive']:

1498

return r, True

1498

return r, True

1499

return None, False

1499

return None, False

1500

relname, ret = body(name)

1500

relname, ret = body(name)

1501

if ret:

1501

if ret:

1502

chosen[relname] = 1

1502

chosen[relname] = 1

1503

return ret

1503

return ret

1504

1505

r = repo.update(node, False, True, choose, False)

1505

r = repo.update(node, False, True, choose, False)

1506

for n in relnames:

1506

for n in relnames:

1507

if n not in chosen:

1507

if n not in chosen:

1508

ui.warn(_('error: no matches for %s\n') % n)

1508

ui.warn(_('error: no matches for %s\n') % n)

1509

r = 1

1509

r = 1

1510

sys.stdout.flush()

1510

sys.stdout.flush()

1511

return r

1511

return r

1512

1513

def root(ui, repo):

1513

def root(ui, repo):

1514

"""print the root (top) of the current working dir"""

1514

"""print the root (top) of the current working dir"""

1515

ui.write(repo.root + "\n")

1515

ui.write(repo.root + "\n")

1516

1517

def serve(ui, repo, **opts):

1517

def serve(ui, repo, **opts):

1518

"""export the repository via HTTP"""

1518

"""export the repository via HTTP"""

1519

1520

if opts["stdio"]:

1520

if opts["stdio"]:

1521

fin, fout = sys.stdin, sys.stdout

1521

fin, fout = sys.stdin, sys.stdout

1522

sys.stdout = sys.stderr

1522

sys.stdout = sys.stderr

1523

1524

def getarg():

1524

def getarg():

1525

argline = fin.readline()[:-1]

1525

argline = fin.readline()[:-1]

1526

arg, l = argline.split()

1526

arg, l = argline.split()

1527

val = fin.read(int(l))

1527

val = fin.read(int(l))

1528

return arg, val

1528

return arg, val

1529

def respond(v):

1529

def respond(v):

1530

fout.write("%d\n" % len(v))

1530

fout.write("%d\n" % len(v))

1531

fout.write(v)

1531

fout.write(v)

1532

fout.flush()

1532

fout.flush()

1533

1534

lock = None

1534

lock = None

1535

1536

while 1:

1536

while 1:

1537

cmd = fin.readline()[:-1]

1537

cmd = fin.readline()[:-1]

1538

if cmd == '':

1538

if cmd == '':

1539

return

1539

return

1540

if cmd == "heads":

1540

if cmd == "heads":

1541

h = repo.heads()

1541

h = repo.heads()

1542

respond(" ".join(map(hex, h)) + "\n")

1542

respond(" ".join(map(hex, h)) + "\n")

1543

if cmd == "lock":

1543

if cmd == "lock":

1544

lock = repo.lock()

1544

lock = repo.lock()

1545

respond("")

1545

respond("")

1546

if cmd == "unlock":

1546

if cmd == "unlock":

1547

if lock:

1547

if lock:

1548

lock.release()

1548

lock.release()

1549

lock = None

1549

lock = None

1550

respond("")

1550

respond("")

1551

elif cmd == "branches":

1551

elif cmd == "branches":

1552

arg, nodes = getarg()

1552

arg, nodes = getarg()

1553

nodes = map(bin, nodes.split(" "))

1553

nodes = map(bin, nodes.split(" "))

1554

r = []

1554

r = []

1555

for b in repo.branches(nodes):

1555

for b in repo.branches(nodes):

1556

r.append(" ".join(map(hex, b)) + "\n")

1556

r.append(" ".join(map(hex, b)) + "\n")

1557

respond("".join(r))

1557

respond("".join(r))

1558

elif cmd == "between":

1558

elif cmd == "between":

1559

arg, pairs = getarg()

1559

arg, pairs = getarg()

1560

pairs = [map(bin, p.split("-")) for p in pairs.split(" ")]

1560

pairs = [map(bin, p.split("-")) for p in pairs.split(" ")]

1561

r = []

1561

r = []

1562

for b in repo.between(pairs):

1562

for b in repo.between(pairs):

1563

r.append(" ".join(map(hex, b)) + "\n")

1563

r.append(" ".join(map(hex, b)) + "\n")

1564

respond("".join(r))

1564

respond("".join(r))

1565

elif cmd == "changegroup":

1565

elif cmd == "changegroup":

1566

nodes = []

1566

nodes = []

1567

arg, roots = getarg()

1567

arg, roots = getarg()

1568

nodes = map(bin, roots.split(" "))

1568

nodes = map(bin, roots.split(" "))

1569

1570

cg = repo.changegroup(nodes)

1570

cg = repo.changegroup(nodes)

1571

while 1:

1571

while 1:

1572

d = cg.read(4096)

1572

d = cg.read(4096)

1573

if not d:

1573

if not d:

1574

break

1574

break

1575

fout.write(d)

1575

fout.write(d)

1576

1577

fout.flush()

1577

fout.flush()

1578

1579

elif cmd == "addchangegroup":

1579

elif cmd == "addchangegroup":

1580

if not lock:

1580

if not lock:

1581

respond("not locked")

1581

respond("not locked")

1582

continue

1582

continue

1583

respond("")

1583

respond("")

1584

1585

r = repo.addchangegroup(fin)

1585

r = repo.addchangegroup(fin)

1586

respond("")

1586

respond("")

1587

1588

optlist = "name templates style address port ipv6 accesslog errorlog"

1588

optlist = "name templates style address port ipv6 accesslog errorlog"

1589

for o in optlist.split():

1589

for o in optlist.split():

1590

if opts[o]:

1590

if opts[o]:

1591

ui.setconfig("web", o, opts[o])

1591

ui.setconfig("web", o, opts[o])

1592

1593

try:

1593

try:

1594

httpd = hgweb.create_server(repo)

1594

httpd = hgweb.create_server(repo)

1595

except socket.error, inst:

1595

except socket.error, inst:

1596

raise util.Abort('cannot start server: ' + inst.args[1])

1596

raise util.Abort('cannot start server: ' + inst.args[1])

1597

1598

if ui.verbose:

1598

if ui.verbose:

1599

addr, port = httpd.socket.getsockname()

1599

addr, port = httpd.socket.getsockname()

1600

if addr == '0.0.0.0':

1600

if addr == '0.0.0.0':

1601

addr = socket.gethostname()

1601

addr = socket.gethostname()

1602

else:

1602

else:

1603

try:

1603

try:

1604

addr = socket.gethostbyaddr(addr)[0]

1604

addr = socket.gethostbyaddr(addr)[0]

1605

except socket.error:

1605

except socket.error:

1606

pass

1606

pass

1607

if port != 80:

1607

if port != 80:

1608

ui.status(_('listening at http://%s:%d/\n') % (addr, port))

1608

ui.status(_('listening at http://%s:%d/\n') % (addr, port))

1609

else:

1609

else:

1610

ui.status(_('listening at http://%s/\n') % addr)

1610

ui.status(_('listening at http://%s/\n') % addr)

1611

httpd.serve_forever()

1611

httpd.serve_forever()

1612

1613

def status(ui, repo, *pats, **opts):

1613

def status(ui, repo, *pats, **opts):

1614

'''show changed files in the working directory

1614

'''show changed files in the working directory

1615

1616

M = modified

1616

M = modified

1617

A = added

1617

A = added

1618

R = removed

1618

R = removed

1619

? = not tracked

1619

? = not tracked

1620

'''

1620

'''

1621

1622

cwd = repo.getcwd()

1622

cwd = repo.getcwd()

1623

files, matchfn, anypats = matchpats(repo, cwd, pats, opts)

1623

files, matchfn, anypats = matchpats(repo, cwd, pats, opts)

1624

(c, a, d, u) = [[util.pathto(cwd, x) for x in n]

1624

(c, a, d, u) = [[util.pathto(cwd, x) for x in n]

1625

for n in repo.changes(files=files, match=matchfn)]

1625

for n in repo.changes(files=files, match=matchfn)]

1626

1627

changetypes = [(_('modified'), 'M', c),

1627

changetypes = [(_('modified'), 'M', c),

1628

(_('added'), 'A', a),

1628

(_('added'), 'A', a),

1629

(_('removed'), 'R', d),

1629

(_('removed'), 'R', d),

1630

(_('unknown'), '?', u)]

1630

(_('unknown'), '?', u)]

1631

1632

end = opts['print0'] and '\0' or '\n'

1632

end = opts['print0'] and '\0' or '\n'

1633

1634

for opt, char, changes in ([ct for ct in changetypes if opts[ct[0]]]

1634

for opt, char, changes in ([ct for ct in changetypes if opts[ct[0]]]

1635

or changetypes):

1635

or changetypes):

1636

if opts['no_status']:

1636

if opts['no_status']:

1637

format = "%%s%s" % end

1637

format = "%%s%s" % end

1638

else:

1638

else:

1639

format = "%s %%s%s" % (char, end);

1639

format = "%s %%s%s" % (char, end);

1640

1641

for f in changes:

1641

for f in changes:

1642

ui.write(format % f)

1642

ui.write(format % f)

1643

1644

def tag(ui, repo, name, rev=None, **opts):

1644

def tag(ui, repo, name, rev=None, **opts):

1645

"""add a tag for the current tip or a given revision"""

1645

"""add a tag for the current tip or a given revision"""

1646

if opts['text']:

1646

if opts['text']:

1647

ui.warn(_("Warning: -t and --text is deprecated,"

1647

ui.warn(_("Warning: -t and --text is deprecated,"

1648

" please use -m or --message instead.\n"))

1648

" please use -m or --message instead.\n"))

1649

if name == "tip":

1649

if name == "tip":

1650

raise util.Abort(_("the name 'tip' is reserved"))

1650

raise util.Abort(_("the name 'tip' is reserved"))

1651

if rev:

1651

if rev:

1652

r = hex(repo.lookup(rev))

1652

r = hex(repo.lookup(rev))

1653

else:

1653

else:

1654

r = hex(repo.changelog.tip())

1654

r = hex(repo.changelog.tip())

1655

1656

if name.find(revrangesep) >= 0:

1656

if name.find(revrangesep) >= 0:

1657

raise util.Abort(_("'%s' cannot be used in a tag name") % revrangesep)

1657

raise util.Abort(_("'%s' cannot be used in a tag name") % revrangesep)

1658

1659

if opts['local']:

1659

if opts['local']:

1660

repo.opener("localtags", "a").write("%s %s\n" % (r, name))

1660

repo.opener("localtags", "a").write("%s %s\n" % (r, name))

1661

return

1661

return

1662

1663

(c, a, d, u) = repo.changes()

1663

(c, a, d, u) = repo.changes()

1664

for x in (c, a, d, u):

1664

for x in (c, a, d, u):

1665

if ".hgtags" in x:

1665

if ".hgtags" in x:

1666

raise util.Abort(_("working copy of .hgtags is changed "

1666

raise util.Abort(_("working copy of .hgtags is changed "

1667

"(please commit .hgtags manually)"))

1667

"(please commit .hgtags manually)"))

1668

1669

repo.wfile(".hgtags", "ab").write("%s %s\n" % (r, name))

1669

repo.wfile(".hgtags", "ab").write("%s %s\n" % (r, name))

1670

if repo.dirstate.state(".hgtags") == '?':

1670

if repo.dirstate.state(".hgtags") == '?':

1671

repo.add([".hgtags"])

1671

repo.add([".hgtags"])

1672

1673

message = (opts['message'] or opts['text'] or

1673

message = (opts['message'] or opts['text'] or

1674

_("Added tag %s for changeset %s") % (name, r))

1674

_("Added tag %s for changeset %s") % (name, r))

1675

try:

1675

try:

1676

repo.commit([".hgtags"], message, opts['user'], opts['date'])

1676

repo.commit([".hgtags"], message, opts['user'], opts['date'])

1677

except ValueError, inst:

1677

except ValueError, inst:

1678

raise util.Abort(str(inst))

1678

raise util.Abort(str(inst))

1679

1680

def tags(ui, repo):

1680

def tags(ui, repo):

1681

"""list repository tags"""

1681

"""list repository tags"""

1682

1683

l = repo.tagslist()

1683

l = repo.tagslist()

1684

l.reverse()

1684

l.reverse()

1685

for t, n in l:

1685

for t, n in l:

1686

try:

1686

try:

1687

r = "%5d:%s" % (repo.changelog.rev(n), hex(n))

1687

r = "%5d:%s" % (repo.changelog.rev(n), hex(n))

1688

except KeyError:

1688

except KeyError:

1689

r = " ?:?"

1689

r = " ?:?"

1690

ui.write("%-30s %s\n" % (t, r))

1690

ui.write("%-30s %s\n" % (t, r))

1691

1692

def tip(ui, repo):

1692

def tip(ui, repo):

1693

"""show the tip revision"""

1693

"""show the tip revision"""

1694

n = repo.changelog.tip()

1694

n = repo.changelog.tip()

1695

show_changeset(ui, repo, changenode=n)

1695

show_changeset(ui, repo, changenode=n)

1696

1697

def unbundle(ui, repo, fname):

1697

def unbundle(ui, repo, fname):

1698

"""apply a changegroup file"""

1698

"""apply a changegroup file"""

1699

f = urllib.urlopen(fname)

1699

f = urllib.urlopen(fname)

1700

1701

if f.read(4) != "HG10":

1701

if f.read(4) != "HG10":

1702

raise util.Abort(_("%s: not a Mercurial bundle file") % fname)

1702

raise util.Abort(_("%s: not a Mercurial bundle file") % fname)

1703

1704

def bzgenerator(f):

1704

def bzgenerator(f):

1705

zd = bz2.BZ2Decompressor()

1705

zd = bz2.BZ2Decompressor()

1706

for chunk in f:

1706

for chunk in f:

1707

yield zd.decompress(chunk)

1707

yield zd.decompress(chunk)

1708

yield zd.flush()

1708

yield zd.flush()

1709

1710

bzgen = bzgenerator(util.filechunkiter(f, 4096))

1710

bzgen = bzgenerator(util.filechunkiter(f, 4096))

1711

repo.addchangegroup(util.chunkbuffer(bzgen))

1711

repo.addchangegroup(util.chunkbuffer(bzgen))

1712

1713

def undo(ui, repo):

1713

def undo(ui, repo):

1714

"""undo the last commit or pull

1714

"""undo the last commit or pull

1715

1716

Roll back the last pull or commit transaction on the

1716

Roll back the last pull or commit transaction on the

1717

repository, restoring the project to its earlier state.

1717

repository, restoring the project to its earlier state.

1718

1719

This command should be used with care. There is only one level of

1719

This command should be used with care. There is only one level of

1720

undo and there is no redo.

1720

undo and there is no redo.

1721

1722

This command is not intended for use on public repositories. Once

1722

This command is not intended for use on public repositories. Once

1723

a change is visible for pull by other users, undoing it locally is

1723

a change is visible for pull by other users, undoing it locally is

1724

ineffective.

1724

ineffective.

1725

"""

1725

"""

1726

repo.undo()

1726

repo.undo()

1727

1728

def update(ui, repo, node=None, merge=False, clean=False, branch=None):

1728

def update(ui, repo, node=None, merge=False, clean=False, branch=None):

1729

'''update or merge working directory

1729

'''update or merge working directory

1730

1731

If there are no outstanding changes in the working directory and

1731

If there are no outstanding changes in the working directory and

1732

there is a linear relationship between the current version and the

1732

there is a linear relationship between the current version and the

1733

requested version, the result is the requested version.

1733

requested version, the result is the requested version.

1734

1735

Otherwise the result is a merge between the contents of the

1735

Otherwise the result is a merge between the contents of the

1736

current working directory and the requested version. Files that

1736

current working directory and the requested version. Files that

1737

changed between either parent are marked as changed for the next

1737

changed between either parent are marked as changed for the next

1738

commit and a commit must be performed before any further updates

1738

commit and a commit must be performed before any further updates

1739

are allowed.

1739

are allowed.

1740

'''

1740

'''

1741

if branch:

1741

if branch:

1742

br = repo.branchlookup(branch=branch)

1742

br = repo.branchlookup(branch=branch)

1743

found = []

1743

found = []

1744

for x in br:

1744

for x in br:

1745

if branch in br[x]:

1745

if branch in br[x]:

1746

found.append(x)

1746

found.append(x)

1747

if len(found) > 1:

1747

if len(found) > 1:

1748

ui.warn(_("Found multiple heads for %s\n") % branch)

1748

ui.warn(_("Found multiple heads for %s\n") % branch)

1749

for x in found:

1749

for x in found:

1750

show_changeset(ui, repo, changenode=x, brinfo=br)

1750

show_changeset(ui, repo, changenode=x, brinfo=br)

1751

return 1

1751

return 1

1752

if len(found) == 1:

1752

if len(found) == 1:

1753

node = found[0]

1753

node = found[0]

1754

ui.warn(_("Using head %s for branch %s\n") % (short(node), branch))

1754

ui.warn(_("Using head %s for branch %s\n") % (short(node), branch))

1755

else:

1755

else:

1756

ui.warn(_("branch %s not found\n") % (branch))

1756

ui.warn(_("branch %s not found\n") % (branch))

1757

return 1

1757

return 1

1758

else:

1758

else:

1759

node = node and repo.lookup(node) or repo.changelog.tip()

1759

node = node and repo.lookup(node) or repo.changelog.tip()

1760

return repo.update(node, allow=merge, force=clean)

1760

return repo.update(node, allow=merge, force=clean)

1761

1762

def verify(ui, repo):

1762

def verify(ui, repo):

1763

"""verify the integrity of the repository"""

1763

"""verify the integrity of the repository"""

1764

return repo.verify()

1764

return repo.verify()

1765

1766

# Command options and aliases are listed here, alphabetically

1766

# Command options and aliases are listed here, alphabetically

1767

1768

table = {

1768

table = {

1769

"^add":

1769

"^add":

1770

(add,

1770

(add,

1771

[('I', 'include', [], _('include path in search')),

1771

[('I', 'include', [], _('include path in search')),

1772

('X', 'exclude', [], _('exclude path from search'))],

1772

('X', 'exclude', [], _('exclude path from search'))],

1773

"hg add [OPTION]... [FILE]..."),

1773

"hg add [OPTION]... [FILE]..."),

1774

"addremove":

1774

"addremove":

1775

(addremove,

1775

(addremove,

1776

[('I', 'include', [], _('include path in search')),

1776

[('I', 'include', [], _('include path in search')),

1777

('X', 'exclude', [], _('exclude path from search'))],

1777

('X', 'exclude', [], _('exclude path from search'))],

1778

_("hg addremove [OPTION]... [FILE]...")),

1778

_("hg addremove [OPTION]... [FILE]...")),

1779

"^annotate":

1779

"^annotate":

1780

(annotate,

1780

(annotate,

1781

[('r', 'rev', '', _('revision')),

1781

[('r', 'rev', '', _('revision')),

1782

('a', 'text', None, _('treat all files as text')),

1782

('a', 'text', None, _('treat all files as text')),

1783

('u', 'user', None, _('show user')),

1783

('u', 'user', None, _('show user')),

1784

('n', 'number', None, _('show revision number')),

1784

('n', 'number', None, _('show revision number')),

1785

('c', 'changeset', None, _('show changeset')),

1785

('c', 'changeset', None, _('show changeset')),

1786

('I', 'include', [], _('include path in search')),

1786

('I', 'include', [], _('include path in search')),

1787

('X', 'exclude', [], _('exclude path from search'))],

1787

('X', 'exclude', [], _('exclude path from search'))],

1788

_('hg annotate [OPTION]... FILE...')),

1788

_('hg annotate [OPTION]... FILE...')),

1789

"bundle":

1789

"bundle":

1790

(bundle,

1790

(bundle,

1791

[],

1791

[],

1792

_('hg bundle FILE DEST')),

1792

_('hg bundle FILE DEST')),

1793

"cat":

1793

"cat":

1794

(cat,

1794

(cat,

1795

[('I', 'include', [], _('include path in search')),

1795

[('I', 'include', [], _('include path in search')),

1796

('X', 'exclude', [], _('exclude path from search')),

1796

('X', 'exclude', [], _('exclude path from search')),

1797

('o', 'output', "", _('output to file')),

1797

('o', 'output', "", _('output to file')),

1798

('r', 'rev', '', _('revision'))],

1798

('r', 'rev', '', _('revision'))],

1799

_('hg cat [OPTION]... FILE...')),

1799

_('hg cat [OPTION]... FILE...')),

1800

"^clone":

1800

"^clone":

1801

(clone,

1801

(clone,

1802

[('U', 'noupdate', None, _('skip update after cloning')),

1802

[('U', 'noupdate', None, _('skip update after cloning')),

1803

('e', 'ssh', "", _('ssh command')),

1803

('e', 'ssh', "", _('ssh command')),

1804

('', 'pull', None, _('use pull protocol to copy metadata')),

1804

('', 'pull', None, _('use pull protocol to copy metadata')),

1805

('', 'remotecmd', "", _('remote hg command'))],

1805

('', 'remotecmd', "", _('remote hg command'))],

1806

_('hg clone [OPTION]... SOURCE [DEST]')),

1806

_('hg clone [OPTION]... SOURCE [DEST]')),

1807

"^commit|ci":

1807

"^commit|ci":

1808

(commit,

1808

(commit,

1809

[('A', 'addremove', None, _('run add/remove during commit')),

1809

[('A', 'addremove', None, _('run add/remove during commit')),

1810

('I', 'include', [], _('include path in search')),

1810

('I', 'include', [], _('include path in search')),

1811

('X', 'exclude', [], _('exclude path from search')),

1811

('X', 'exclude', [], _('exclude path from search')),

1812

('m', 'message', "", _('commit message')),

1812

('m', 'message', "", _('commit message')),

1813

('t', 'text', "", _('commit message (deprecated: use -m)')),

1813

('t', 'text', "", _('commit message (deprecated: use -m)')),

1814

('l', 'logfile', "", _('commit message file')),

1814

('l', 'logfile', "", _('commit message file')),

1815

('d', 'date', "", _('date code')),

1815

('d', 'date', "", _('date code')),

1816

('u', 'user', "", _('user'))],

1816

('u', 'user', "", _('user'))],

1817

_('hg commit [OPTION]... [FILE]...')),

1817

_('hg commit [OPTION]... [FILE]...')),

1818

"copy|cp": (copy,

1818

"copy|cp": (copy,

1819

[('I', 'include', [], _('include path in search')),

1819

[('I', 'include', [], _('include path in search')),

1820

('X', 'exclude', [], _('exclude path from search')),

1820

('X', 'exclude', [], _('exclude path from search')),

1821

('A', 'after', None, _('record a copy after it has happened')),

1821

('A', 'after', None, _('record a copy after it has happened')),

1822

('f', 'force', None, _('replace destination if it exists')),

1822

('f', 'force', None, _('replace destination if it exists')),

1823

('p', 'parents', None, _('append source path to dest'))],

1823

('p', 'parents', None, _('append source path to dest'))],

1824

_('hg copy [OPTION]... [SOURCE]... DEST')),

1824

_('hg copy [OPTION]... [SOURCE]... DEST')),

1825

"debugancestor": (debugancestor, [], _('debugancestor INDEX REV1 REV2')),

1825

"debugancestor": (debugancestor, [], _('debugancestor INDEX REV1 REV2')),

1826

"debugcheckstate": (debugcheckstate, [], _('debugcheckstate')),

1826

"debugcheckstate": (debugcheckstate, [], _('debugcheckstate')),

1827

"debugconfig": (debugconfig, [], _('debugconfig')),

1827

"debugconfig": (debugconfig, [], _('debugconfig')),

1828

"debugsetparents": (debugsetparents, [], _('debugsetparents REV1 [REV2]')),

1828

"debugsetparents": (debugsetparents, [], _('debugsetparents REV1 [REV2]')),

1829

"debugstate": (debugstate, [], _('debugstate')),

1829

"debugstate": (debugstate, [], _('debugstate')),

1830

"debugdata": (debugdata, [], _('debugdata FILE REV')),

1830

"debugdata": (debugdata, [], _('debugdata FILE REV')),

1831

"debugindex": (debugindex, [], _('debugindex FILE')),

1831

"debugindex": (debugindex, [], _('debugindex FILE')),

1832

"debugindexdot": (debugindexdot, [], _('debugindexdot FILE')),

1832

"debugindexdot": (debugindexdot, [], _('debugindexdot FILE')),

1833

"debugrename": (debugrename, [], _('debugrename FILE [REV]')),

1833

"debugrename": (debugrename, [], _('debugrename FILE [REV]')),

1834

"debugwalk":

1834

"debugwalk":

1835

(debugwalk,

1835

(debugwalk,

1836

[('I', 'include', [], _('include path in search')),

1836

[('I', 'include', [], _('include path in search')),

1837

('X', 'exclude', [], _('exclude path from search'))],

1837

('X', 'exclude', [], _('exclude path from search'))],

1838

_('debugwalk [OPTION]... [FILE]...')),

1838

_('debugwalk [OPTION]... [FILE]...')),

1839

"^diff":

1839

"^diff":

1840

(diff,

1840

(diff,

1841

[('r', 'rev', [], _('revision')),

1841

[('r', 'rev', [], _('revision')),

1842

('a', 'text', None, _('treat all files as text')),

1842

('a', 'text', None, _('treat all files as text')),

1843

('I', 'include', [], _('include path in search')),

1843

('I', 'include', [], _('include path in search')),

1844

('X', 'exclude', [], _('exclude path from search'))],

1844

('X', 'exclude', [], _('exclude path from search'))],

1845

_('hg diff [-a] [-I] [-X] [-r REV1 [-r REV2]] [FILE]...')),

1845

_('hg diff [-a] [-I] [-X] [-r REV1 [-r REV2]] [FILE]...')),

1846

"^export":

1846

"^export":

1847

(export,

1847

(export,

1848

[('o', 'output', "", _('output to file')),

1848

[('o', 'output', "", _('output to file')),

1849

('a', 'text', None, _('treat all files as text'))],

1849

('a', 'text', None, _('treat all files as text'))],

1850

_("hg export [-a] [-o OUTFILE] REV...")),

1850

_("hg export [-a] [-o OUTFILE] REV...")),

1851

"forget":

1851

"forget":

1852

(forget,

1852

(forget,

1853

[('I', 'include', [], _('include path in search')),

1853

[('I', 'include', [], _('include path in search')),

1854

('X', 'exclude', [], _('exclude path from search'))],

1854

('X', 'exclude', [], _('exclude path from search'))],

1855

_("hg forget [OPTION]... FILE...")),

1855

_("hg forget [OPTION]... FILE...")),

1856

"grep":

1856

"grep":

1857

(grep,

1857

(grep,

1858

[('0', 'print0', None, _('end fields with NUL')),

1858

[('0', 'print0', None, _('end fields with NUL')),

1859

('I', 'include', [], _('include path in search')),

1859

('I', 'include', [], _('include path in search')),

1860

('X', 'exclude', [], _('include path in search')),

1860

('X', 'exclude', [], _('include path in search')),

1861

('', 'all', None, _('print all revisions with matches')),

1861

('', 'all', None, _('print all revisions with matches')),

1862

('i', 'ignore-case', None, _('ignore case when matching')),

1862

('i', 'ignore-case', None, _('ignore case when matching')),

1863

('l', 'files-with-matches', None, _('print names of files and revs with matches')),

1863

('l', 'files-with-matches', None, _('print names of files and revs with matches')),

1864

('n', 'line-number', None, _('print line numbers')),

1864

('n', 'line-number', None, _('print line numbers')),

1865

('r', 'rev', [], _('search in revision rev')),

1865

('r', 'rev', [], _('search in revision rev')),

1866

('u', 'user', None, _('print user who made change'))],

1866

('u', 'user', None, _('print user who made change'))],

1867

_("hg grep [OPTION]... PATTERN [FILE]...")),

1867

_("hg grep [OPTION]... PATTERN [FILE]...")),

1868

"heads":

1868

"heads":

1869

(heads,

1869

(heads,

1870

[('b', 'branches', None, _('find branch info'))],

1870

[('b', 'branches', None, _('find branch info'))],

1871

_('hg heads [-b]')),

1871

_('hg heads [-b]')),

1872

"help": (help_, [], _('hg help [COMMAND]')),

1872

"help": (help_, [], _('hg help [COMMAND]')),

1873

"identify|id": (identify, [], _('hg identify')),

1873

"identify|id": (identify, [], _('hg identify')),

1874

"import|patch":

1874

"import|patch":

1875

(import_,

1875

(import_,

1876

[('p', 'strip', 1, _('path strip')),

1876

[('p', 'strip', 1, _('path strip')),

1877

('f', 'force', None, _('skip check for outstanding changes')),

1877

('f', 'force', None, _('skip check for outstanding changes')),

1878

('b', 'base', "", _('base path'))],

1878

('b', 'base', "", _('base path'))],

1879

_("hg import [-f] [-p NUM] [-b BASE] PATCH...")),

1879

_("hg import [-f] [-p NUM] [-b BASE] PATCH...")),

1880

"incoming|in": (incoming,

1880

"incoming|in": (incoming,

1881

[('p', 'patch', None, _('show patch'))],

1881

[('p', 'patch', None, _('show patch'))],

1882

_('hg incoming [-p] [SOURCE]')),

1882

_('hg incoming [-p] [SOURCE]')),

1883

"^init": (init, [], _('hg init [DEST]')),

1883

"^init": (init, [], _('hg init [DEST]')),

1884

"locate":

1884

"locate":

1885

(locate,

1885

(locate,

1886

[('r', 'rev', '', _('revision')),

1886

[('r', 'rev', '', _('revision')),

1887

('0', 'print0', None, _('end filenames with NUL')),

1887

('0', 'print0', None, _('end filenames with NUL')),

1888

('f', 'fullpath', None, _('print complete paths')),

1888

('f', 'fullpath', None, _('print complete paths')),

1889

('I', 'include', [], _('include path in search')),

1889

('I', 'include', [], _('include path in search')),

1890

('X', 'exclude', [], _('exclude path from search'))],

1890

('X', 'exclude', [], _('exclude path from search'))],

1891

_('hg locate [OPTION]... [PATTERN]...')),

1891

_('hg locate [OPTION]... [PATTERN]...')),

1892

"^log|history":

1892

"^log|history":

1893

(log,

1893

(log,

1894

[('I', 'include', [], _('include path in search')),

1894

[('I', 'include', [], _('include path in search')),

1895

('X', 'exclude', [], _('exclude path from search')),

1895

('X', 'exclude', [], _('exclude path from search')),

1896

('b', 'branch', None, _('show branches')),

1896

('b', 'branch', None, _('show branches')),

1897

('k', 'keyword', [], _('search for a keyword')),

1897

('k', 'keyword', [], _('search for a keyword')),

1898

('r', 'rev', [], _('revision')),

1898

('r', 'rev', [], _('revision')),

1899

('p', 'patch', None, _('show patch'))],

1899

('p', 'patch', None, _('show patch'))],

1900

_('hg log [-I] [-X] [-r REV]... [-p] [FILE]')),

1900

_('hg log [-I] [-X] [-r REV]... [-p] [FILE]')),

1901

"manifest": (manifest, [], _('hg manifest [REV]')),

1901

"manifest": (manifest, [], _('hg manifest [REV]')),

1902

"outgoing|out": (outgoing,

1902

"outgoing|out": (outgoing,

1903

[('p', 'patch', None, _('show patch'))],

1903

[('p', 'patch', None, _('show patch'))],

1904

_('hg outgoing [-p] [DEST]')),

1904

_('hg outgoing [-p] [DEST]')),

1905

"parents": (parents, [], _('hg parents [REV]')),

1905

"parents": (parents, [], _('hg parents [REV]')),

1906

"paths": (paths, [], _('hg paths [NAME]')),

1906

"paths": (paths, [], _('hg paths [NAME]')),

1907

"^pull":

1907

"^pull":

1908

(pull,

1908

(pull,

1909

[('u', 'update', None, _('update working directory')),

1909

[('u', 'update', None, _('update working directory')),

1910

('e', 'ssh', "", _('ssh command')),

1910

('e', 'ssh', "", _('ssh command')),

1911

('', 'remotecmd', "", _('remote hg command'))],

1911

('', 'remotecmd', "", _('remote hg command'))],

1912

_('hg pull [-u] [-e FILE] [--remotecmd FILE] [SOURCE]')),

1912

_('hg pull [-u] [-e FILE] [--remotecmd FILE] [SOURCE]')),

1913

"^push":

1913

"^push":

1914

(push,

1914

(push,

1915

[('f', 'force', None, _('force push')),

1915

[('f', 'force', None, _('force push')),

1916

('e', 'ssh', "", _('ssh command')),

1916

('e', 'ssh', "", _('ssh command')),

1917

('', 'remotecmd', "", _('remote hg command'))],

1917

('', 'remotecmd', "", _('remote hg command'))],

1918

_('hg push [-f] [-e FILE] [--remotecmd FILE] [DEST]')),

1918

_('hg push [-f] [-e FILE] [--remotecmd FILE] [DEST]')),

1919

"rawcommit":

1919

"rawcommit":

1920

(rawcommit,

1920

(rawcommit,

1921

[('p', 'parent', [], _('parent')),

1921

[('p', 'parent', [], _('parent')),

1922

('d', 'date', "", _('date code')),

1922

('d', 'date', "", _('date code')),

1923

('u', 'user', "", _('user')),

1923

('u', 'user', "", _('user')),

1924

('F', 'files', "", _('file list')),

1924

('F', 'files', "", _('file list')),

1925

('m', 'message', "", _('commit message')),

1925

('m', 'message', "", _('commit message')),

1926

('t', 'text', "", _('commit message (deprecated: use -m)')),

1926

('t', 'text', "", _('commit message (deprecated: use -m)')),

1927

('l', 'logfile', "", _('commit message file'))],

1927

('l', 'logfile', "", _('commit message file'))],

1928

_('hg rawcommit [OPTION]... [FILE]...')),

1928

_('hg rawcommit [OPTION]... [FILE]...')),

1929

"recover": (recover, [], _("hg recover")),

1929

"recover": (recover, [], _("hg recover")),

1930

"^remove|rm": (remove,

1930

"^remove|rm": (remove,

1931

[('I', 'include', [], _('include path in search')),

1931

[('I', 'include', [], _('include path in search')),

1932

('X', 'exclude', [], _('exclude path from search'))],

1932

('X', 'exclude', [], _('exclude path from search'))],

1933

_("hg remove [OPTION]... FILE...")),

1933

_("hg remove [OPTION]... FILE...")),

1934

"rename|mv": (rename,

1934

"rename|mv": (rename,

1935

[('I', 'include', [], _('include path in search')),

1935

[('I', 'include', [], _('include path in search')),

1936

('X', 'exclude', [], _('exclude path from search')),

1936

('X', 'exclude', [], _('exclude path from search')),

1937

('A', 'after', None, _('record a copy after it has happened')),

1937

('A', 'after', None, _('record a copy after it has happened')),

1938

('f', 'force', None, _('replace destination if it exists')),

1938

('f', 'force', None, _('replace destination if it exists')),

1939

('p', 'parents', None, _('append source path to dest'))],

1939

('p', 'parents', None, _('append source path to dest'))],

1940

_('hg rename [OPTION]... [SOURCE]... DEST')),

1940

_('hg rename [OPTION]... [SOURCE]... DEST')),

1941

"^revert":

1941

"^revert":

1942

(revert,

1942

(revert,

1943

[("n", "nonrecursive", None, _("don't recurse into subdirs")),

1943

[("n", "nonrecursive", None, _("don't recurse into subdirs")),

1944

("r", "rev", "", _("revision"))],

1944

("r", "rev", "", _("revision"))],

1945

_("hg revert [-n] [-r REV] [NAME]...")),

1945

_("hg revert [-n] [-r REV] [NAME]...")),

1946

"root": (root, [], _("hg root")),

1946

"root": (root, [], _("hg root")),

1947

"^serve":

1947

"^serve":

1948

(serve,

1948

(serve,

1949

[('A', 'accesslog', '', _('access log file')),

1949

[('A', 'accesslog', '', _('access log file')),

1950

('E', 'errorlog', '', _('error log file')),

1950

('E', 'errorlog', '', _('error log file')),

1951

('p', 'port', 0, _('listen port')),

1951

('p', 'port', 0, _('listen port')),

1952

('a', 'address', '', _('interface address')),

1952

('a', 'address', '', _('interface address')),

1953

('n', 'name', "", _('repository name')),

1953

('n', 'name', "", _('repository name')),

1954

('', 'stdio', None, _('for remote clients')),

1954

('', 'stdio', None, _('for remote clients')),

1955

('t', 'templates', "", _('template directory')),

1955

('t', 'templates', "", _('template directory')),

1956

('', 'style', "", _('template style')),

1956

('', 'style', "", _('template style')),

1957

('6', 'ipv6', None, _('use IPv6 in addition to IPv4'))],

1957

('6', 'ipv6', None, _('use IPv6 in addition to IPv4'))],

1958

_("hg serve [OPTION]...")),

1958

_("hg serve [OPTION]...")),

1959

"^status":

1959

"^status":

1960

(status,

1960

(status,

1961

[('m', 'modified', None, _('show only modified files')),

1961

[('m', 'modified', None, _('show only modified files')),

1962

('a', 'added', None, _('show only added files')),

1962

('a', 'added', None, _('show only added files')),

1963

('r', 'removed', None, _('show only removed files')),

1963

('r', 'removed', None, _('show only removed files')),

1964

('u', 'unknown', None, _('show only unknown (not tracked) files')),

1964

('u', 'unknown', None, _('show only unknown (not tracked) files')),

1965

('n', 'no-status', None, _('hide status prefix')),

1965

('n', 'no-status', None, _('hide status prefix')),

1966

('0', 'print0', None, _('end filenames with NUL')),

1966

('0', 'print0', None, _('end filenames with NUL')),

1967

('I', 'include', [], _('include path in search')),

1967

('I', 'include', [], _('include path in search')),

1968

('X', 'exclude', [], _('exclude path from search'))],

1968

('X', 'exclude', [], _('exclude path from search'))],

1969

_("hg status [OPTION]... [FILE]...")),

1969

_("hg status [OPTION]... [FILE]...")),

1970

"tag":

1970

"tag":

1971

(tag,

1971

(tag,

1972

[('l', 'local', None, _('make the tag local')),

1972

[('l', 'local', None, _('make the tag local')),

1973

('m', 'message', "", _('commit message')),

1973

('m', 'message', "", _('commit message')),

1974

('t', 'text', "", _('commit message (deprecated: use -m)')),

1974

('t', 'text', "", _('commit message (deprecated: use -m)')),

1975

('d', 'date', "", _('date code')),

1975

('d', 'date', "", _('date code')),

1976

('u', 'user', "", _('user'))],

1976

('u', 'user', "", _('user'))],

1977

_('hg tag [OPTION]... NAME [REV]')),

1977

_('hg tag [OPTION]... NAME [REV]')),

1978

"tags": (tags, [], _('hg tags')),

1978

"tags": (tags, [], _('hg tags')),

1979

"tip": (tip, [], _('hg tip')),

1979

"tip": (tip, [], _('hg tip')),

1980

"unbundle":

1980

"unbundle":

1981

(unbundle,

1981

(unbundle,

1982

[],

1982

[],

1983

_('hg unbundle FILE')),

1983

_('hg unbundle FILE')),

1984

"undo": (undo, [], _('hg undo')),

1984

"undo": (undo, [], _('hg undo')),

1985

"^update|up|checkout|co":

1985

"^update|up|checkout|co":

1986

(update,

1986

(update,

1987

[('b', 'branch', "", _('checkout the head of a specific branch')),

1987

[('b', 'branch', "", _('checkout the head of a specific branch')),

1988

('m', 'merge', None, _('allow merging of conflicts')),

1988

('m', 'merge', None, _('allow merging of conflicts')),

1989

('C', 'clean', None, _('overwrite locally modified files'))],

1989

('C', 'clean', None, _('overwrite locally modified files'))],

1990

_('hg update [-b TAG] [-m] [-C] [REV]')),

1990

_('hg update [-b TAG] [-m] [-C] [REV]')),

1991

"verify": (verify, [], _('hg verify')),

1991

"verify": (verify, [], _('hg verify')),

1992

"version": (show_version, [], _('hg version')),

1992

"version": (show_version, [], _('hg version')),

1993

}

1993

}

1994

1995

globalopts = [

1995

globalopts = [

1996

('R', 'repository', "", _('repository root directory')),

1996

('R', 'repository', "", _('repository root directory')),

1997

('', 'cwd', '', _('change working directory')),

1997

('', 'cwd', '', _('change working directory')),

1998

('y', 'noninteractive', None, _('run non-interactively')),

1998

('y', 'noninteractive', None, _('run non-interactively')),

1999

('q', 'quiet', None, _('quiet mode')),

1999

('q', 'quiet', None, _('quiet mode')),

2000

('v', 'verbose', None, _('verbose mode')),

2000

('v', 'verbose', None, _('verbose mode')),

2001

('', 'debug', None, _('debug mode')),

2001

('', 'debug', None, _('debug mode')),

2002

('', 'debugger', None, _('start debugger')),

2002

('', 'debugger', None, _('start debugger')),

2003

('', 'traceback', None, _('print traceback on exception')),

2003

('', 'traceback', None, _('print traceback on exception')),

2004

('', 'time', None, _('time how long the command takes')),

2004

('', 'time', None, _('time how long the command takes')),

2005

('', 'profile', None, _('profile')),

2005

('', 'profile', None, _('profile')),

2006

('', 'version', None, _('output version information and exit')),

2006

('', 'version', None, _('output version information and exit')),

2007

('h', 'help', None, _('display help and exit')),

2007

('h', 'help', None, _('display help and exit')),

2008

]

2008

]

2009

2010

norepo = ("clone init version help debugancestor debugconfig debugdata"

2010

norepo = ("clone init version help debugancestor debugconfig debugdata"

2011

" debugindex debugindexdot paths")

2011

" debugindex debugindexdot paths")

2012

2013

def find(cmd):

2013

def find(cmd):

2014

for e in table.keys():

2014

for e in table.keys():

2015

if re.match("(%s)$" % e, cmd):

2015

if re.match("(%s)$" % e, cmd):

2016

return e, table[e]

2016

return e, table[e]

2017

2018

raise UnknownCommand(cmd)

2018

raise UnknownCommand(cmd)

2019

2020

class SignalInterrupt(Exception):

2020

class SignalInterrupt(Exception):

2021

"""Exception raised on SIGTERM and SIGHUP."""

2021

"""Exception raised on SIGTERM and SIGHUP."""

2022

2023

def catchterm(*args):

2023

def catchterm(*args):

2024

raise SignalInterrupt

2024

raise SignalInterrupt

2025

2026

def run():

2026

def run():

2027

sys.exit(dispatch(sys.argv[1:]))

2027

sys.exit(dispatch(sys.argv[1:]))

2028

2029

class ParseError(Exception):

2029

class ParseError(Exception):

2030

"""Exception raised on errors in parsing the command line."""

2030

"""Exception raised on errors in parsing the command line."""

2031

2032

def parse(args):

2032

def parse(args):

2033

options = {}

2033

options = {}

2034

cmdoptions = {}

2034

cmdoptions = {}

2035

2036

try:

2036

try:

2037

args = fancyopts.fancyopts(args, globalopts, options)

2037

args = fancyopts.fancyopts(args, globalopts, options)

2038

except fancyopts.getopt.GetoptError, inst:

2038

except fancyopts.getopt.GetoptError, inst:

2039

raise ParseError(None, inst)

2039

raise ParseError(None, inst)

2040

2041

if args:

2041

if args:

2042

cmd, args = args[0], args[1:]

2042

cmd, args = args[0], args[1:]

2043

i = find(cmd)[1]

2043

i = find(cmd)[1]

2044

c = list(i[1])

2044

c = list(i[1])

2045

else:

2045

else:

2046

cmd = None

2046

cmd = None

2047

c = []

2047

c = []

2048

2049

# combine global options into local

2049

# combine global options into local

2050

for o in globalopts:

2050

for o in globalopts:

2051

c.append((o[0], o[1], options[o[1]], o[3]))

2051

c.append((o[0], o[1], options[o[1]], o[3]))

2052

2053

try:

2053

try:

2054

args = fancyopts.fancyopts(args, c, cmdoptions)

2054

args = fancyopts.fancyopts(args, c, cmdoptions)

2055

except fancyopts.getopt.GetoptError, inst:

2055

except fancyopts.getopt.GetoptError, inst:

2056

raise ParseError(cmd, inst)

2056

raise ParseError(cmd, inst)

2057

2058

# separate global options back out

2058

# separate global options back out

2059

for o in globalopts:

2059

for o in globalopts:

2060

n = o[1]

2060

n = o[1]

2061

options[n] = cmdoptions[n]

2061

options[n] = cmdoptions[n]

2062

del cmdoptions[n]

2062

del cmdoptions[n]

2063

2064

return (cmd, cmd and i[0] or None, args, options, cmdoptions)

2064

return (cmd, cmd and i[0] or None, args, options, cmdoptions)

2065

2066

def dispatch(args):

2066

def dispatch(args):

2067

signal.signal(signal.SIGTERM, catchterm)

2067

signal.signal(signal.SIGTERM, catchterm)

2068

try:

2068

try:

2069

signal.signal(signal.SIGHUP, catchterm)

2069

signal.signal(signal.SIGHUP, catchterm)

2070

except AttributeError:

2070

except AttributeError:

2071

pass

2071

pass

2072

2073

u = ui.ui()

2073

u = ui.ui()

2074

external = []

2074

external = []

2075

for x in u.extensions():

2075

for x in u.extensions():

2076

if x[1]:

2076

if x[1]:

2077

try:

2077

try:

2078

mod = imp.load_source(x[0], x[1])

2078

mod = imp.load_source(x[0], x[1])

2079

except:

2079

except:

2080

u.warn(_("*** failed to import extension %s\n") % x[1])

2080

u.warn(_("*** failed to import extension %s\n") % x[1])

2081

continue

2081

continue

2082

else:

2082

else:

2083

def importh(name):

2083

def importh(name):

2084

mod = __import__(name)

2084

mod = __import__(name)

2085

components = name.split('.')

2085

components = name.split('.')

2086

for comp in components[1:]:

2086

for comp in components[1:]:

2087

mod = getattr(mod, comp)

2087

mod = getattr(mod, comp)

2088

return mod

2088

return mod

2089

try:

2089

try:

2090

mod = importh(x[0])

2090

mod = importh(x[0])

2091

except:

2091

except:

2092

u.warn(_("failed to import extension %s\n") % x[0])

2092

u.warn(_("failed to import extension %s\n") % x[0])

2093

continue

2093

continue

2094

2095

external.append(mod)

2095

external.append(mod)

2096

for x in external:

2096

for x in external:

2097

cmdtable = getattr(x, 'cmdtable', {})

2097

cmdtable = getattr(x, 'cmdtable', {})

2098

for t in cmdtable:

2098

for t in cmdtable:

2099

if t in table:

2099

if t in table:

2100

u.warn(_("module %s overrides %s\n") % (x.__name__, t))

2100

u.warn(_("module %s overrides %s\n") % (x.__name__, t))

2101

table.update(cmdtable)

2101

table.update(cmdtable)

2102

2103

try:

2103

try:

2104

cmd, func, args, options, cmdoptions = parse(args)

2104

cmd, func, args, options, cmdoptions = parse(args)

2105

except ParseError, inst:

2105

except ParseError, inst:

2106

if inst.args[0]:

2106

if inst.args[0]:

2107

u.warn(_("hg %s: %s\n") % (inst.args[0], inst.args[1]))

2107

u.warn(_("hg %s: %s\n") % (inst.args[0], inst.args[1]))

2108

help_(u, inst.args[0])

2108

help_(u, inst.args[0])

2109

else:

2109

else:

2110

u.warn(_("hg: %s\n") % inst.args[1])

2110

u.warn(_("hg: %s\n") % inst.args[1])

2111

help_(u, 'shortlist')

2111

help_(u, 'shortlist')

2112

sys.exit(-1)

2112

sys.exit(-1)

2113

except UnknownCommand, inst:

2113

except UnknownCommand, inst:

2114

u.warn(_("hg: unknown command '%s'\n") % inst.args[0])

2114

u.warn(_("hg: unknown command '%s'\n") % inst.args[0])

2115

help_(u, 'shortlist')

2115

help_(u, 'shortlist')

2116

sys.exit(1)

2116

sys.exit(1)

2117

2118

if options["time"]:

2118

if options["time"]:

2119

def get_times():

2119

def get_times():

2120

t = os.times()

2120

t = os.times()

2121

if t[4] == 0.0: # Windows leaves this as zero, so use time.clock()

2121

if t[4] == 0.0: # Windows leaves this as zero, so use time.clock()

2122

t = (t[0], t[1], t[2], t[3], time.clock())

2122

t = (t[0], t[1], t[2], t[3], time.clock())

2123

return t

2123

return t

2124

s = get_times()

2124

s = get_times()

2125

def print_time():

2125

def print_time():

2126

t = get_times()

2126

t = get_times()

2127

u.warn(_("Time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n") %

2127

u.warn(_("Time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n") %

2128

(t[4]-s[4], t[0]-s[0], t[2]-s[2], t[1]-s[1], t[3]-s[3]))

2128

(t[4]-s[4], t[0]-s[0], t[2]-s[2], t[1]-s[1], t[3]-s[3]))

2129

atexit.register(print_time)

2129

atexit.register(print_time)

2130

2131

u.updateopts(options["verbose"], options["debug"], options["quiet"],

2131

u.updateopts(options["verbose"], options["debug"], options["quiet"],

2132

not options["noninteractive"])

2132

not options["noninteractive"])

2133

2134

# enter the debugger before command execution

2134

# enter the debugger before command execution

2135

if options['debugger']:

2135

if options['debugger']:

2136

pdb.set_trace()

2136

pdb.set_trace()

2137

2138

try:

2138

try:

2139

try:

2139

try:

2140

if options['help']:

2140

if options['help']:

2141

help_(u, cmd, options['version'])

2141

help_(u, cmd, options['version'])

2142

sys.exit(0)

2142

sys.exit(0)

2143

elif options['version']:

2143

elif options['version']:

2144

show_version(u)

2144

show_version(u)

2145

sys.exit(0)

2145

sys.exit(0)

2146

elif not cmd:

2146

elif not cmd:

2147

help_(u, 'shortlist')

2147

help_(u, 'shortlist')

2148

sys.exit(0)

2148

sys.exit(0)

2149

2150

if options['cwd']:

2150

if options['cwd']:

2151

try:

2151

try:

2152

os.chdir(options['cwd'])

2152

os.chdir(options['cwd'])

2153

except OSError, inst:

2153

except OSError, inst:

2154

raise util.Abort('%s: %s' %

2154

raise util.Abort('%s: %s' %

2155

(options['cwd'], inst.strerror))

2155

(options['cwd'], inst.strerror))

2156

2157

if cmd not in norepo.split():

2157

if cmd not in norepo.split():

2158

path = options["repository"] or ""

2158

path = options["repository"] or ""

2159

repo = hg.repository(ui=u, path=path)

2159

repo = hg.repository(ui=u, path=path)

2160

for x in external:

2160

for x in external:

2161

if hasattr(x, 'reposetup'): x.reposetup(u, repo)

2161

if hasattr(x, 'reposetup'): x.reposetup(u, repo)

2162

d = lambda: func(u, repo, *args, **cmdoptions)

2162

d = lambda: func(u, repo, *args, **cmdoptions)

2163

else:

2163

else:

2164

d = lambda: func(u, *args, **cmdoptions)

2164

d = lambda: func(u, *args, **cmdoptions)

2165

2166

if options['profile']:

2166

if options['profile']:

2167

import hotshot, hotshot.stats

2167

import hotshot, hotshot.stats

2168

prof = hotshot.Profile("hg.prof")

2168

prof = hotshot.Profile("hg.prof")

2169

r = prof.runcall(d)

2169

r = prof.runcall(d)

2170

prof.close()

2170

prof.close()

2171

stats = hotshot.stats.load("hg.prof")

2171

stats = hotshot.stats.load("hg.prof")

2172

stats.strip_dirs()

2172

stats.strip_dirs()

2173

stats.sort_stats('time', 'calls')

2173

stats.sort_stats('time', 'calls')

2174

stats.print_stats(40)

2174

stats.print_stats(40)

2175

return r

2175

return r

2176

else:

2176

else:

2177

return d()

2177

return d()

2178

except:

2178

except:

2179

# enter the debugger when we hit an exception

2179

# enter the debugger when we hit an exception

2180

if options['debugger']:

2180

if options['debugger']:

2181

pdb.post_mortem(sys.exc_info()[2])

2181

pdb.post_mortem(sys.exc_info()[2])

2182

if options['traceback']:

2182

if options['traceback']:

2183

traceback.print_exc()

2183

traceback.print_exc()

2184

raise

2184

raise

2185

except hg.RepoError, inst:

2185

except hg.RepoError, inst:

2186

u.warn(_("abort: "), inst, "!\n")

2186

u.warn(_("abort: "), inst, "!\n")

2187

except revlog.RevlogError, inst:

2187

except revlog.RevlogError, inst:

2188

u.warn(_("abort: "), inst, "!\n")

2188

u.warn(_("abort: "), inst, "!\n")

2189

except SignalInterrupt:

2189

except SignalInterrupt:

2190

u.warn(_("killed!\n"))

2190

u.warn(_("killed!\n"))

2191

except KeyboardInterrupt:

2191

except KeyboardInterrupt:

2192

try:

2192

try:

2193

u.warn(_("interrupted!\n"))

2193

u.warn(_("interrupted!\n"))

2194

except IOError, inst:

2194

except IOError, inst:

2195

if inst.errno == errno.EPIPE:

2195

if inst.errno == errno.EPIPE:

2196

if u.debugflag:

2196

if u.debugflag:

2197

u.warn(_("\nbroken pipe\n"))

2197

u.warn(_("\nbroken pipe\n"))

2198

else:

2198

else:

2199

raise

2199

raise

2200

except IOError, inst:

2200

except IOError, inst:

2201

if hasattr(inst, "code"):

2201

if hasattr(inst, "code"):

2202

u.warn(_("abort: %s\n") % inst)

2202

u.warn(_("abort: %s\n") % inst)

2203

elif hasattr(inst, "reason"):

2203

elif hasattr(inst, "reason"):

2204

u.warn(_("abort: error: %s\n") % inst.reason[1])

2204

u.warn(_("abort: error: %s\n") % inst.reason[1])

2205

elif hasattr(inst, "args") and inst[0] == errno.EPIPE:

2205

elif hasattr(inst, "args") and inst[0] == errno.EPIPE:

2206

if u.debugflag:

2206

if u.debugflag:

2207

u.warn(_("broken pipe\n"))

2207

u.warn(_("broken pipe\n"))

2208

elif getattr(inst, "strerror", None):

2208

elif getattr(inst, "strerror", None):

2209

if getattr(inst, "filename", None):

2209

if getattr(inst, "filename", None):

2210

u.warn(_("abort: %s - %s\n") % (inst.strerror, inst.filename))

2210

u.warn(_("abort: %s - %s\n") % (inst.strerror, inst.filename))

2211

else:

2211

else:

2212

u.warn(_("abort: %s\n") % inst.strerror)

2212

u.warn(_("abort: %s\n") % inst.strerror)

2213

else:

2213

else:

2214

raise

2214

raise

2215

except OSError, inst:

2215

except OSError, inst:

2216

if hasattr(inst, "filename"):

2216

if hasattr(inst, "filename"):

2217

u.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename))

2217

u.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename))

2218

else:

2218

else:

2219

u.warn(_("abort: %s\n") % inst.strerror)

2219

u.warn(_("abort: %s\n") % inst.strerror)

2220

except util.Abort, inst:

2220

except util.Abort, inst:

2221

u.warn(_('abort: '), inst.args[0] % inst.args[1:], '\n')

2221

u.warn(_('abort: '), inst.args[0] % inst.args[1:], '\n')

2222

sys.exit(1)

2222

sys.exit(1)

2223

except TypeError, inst:

2223

except TypeError, inst:

2224

# was this an argument error?

2224

# was this an argument error?

2225

tb = traceback.extract_tb(sys.exc_info()[2])

2225

tb = traceback.extract_tb(sys.exc_info()[2])

2226

if len(tb) > 2: # no

2226

if len(tb) > 2: # no

2227

raise

2227

raise

2228

u.debug(inst, "\n")

2228

u.debug(inst, "\n")

2229

u.warn(_("%s: invalid arguments\n") % cmd)

2229

u.warn(_("%s: invalid arguments\n") % cmd)

2230

help_(u, cmd)

2230

help_(u, cmd)

2231

except UnknownCommand, inst:

2231

except UnknownCommand, inst:

2232

u.warn(_("hg: unknown command '%s'\n") % inst.args[0])

2232

u.warn(_("hg: unknown command '%s'\n") % inst.args[0])

2233

help_(u, 'shortlist')

2233

help_(u, 'shortlist')

2234

except SystemExit:

2234

except SystemExit:

2235

# don't catch this in the catch-all below

2235

# don't catch this in the catch-all below

2236

raise

2236

raise

2237

except:

2237

except:

2238

u.warn(_("** unknown exception encountered, details follow\n"))

2238

u.warn(_("** unknown exception encountered, details follow\n"))

2239

u.warn(_("** report bug details to mercurial@selenic.com\n"))

2239

u.warn(_("** report bug details to mercurial@selenic.com\n"))

2240

raise

2240

raise

2241

2242

sys.exit(-1)

2242

sys.exit(-1)

             #!/bin/sh
             mkdir t
             cd t
             hg init
             mkdir -p beans
             for b in kidney navy turtle borlotti black pinto; do
                 echo $b > beans/$b
             done
             mkdir -p mammals/Procyonidae
             for m in cacomistle coatimundi raccoon; do
                 echo $m > mammals/Procyonidae/$m
             done
             echo skunk > mammals/skunk
             echo fennel > fennel
             echo fenugreek > fenugreek
             echo fiddlehead > fiddlehead
             echo glob:glob > glob:glob
             hg addremove
             hg commit -m "commit #0" -d "0 0"
             hg debugwalk
             cd mammals
             hg debugwalk
             hg debugwalk Procyonidae
             cd Procyonidae
             hg debugwalk
             hg debugwalk ..
             cd ..
             hg debugwalk ../beans
             hg debugwalk
             cd ..
             hg debugwalk -Ibeans
-            hg debugwalk 'mammals/../beans/b*'
+            hg debugwalk 'glob:mammals/../beans/b*'
             hg debugwalk '-X*/Procyonidae' mammals
             hg debugwalk path:mammals
             hg debugwalk ..
             hg debugwalk beans/../..
             # Don't know how to test absolute paths without always getting a false
             # error.
             #hg debugwalk `pwd`/beans
             #hg debugwalk `pwd`/..
             hg debugwalk glob:\*
             hg debugwalk 're:.*[kb]$'
             hg debugwalk path:beans/black
-            hg debugwalk beans 'beans/*'
+            hg debugwalk beans 'glob:beans/*'
-            hg debugwalk 'j*'
+            hg debugwalk 'glob:j*'
             hg debugwalk NOEXIST
             mkfifo fifo
             hg debugwalk fifo
             rm fenugreek
             hg debugwalk fenugreek
             hg rm fenugreek
             hg debugwalk fenugreek
             touch new
             hg debugwalk new

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

             # commands.py - command processing for mercurial
             #
             # Copyright 2005 Matt Mackall <mpm@selenic.com>
             #
             # This software may be used and distributed according to the terms
             # of the GNU General Public License, incorporated herein by reference.
             from demandload import demandload
             from node import *
             from i18n import gettext as _
             demandload(globals(), "os re sys signal shutil imp urllib pdb")
             demandload(globals(), "fancyopts ui hg util lock revlog")
             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."""
             def filterfiles(filters, files):
                 l = [x for x in files if x in filters]
                 for t in filters:
                     if t and t[-1] != "/":
                         t += "/"
                     l += [x for x in files if x.startswith(t)]
                 return l
             def relpath(repo, args):
                 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=''):
-                return util.matcher(repo.root, cwd, pats or ['.'], opts.get('include'),
+                return util.cmdmatcher(repo.root, cwd, pats or ['.'], opts.get('include'),
                                     opts.get('exclude'), head)
             def makewalk(repo, pats, opts, head=''):
                 cwd = repo.getcwd()
                 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):
                         yield src, fn, util.pathto(cwd, fn), fn in exact
                 return files, matchfn, walk()
             def walk(repo, pats, opts, head=''):
                 files, matchfn, results = makewalk(repo, pats, opts, head)
                 for r in results:
                     yield r
             def walkchangerevs(ui, repo, cwd, 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.
                 We walk a window of revisions in the desired order.  Within the
                 window, we first walk forwards to gather data, then in the desired
                 order (usually backwards) to display it.
                 This function returns an (iterator, getchange) pair.  The
                 getchange function returns the changelog entry for a numeric
                 revision.  The iterator yields 3-tuples.  They will be of one of
                 the following forms:
                 "window", incrementing, lastrev: stepping through a window,
                 positive if walking forwards through revs, last rev in the
                 sequence iterated over - use to reset state for the current window
                 "add", rev, fns: out-of-order traversal of the given file names
                 fns, which changed during revision rev - use to gather data for
                 possible display
                 "iter", rev, None: in-order traversal of the revs earlier iterated
                 over with "add" - use to display data'''
                 if repo.changelog.count() == 0:
                     return [], False
                 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']]
                 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 = {}
                 chcache = {}
                 def getchange(rev):
                     ch = chcache.get(rev)
                     if ch is None:
                         chcache[rev] = ch = repo.changelog.read(repo.lookup(str(rev)))
                     return ch
                 if not slowpath and not files:
                     # No files, no patterns.  Display all revs.
                     wanted = dict(zip(revs, revs))
                 if not slowpath:
                     # Only files, no patterns.  Check the history of each file.
                     def filerevgen(filelog):
                         for i in xrange(filelog.count() - 1, -1, -window):
                             revs = []
                             for j in xrange(max(0, i - window), i + 1):
                                 revs.append(filelog.linkrev(filelog.node(j)))
                             revs.reverse()
                             for rev in revs:
                                 yield rev
                     minrev, maxrev = min(revs), max(revs)
                     for file in files:
                         filelog = repo.file(file)
                         # A zero count may be a directory or deleted file, so
                         # try to find matching entries on the slow path.
                         if filelog.count() == 0:
                             slowpath = True
                             break
                         for rev in filerevgen(filelog):
                             if rev <= maxrev:
                                 if rev < minrev:
                                     break
                                 fncache.setdefault(rev, [])
                                 fncache[rev].append(file)
                                 wanted[rev] = 1
                 if slowpath:
                     # The slow path checks files modified in every changeset.
                     def changerevgen():
                         for i in xrange(repo.changelog.count() - 1, -1, -window):
                             for j in xrange(max(0, i - window), i + 1):
                                 yield j, getchange(j)[3]
                     for rev, changefiles in changerevgen():
                         matches = filter(matchfn, changefiles)
                         if matches:
                             fncache[rev] = matches
                             wanted[rev] = 1
                 def iterate():
                     for i in xrange(0, len(revs), window):
                         yield 'window', revs[0] < revs[-1], revs[-1]
                         nrevs = [rev for rev in revs[i:min(i+window, len(revs))]
                                  if rev in wanted]
                         srevs = list(nrevs)
                         srevs.sort()
                         for rev in srevs:
                             fns = fncache.get(rev) or filter(matchfn, getchange(rev)[3])
                             yield 'add', rev, fns
                         for rev in nrevs:
                             yield 'iter', rev, None
                 return iterate(), getchange
             revrangesep = ':'
             def revrange(ui, repo, revs, revlog=None):
                 """Yield revision as strings from a list of revision specifications."""
                 if revlog is None:
                     revlog = repo.changelog
                 revcount = revlog.count()
                 def fix(val, defval):
                     if not val:
                         return defval
                     try:
                         num = int(val)
                         if str(num) != val:
                             raise ValueError
                         if num < 0: num += revcount
                         if num < 0: num = 0
                         elif num >= revcount:
                             raise ValueError
                     except ValueError:
                         try:
                             num = repo.changelog.rev(repo.lookup(val))
                         except KeyError:
                             try:
                                 num = revlog.rev(revlog.lookup(val))
                             except KeyError:
                                 raise util.Abort(_('invalid revision identifier %s'), val)
                     return num
                 seen = {}
                 for spec in revs:
                     if spec.find(revrangesep) >= 0:
                         start, end = spec.split(revrangesep, 1)
                         start = fix(start, 0)
                         end = fix(end, revcount - 1)
                         step = start > end and -1 or 1
                         for rev in xrange(start, end+step, step):
                             if rev in seen: continue
                             seen[rev] = 1
                             yield str(rev)
                     else:
                         rev = fix(spec, None)
                         if rev in seen: continue
                         seen[rev] = 1
                         yield str(rev)
             def make_filename(repo, r, pat, node=None,
                               total=None, seqno=None, revwidth=None, pathname=None):
                 node_expander = {
                     'H': lambda: hex(node),
                     'R': lambda: str(r.rev(node)),
                     'h': lambda: short(node),
                     }
                 expander = {
                     '%': lambda: '%',
                     'b': lambda: os.path.basename(repo.root),
                     }
                 try:
                     if node:
                         expander.update(node_expander)
                     if node and revwidth is not None:
                         expander['r'] = lambda: str(r.rev(node)).zfill(revwidth)
                     if total is not None:
                         expander['N'] = lambda: str(total)
                     if seqno is not None:
                         expander['n'] = lambda: str(seqno)
                     if total is not None and seqno is not None:
                         expander['n'] = lambda:str(seqno).zfill(len(str(total)))
                     if pathname is not None:
                         expander['s'] = lambda: os.path.basename(pathname)
                         expander['d'] = lambda: os.path.dirname(pathname) or '.'
                         expander['p'] = lambda: pathname
                     newname = []
                     patlen = len(pat)
                     i = 0
                     while i < patlen:
                         c = pat[i]
                         if c == '%':
                             i += 1
                             c = pat[i]
                             c = expander[c]()
                         newname.append(c)
                         i += 1
                     return ''.join(newname)
                 except KeyError, inst:
                     raise util.Abort(_("invalid format spec '%%%s' in output file name"),
                                 inst.args[0])
             def make_file(repo, r, pat, node=None,
                           total=None, seqno=None, revwidth=None, mode='wb', pathname=None):
                 if not pat or pat == '-':
                     return 'w' in mode and sys.stdout or sys.stdin
                 if hasattr(pat, 'write') and 'w' in mode:
                     return pat
                 if hasattr(pat, 'read') and 'r' in mode:
                     return pat
                 return open(make_filename(repo, r, pat, node, total, seqno, revwidth,
                                           pathname),
                             mode)
             def dodiff(fp, ui, repo, node1, node2, files=None, match=util.always,
                        changes=None, text=False):
                 if not changes:
                     (c, a, d, u) = repo.changes(node1, node2, files, match=match)
                 else:
                     (c, a, d, u) = changes
                 if files:
                     c, a, d = map(lambda x: filterfiles(files, x), (c, a, d))
                 if not c and not a and not d:
                     return
                 if node2:
                     change = repo.changelog.read(node2)
                     mmap2 = repo.manifest.read(change[0])
                     date2 = util.datestr(change[2])
                     def read(f):
                         return repo.file(f).read(mmap2[f])
                 else:
                     date2 = util.datestr()
                     if not node1:
                         node1 = repo.dirstate.parents()[0]
                     def read(f):
                         return repo.wfile(f).read()
                 if ui.quiet:
                     r = None
                 else:
                     hexfunc = ui.verbose and hex or short
                     r = [hexfunc(node) for node in [node1, node2] if node]
                 change = repo.changelog.read(node1)
                 mmap = repo.manifest.read(change[0])
                 date1 = util.datestr(change[2])
                 for f in c:
                     to = None
                     if f in mmap:
                         to = repo.file(f).read(mmap[f])
                     tn = read(f)
                     fp.write(mdiff.unidiff(to, date1, tn, date2, f, r, text=text))
                 for f in a:
                     to = None
                     tn = read(f)
                     fp.write(mdiff.unidiff(to, date1, tn, date2, f, r, text=text))
                 for f in d:
                     to = repo.file(f).read(mmap[f])
                     tn = None
                     fp.write(mdiff.unidiff(to, date1, tn, date2, f, r, text=text))
             def trimuser(ui, name, rev, revcache):
                 """trim the name of the user who committed a change"""
                 user = revcache.get(rev)
                 if user is None:
                     user = revcache[rev] = ui.shortuser(name)
                 return user
             def show_changeset(ui, repo, rev=0, changenode=None, brinfo=None):
                 """show a single changeset or file revision"""
                 log = repo.changelog
                 if changenode is None:
                     changenode = log.node(rev)
                 elif not rev:
                     rev = log.rev(changenode)
                 if ui.quiet:
                     ui.write("%d:%s\n" % (rev, short(changenode)))
                     return
                 changes = log.read(changenode)
                 date = util.datestr(changes[2])
                 parents = [(log.rev(p), ui.verbose and hex(p) or short(p))
                            for p in log.parents(changenode)
                            if ui.debugflag or p != nullid]
                 if not ui.debugflag and len(parents) == 1 and parents[0][0] == rev-1:
                     parents = []
                 if ui.verbose:
                     ui.write(_("changeset:   %d:%s\n") % (rev, hex(changenode)))
                 else:
                     ui.write(_("changeset:   %d:%s\n") % (rev, short(changenode)))
                 for tag in repo.nodetags(changenode):
                     ui.status(_("tag:         %s\n") % tag)
                 for parent in parents:
                     ui.write(_("parent:      %d:%s\n") % parent)
                 if brinfo and changenode in brinfo:
                     br = brinfo[changenode]
                     ui.write(_("branch:      %s\n") % " ".join(br))
                 ui.debug(_("manifest:    %d:%s\n") % (repo.manifest.rev(changes[0]),
                                                   hex(changes[0])))
                 ui.status(_("user:        %s\n") % changes[1])
                 ui.status(_("date:        %s\n") % date)
                 if ui.debugflag:
                     files = repo.changes(log.parents(changenode)[0], changenode)
                     for key, value in zip([_("files:"), _("files+:"), _("files-:")], files):
                         if value:
                             ui.note("%-12s %s\n" % (key, " ".join(value)))
                 else:
                     ui.note(_("files:       %s\n") % " ".join(changes[3]))
                 description = changes[4].strip()
                 if description:
                     if ui.verbose:
                         ui.status(_("description:\n"))
                         ui.status(description)
                         ui.status("\n\n")
                     else:
                         ui.status(_("summary:     %s\n") % description.splitlines()[0])
                 ui.status("\n")
             def show_version(ui):
                 """output version and copyright information"""
                 ui.write(_("Mercurial Distributed SCM (version %s)\n")
                          % version.get_version())
                 ui.status(_(
                     "\nCopyright (C) 2005 Matt Mackall <mpm@selenic.com>\n"
                     "This is free software; see the source for copying conditions. "
                     "There is NO\nwarranty; "
                     "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
                 ))
             def help_(ui, cmd=None, with_version=False):
                 """show help for a given command or all commands"""
                 option_lists = []
                 if cmd and cmd != 'shortlist':
                     if with_version:
                         show_version(ui)
                         ui.write('\n')
                     key, i = find(cmd)
                     # synopsis
                     ui.write("%s\n\n" % i[2])
                     # description
                     doc = i[0].__doc__
                     if ui.quiet:
                         doc = doc.splitlines(0)[0]
                     ui.write("%s\n" % doc.rstrip())
                     if not ui.quiet:
                         # aliases
                         aliases = ', '.join(key.split('|')[1:])
                         if aliases:
                             ui.write(_("\naliases: %s\n") % aliases)
                         # options
                         if i[1]:
                             option_lists.append(("options", i[1]))
                 else:
                     # program name
                     if ui.verbose or with_version:
                         show_version(ui)
                     else:
                         ui.status(_("Mercurial Distributed SCM\n"))
                     ui.status('\n')
                     # list of commands
                     if cmd == "shortlist":
                         ui.status(_('basic commands (use "hg help" '
                                     'for the full list or option "-v" for details):\n\n'))
                     elif ui.verbose:
                         ui.status(_('list of commands:\n\n'))
                     else:
                         ui.status(_('list of commands (use "hg help -v" '
                                     'to show aliases and global options):\n\n'))
                     h = {}
                     cmds = {}
                     for c, e in table.items():
                         f = c.split("|")[0]
                         if cmd == "shortlist" and not f.startswith("^"):
                             continue
                         f = f.lstrip("^")
                         if not ui.debugflag and f.startswith("debug"):
                             continue
                         d = ""
                         if e[0].__doc__:
                             d = e[0].__doc__.splitlines(0)[0].rstrip()
                         h[f] = d
                         cmds[f]=c.lstrip("^")
                     fns = h.keys()
                     fns.sort()
                     m = max(map(len, fns))
                     for f in fns:
                         if ui.verbose:
                             commands = cmds[f].replace("|",", ")
                             ui.write(" %s:\n      %s\n"%(commands,h[f]))
                         else:
                             ui.write(' %-*s   %s\n' % (m, f, h[f]))
                 # global options
                 if ui.verbose:
                     option_lists.append(("global options", globalopts))
                 # list all option lists
                 opt_output = []
                 for title, options in option_lists:
                     opt_output.append(("\n%s:\n" % title, None))
                     for shortopt, longopt, default, desc in options:
                         opt_output.append(("%2s%s" % (shortopt and "-%s" % shortopt,
                                                       longopt and " --%s" % longopt),
                                            "%s%s" % (desc,
                                                      default and _(" (default: %s)") % default
                                                      or "")))
                 if opt_output:
                     opts_len = max([len(line[0]) for line in opt_output if line[1]])
                     for first, second in opt_output:
                         if second:
                             ui.write(" %-*s  %s\n" % (opts_len, first, second))
                         else:
                             ui.write("%s\n" % first)
             # Commands start here, listed alphabetically
             def add(ui, repo, *pats, **opts):
                 '''add the specified files on the next commit'''
                 names = []
                 for src, abs, rel, exact in walk(repo, pats, opts):
                     if exact:
                         if ui.verbose: ui.status(_('adding %s\n') % rel)
                         names.append(abs)
                     elif repo.dirstate.state(abs) == '?':
                         ui.status(_('adding %s\n') % rel)
                         names.append(abs)
                 repo.add(names)
             def addremove(ui, repo, *pats, **opts):
                 """add all new files, delete all missing files"""
                 add, remove = [], []
                 for src, abs, rel, exact in walk(repo, pats, opts):
                     if src == 'f' and repo.dirstate.state(abs) == '?':
                         add.append(abs)
                         if ui.verbose or not exact:
                             ui.status(_('adding %s\n') % rel)
                     if repo.dirstate.state(abs) != 'r' and not os.path.exists(rel):
                         remove.append(abs)
                         if ui.verbose or not exact:
                             ui.status(_('removing %s\n') % rel)
                 repo.add(add)
                 repo.remove(remove)
             def annotate(ui, repo, *pats, **opts):
                 """show changeset information per file line"""
                 def getnode(rev):
                     return short(repo.changelog.node(rev))
                 ucache = {}
                 def getname(rev):
                     cl = repo.changelog.read(repo.changelog.node(rev))
                     return trimuser(ui, cl[1], rev, ucache)
                 if not pats:
                     raise util.Abort(_('at least one file name or pattern required'))
                 opmap = [['user', getname], ['number', str], ['changeset', getnode]]
                 if not opts['user'] and not opts['changeset']:
                     opts['number'] = 1
                 if opts['rev']:
                     node = repo.changelog.lookup(opts['rev'])
                 else:
                     node = repo.dirstate.parents()[0]
                 change = repo.changelog.read(node)
                 mmap = repo.manifest.read(change[0])
                 for src, abs, rel, exact in walk(repo, pats, opts):
                     if abs not in mmap:
                         ui.warn(_("warning: %s is not in the repository!\n") % rel)
                         continue
                     f = repo.file(abs)
                     if not opts['text'] and util.binary(f.read(mmap[abs])):
                         ui.write(_("%s: binary file\n") % rel)
                         continue
                     lines = f.annotate(mmap[abs])
                     pieces = []
                     for o, f in opmap:
                         if opts[o]:
                             l = [f(n) for n, dummy in lines]
                             if l:
                                 m = max(map(len, l))
                                 pieces.append(["%*s" % (m, x) for x in l])
                     if pieces:
                         for p, l in zip(zip(*pieces), lines):
                             ui.write("%s: %s" % (" ".join(p), l[1]))
             def bundle(ui, repo, fname, dest="default-push", **opts):
                 """create a changegroup file"""
                 f = open(fname, "wb")
                 dest = ui.expandpath(dest)
                 other = hg.repository(ui, dest)
                 o = repo.findoutgoing(other)
                 cg = repo.changegroup(o)
                 try:
                     f.write("HG10")
                     z = bz2.BZ2Compressor(9)
                     while 1:
                         chunk = cg.read(4096)
                         if not chunk:
                             break
                         f.write(z.compress(chunk))
                     f.write(z.flush())
                 except:
                     os.unlink(fname)
                     raise
             def cat(ui, repo, file1, *pats, **opts):
                 """output the latest or given revisions of files"""
                 mf = {}
                 if opts['rev']:
                     change = repo.changelog.read(repo.lookup(opts['rev']))
                     mf = repo.manifest.read(change[0])
                 for src, abs, rel, exact in walk(repo, (file1,) + pats, opts):
                     r = repo.file(abs)
                     if opts['rev']:
                         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 dest is None:
                     dest = os.path.basename(os.path.normpath(source))
                 if os.path.exists(dest):
                     raise util.Abort(_("destination '%s' already exists"), dest)
                 dest = os.path.realpath(dest)
                 class Dircleanup:
                     def __init__(self, dir_):
                         self.rmtree = shutil.rmtree
                         self.dir_ = dir_
                         os.mkdir(dir_)
                     def close(self):
                         self.dir_ = None
                     def __del__(self):
                         if self.dir_:
                             self.rmtree(self.dir_, True)
                 if opts['ssh']:
                     ui.setconfig("ui", "ssh", opts['ssh'])
                 if opts['remotecmd']:
                     ui.setconfig("ui", "remotecmd", opts['remotecmd'])
                 if not os.path.exists(source):
                     source = ui.expandpath(source)
                 d = Dircleanup(dest)
                 abspath = source
                 other = hg.repository(ui, source)
                 copy = False
                 if other.dev() != -1:
                     abspath = os.path.abspath(source)
                     if not opts['pull']:
                         copy = True
                 if copy:
                     try:
                         # we use a lock here because if we race with commit, we
                         # can end up with extra data in the cloned revlogs that's
                         # not pointed to by changesets, thus causing verify to
                         # fail
                         l1 = lock.lock(os.path.join(source, ".hg", "lock"))
                     except OSError:
                         copy = False
                 if copy:
                     # we lock here to avoid premature writing to the target
                     os.mkdir(os.path.join(dest, ".hg"))
                     l2 = lock.lock(os.path.join(dest, ".hg", "lock"))
                     files = "data 00manifest.d 00manifest.i 00changelog.d 00changelog.i"
                     for f in files.split():
                         src = os.path.join(source, ".hg", f)
                         dst = os.path.join(dest, ".hg", f)
                         util.copyfiles(src, dst)
                     repo = hg.repository(ui, dest)
                 else:
                     repo = hg.repository(ui, dest, create=1)
                     repo.pull(other)
                 f = repo.opener("hgrc", "w", text=True)
                 f.write("[paths]\n")
                 f.write("default = %s\n" % abspath)
                 if not opts['noupdate']:
                     update(ui, repo)
                 d.close()
             def commit(ui, repo, *pats, **opts):
                 """commit the specified files or all outstanding changes"""
                 if opts['text']:
                     ui.warn(_("Warning: -t and --text is deprecated,"
                               " please use -m or --message instead.\n"))
                 message = opts['message'] or opts['text']
                 logfile = opts['logfile']
                 if message and logfile:
                     raise util.Abort(_('options --message and --logfile are mutually '
                                        'exclusive'))
                 if not message and logfile:
                     try:
                         if logfile == '-':
                             message = sys.stdin.read()
                         else:
                             message = open(logfile).read()
                     except IOError, inst:
                         raise util.Abort(_("can't read commit message '%s': %s") %
                                          (logfile, inst.strerror))
                 if opts['addremove']:
                     addremove(ui, repo, *pats, **opts)
                 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']]
                 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 = []
                 try:
                     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:
                     raise util.Abort(_('no source or destination specified'))
                 elif len(pats) == 1:
                     raise util.Abort(_('no destination specified'))
                 pats = list(pats)
                 dest = pats.pop()
                 sources = []
                 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):
                     if okaytocopy(abs, rel, exact):
                         sources.append((abs, rel, exact))
                 if not sources:
                     raise util.Abort(_('no files to copy'))
                 cwd = repo.getcwd()
                 absdest = util.canonpath(repo.root, cwd, dest)
                 reldest = util.pathto(cwd, absdest)
                 if os.path.exists(reldest):
                     destisfile = not os.path.isdir(reldest)
                 else:
                     destisfile = len(sources) == 1 or repo.dirstate.state(absdest) != '?'
                 if destisfile:
                     if opts['parents']:
                         raise util.Abort(_('with --parents, destination must be a directory'))
                     elif len(sources) > 1:
                         raise util.Abort(_('with multiple sources, destination must be a '
                                            'directory'))
                 errs, copied = 0, []
                 for abs, rel, exact in sources:
                     if opts['parents']:
                         mydest = os.path.join(dest, rel)
                     elif destisfile:
                         mydest = reldest
                     else:
                         mydest = os.path.join(dest, os.path.basename(rel))
                     myabsdest = util.canonpath(repo.root, cwd, mydest)
                     myreldest = util.pathto(cwd, myabsdest)
                     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 opts['parents']: os.makedirs(mydestdir)
                             elif not destisfile: os.mkdir(mydestdir)
                         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)
                             else:
                                 ui.warn(_('%s: cannot copy - %s\n') % (rel, inst.strerror))
                             errs += 1
                             continue
                     repo.copy(abs, myabsdest)
                     copied.append((abs, rel, exact))
                 if errs:
                     ui.warn(_('(consider using --after)\n'))
                 return errs, copied
             def copy(ui, repo, *pats, **opts):
                 """mark files as copied for the next commit"""
                 errs, copied = docopy(ui, repo, pats, opts)
                 return errs
             def debugancestor(ui, index, rev1, rev2):
                 """find the ancestor revision of two revisions in a given index"""
                 r = revlog.revlog(file, index, "")
                 a = r.ancestor(r.lookup(rev1), r.lookup(rev2))
                 ui.write("%d:%s\n" % (r.rev(a), hex(a)))
             def debugcheckstate(ui, repo):
                 """validate the correctness of the current dirstate"""
                 parent1, parent2 = repo.dirstate.parents()
                 repo.dirstate.read()
                 dc = repo.dirstate.map
                 keys = dc.keys()
                 keys.sort()
                 m1n = repo.changelog.read(parent1)[0]
                 m2n = repo.changelog.read(parent2)[0]
                 m1 = repo.manifest.read(m1n)
                 m2 = repo.manifest.read(m2n)
                 errors = 0
                 for f in dc:
                     state = repo.dirstate.state(f)
                     if state in "nr" and f not in m1:
                         ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))
                         errors += 1
                     if state in "a" and f in m1:
                         ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))
                         errors += 1
                     if state in "m" and f not in m1 and f not in m2:
                         ui.warn(_("%s in state %s, but not in either manifest\n") %
                                 (f, state))
                         errors += 1
                 for f in m1:
                     state = repo.dirstate.state(f)
                     if state not in "nrm":
                         ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))
                         errors += 1
                 if errors:
                     raise util.Abort(_(".hg/dirstate inconsistent with current parent's manifest"))
             def debugconfig(ui):
                 """show combined config settings from all hgrc files"""
                 try:
                     repo = hg.repository(ui)
                 except hg.RepoError:
                     pass
                 for section, name, value in ui.walkconfig():
                     ui.write('%s.%s=%s\n' % (section, name, value))
             def debugsetparents(ui, repo, rev1, rev2=None):
                 """
                 manually set the parents of the current working directory
                 This is useful for writing repository conversion tools, but should
                 be used with care.
                 """
                 if not rev2:
                     rev2 = hex(nullid)
                 repo.dirstate.setparents(repo.lookup(rev1), repo.lookup(rev2))
             def debugstate(ui, repo):
                 """show the contents of the current dirstate"""
                 repo.dirstate.read()
                 dc = repo.dirstate.map
                 keys = dc.keys()
                 keys.sort()
                 for file_ in keys:
                     ui.write("%c %3o %10d %s %s\n"
                              % (dc[file_][0], dc[file_][1] & 0777, dc[file_][2],
                                 time.strftime("%x %X",
                                               time.localtime(dc[file_][3])), file_))
                 for f in repo.dirstate.copies:
                     ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copies[f], f))
             def debugdata(ui, file_, rev):
                 """dump the contents of an data file revision"""
                 r = revlog.revlog(file, file_[:-2] + ".i", file_)
                 try:
                     ui.write(r.revision(r.lookup(rev)))
                 except KeyError:
                     raise util.Abort(_('invalid revision identifier %s'), rev)
             def debugindex(ui, file_):
                 """dump the contents of an index file"""
                 r = revlog.revlog(file, file_, "")
                 ui.write("   rev    offset  length   base linkrev" +
                          " nodeid       p1           p2\n")
                 for i in range(r.count()):
                     e = r.index[i]
                     ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (
                             i, e[0], e[1], e[2], e[3],
                         short(e[6]), short(e[4]), short(e[5])))
             def debugindexdot(ui, file_):
                 """dump an index DAG as a .dot file"""
                 r = revlog.revlog(file, file_, "")
                 ui.write("digraph G {\n")
                 for i in range(r.count()):
                     e = r.index[i]
                     ui.write("\t%d -> %d\n" % (r.rev(e[4]), i))
                     if e[5] != nullid:
                         ui.write("\t%d -> %d\n" % (r.rev(e[5]), i))
                 ui.write("}\n")
             def debugrename(ui, repo, file, rev=None):
                 """dump rename information"""
                 r = repo.file(relpath(repo, [file])[0])
                 if rev:
                     try:
                         # 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:
                         n = r.lookup(rev)
                 else:
                     n = r.tip()
                 m = r.renamed(n)
                 if m:
                     ui.write(_("renamed from %s:%s\n") % (m[0], hex(m[1])))
                 else:
                     ui.write(_("not renamed\n"))
             def debugwalk(ui, repo, *pats, **opts):
                 """show how files match on given patterns"""
                 items = list(walk(repo, pats, opts))
                 if not items:
                     return
                 fmt = '%%s  %%-%ds  %%-%ds  %%s' % (
                     max([len(abs) for (src, abs, rel, exact) in items]),
                     max([len(rel) for (src, abs, rel, exact) in items]))
                 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)"""
                 node1, node2 = None, None
                 revs = [repo.lookup(x) for x in opts['rev']]
                 if len(revs) > 0:
                     node1 = revs[0]
                 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)
                 dodiff(sys.stdout, ui, repo, node1, node2, fns, match=matchfn,
                        text=opts['text'])
             def doexport(ui, repo, changeset, seqno, total, revwidth, opts):
                 node = repo.lookup(changeset)
                 prev, other = repo.changelog.parents(node)
                 change = repo.changelog.read(node)
                 fp = make_file(repo, repo.changelog, opts['output'],
                                node=node, total=total, seqno=seqno,
                                revwidth=revwidth)
                 if fp != sys.stdout:
                     ui.note("%s\n" % fp.name)
                 fp.write("# HG changeset patch\n")
                 fp.write("# User %s\n" % change[1])
                 fp.write("# Node ID %s\n" % hex(node))
                 fp.write("# Parent  %s\n" % hex(prev))
                 if other != nullid:
                     fp.write("# Parent  %s\n" % hex(other))
                 fp.write(change[4].rstrip())
                 fp.write("\n\n")
                 dodiff(fp, ui, repo, prev, node, text=opts['text'])
                 if fp != sys.stdout:
                     fp.close()
             def export(ui, repo, *changesets, **opts):
                 """dump the header and diffs for one or more changesets"""
                 if not changesets:
                     raise util.Abort(_("export requires at least one changeset"))
                 seqno = 0
                 revs = list(revrange(ui, repo, changesets))
                 total = len(revs)
                 revwidth = max(map(len, revs))
                 ui.note(len(revs) > 1 and _("Exporting patches:\n") or _("Exporting patch:\n"))
                 for cset in revs:
                     seqno += 1
                     doexport(ui, repo, cset, seqno, total, revwidth, opts)
             def forget(ui, repo, *pats, **opts):
                 """don't add the specified files on the next commit"""
                 forget = []
                 for src, abs, rel, exact in walk(repo, pats, opts):
                     if repo.dirstate.state(abs) == 'a':
                         forget.append(abs)
                         if ui.verbose or not exact:
                             ui.status(_('forgetting %s\n') % rel)
                 repo.forget(forget)
             def grep(ui, repo, pattern, *pats, **opts):
                 """search for a pattern in specified files and revisions"""
                 reflags = 0
                 if opts['ignore_case']:
                     reflags |= re.I
                 regexp = re.compile(pattern, reflags)
                 sep, eol = ':', '\n'
                 if opts['print0']:
                     sep = eol = '\0'
                 fcache = {}
                 def getfile(fn):
                     if fn not in fcache:
                         fcache[fn] = repo.file(fn)
                     return fcache[fn]
                 def matchlines(body):
                     begin = 0
                     linenum = 0
                     while True:
                         match = regexp.search(body, begin)
                         if not match:
                             break
                         mstart, mend = match.span()
                         linenum += body.count('\n', begin, mstart) + 1
                         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:
                     def __init__(self, line, linenum, colstart, colend):
                         self.line = line
                         self.linenum = linenum
                         self.colstart = colstart
                         self.colend = colend
                     def __eq__(self, other):
                         return self.line == other.line
                     def __hash__(self):
                         return hash(self.line)
                 matches = {}
                 def grepbody(fn, rev, body):
                     matches[rev].setdefault(fn, {})
                     m = matches[rev][fn]
                     for lnum, cstart, cend, line in matchlines(body):
                         s = linestate(line, lnum, cstart, cend)
                         m[s] = s
                 prev = {}
                 ucache = {}
                 def display(fn, rev, states, prevstates):
                     diff = list(sets.Set(states).symmetric_difference(sets.Set(prevstates)))
                     diff.sort(lambda x, y: cmp(x.linenum, y.linenum))
                     counts = {'-': 0, '+': 0}
                     filerevmatches = {}
                     for l in diff:
                         if incrementing or not opts['all']:
                             change = ((l in prevstates) and '-') or '+'
                             r = rev
                         else:
                             change = ((l in states) and '-') or '+'
                             r = prev[fn]
                         cols = [fn, str(rev)]
                         if opts['line_number']: cols.append(str(l.linenum))
                         if opts['all']: cols.append(change)
                         if opts['user']: cols.append(trimuser(ui, getchange(rev)[1], rev,
                                                               ucache))
                         if opts['files_with_matches']:
                             c = (fn, rev)
                             if c in filerevmatches: continue
                             filerevmatches[c] = 1
                         else:
                             cols.append(l.line)
                         ui.write(sep.join(cols), eol)
                         counts[change] += 1
                     return counts['+'], counts['-']
                 fstate = {}
                 skip = {}
                 changeiter, getchange = walkchangerevs(ui, repo, repo.getcwd(), pats, opts)
                 count = 0
                 incrementing = False
                 for st, rev, fns in changeiter:
                     if st == 'window':
                         incrementing = rev
                         matches.clear()
                     elif st == 'add':
                         change = repo.changelog.read(repo.lookup(str(rev)))
                         mf = repo.manifest.read(change[0])
                         matches[rev] = {}
                         for fn in fns:
                             if fn in skip: continue
                             fstate.setdefault(fn, {})
                             try:
                                 grepbody(fn, rev, getfile(fn).read(mf[fn]))
                             except KeyError:
                                 pass
                     elif st == 'iter':
                         states = matches[rev].items()
                         states.sort()
                         for fn, m in states:
                             if fn in skip: continue
                             if incrementing or not opts['all'] or fstate[fn]:
                                 pos, neg = display(fn, rev, m, fstate[fn])
                                 count += pos + neg
                                 if pos and not opts['all']:
                                     skip[fn] = True
                             fstate[fn] = m
                             prev[fn] = rev
                 if not incrementing:
                     fstate = fstate.items()
                     fstate.sort()
                     for fn, state in fstate:
                         if fn in skip: continue
                         display(fn, rev, {}, state)
                 return (count == 0 and 1) or 0
             def heads(ui, repo, **opts):
                 """show current repository heads"""
                 heads = repo.changelog.heads()
                 br = None
                 if opts['branches']:
                     br = repo.branchlookup(heads)
                 for n in repo.changelog.heads():
                     show_changeset(ui, repo, changenode=n, brinfo=br)
             def identify(ui, repo):
                 """print information about the working copy"""
                 parents = [p for p in repo.dirstate.parents() if p != nullid]
                 if not parents:
                     ui.write(_("unknown\n"))
                     return
                 hexfunc = ui.verbose and hex or short
                 (c, a, d, u) = repo.changes()
                 output = ["%s%s" % ('+'.join([hexfunc(parent) for parent in parents]),
                                     (c or a or d) and "+" or "")]
                 if not ui.quiet:
                     # multiple tags for a single parent separated by '/'
                     parenttags = ['/'.join(tags)
                                   for tags in map(repo.nodetags, parents) if tags]
                     # tags for multiple parents separated by ' + '
                     if parenttags:
                         output.append(' + '.join(parenttags))
                 ui.write("%s\n" % ' '.join(output))
             def import_(ui, repo, patch1, *patches, **opts):
                 """import an ordered set of patches"""
                 patches = (patch1,) + patches
                 if not opts['force']:
                     (c, a, d, u) = repo.changes()
                     if c or a or d:
                         raise util.Abort(_("outstanding uncommitted changes"))
                 d = opts["base"]
                 strip = opts["strip"]
                 mailre = re.compile(r'(?:From |[\w-]+:)')
                 # attempt to detect the start of a patch
                 # (this heuristic is borrowed from quilt)
                 diffre = re.compile(r'(?:Index:[ \t]|diff[ \t]|RCS file: |' +
                                     'retrieving revision [0-9]+(\.[0-9]+)*$|' +
                                     '(---|\*\*\*)[ \t])')
                 for patch in patches:
                     ui.status(_("applying %s\n") % patch)
                     pf = os.path.join(d, patch)
                     message = []
                     user = None
                     hgpatch = False
                     for line in file(pf):
                         line = line.rstrip()
                         if (not message and not hgpatch and
                                mailre.match(line) and not opts['force']):
                             if len(line) > 35: line = line[:32] + '...'
                             raise util.Abort(_('first line looks like a '
                                                'mail header: ') + line)
                         if diffre.match(line):
                             break
                         elif hgpatch:
                             # parse values when importing the result of an hg export
                             if line.startswith("# User "):
                                 user = line[7:]
                                 ui.debug(_('User: %s\n') % user)
                             elif not line.startswith("# ") and line:
                                 message.append(line)
                                 hgpatch = False
                         elif line == '# HG changeset patch':
                             hgpatch = True
                             message = []       # We may have collected garbage
                         else:
                             message.append(line)
                     # make sure message isn't empty
                     if not message:
                         message = _("imported patch %s\n") % patch
                     else:
                         message = "%s\n" % '\n'.join(message)
                     ui.debug(_('message:\n%s\n') % message)
                     files = util.patch(strip, pf, ui)
                     if len(files) > 0:
                         addremove(ui, repo, *files)
                     repo.commit(files, message, user)
             def incoming(ui, repo, source="default", **opts):
                 """show new changesets found in source"""
                 source = ui.expandpath(source)
                 other = hg.repository(ui, source)
                 if not other.local():
                     raise util.Abort(_("incoming doesn't work for remote repositories yet"))
                 o = repo.findincoming(other)
                 if not o:
                     return
                 o = other.newer(o)
                 for n in o:
                     show_changeset(ui, other, changenode=n)
                     if opts['patch']:
                         prev = other.changelog.parents(n)[0]
                         dodiff(ui, ui, other, prev, n)
                         ui.write("\n")
             def init(ui, dest="."):
                 """create a new repository in the given directory"""
                 if not os.path.exists(dest):
                     os.mkdir(dest)
                 hg.repository(ui, dest, create=1)
             def locate(ui, repo, *pats, **opts):
                 """locate files matching specific patterns"""
                 end = opts['print0'] and '\0' or '\n'
                 for src, abs, rel, exact in walk(repo, pats, opts, '(?:.*/|)'):
                     if repo.dirstate.state(abs) == '?':
                         continue
                     if opts['fullpath']:
                         ui.write(os.path.join(repo.root, abs), end)
                     else:
                         ui.write(rel, end)
             def log(ui, repo, *pats, **opts):
                 """show revision history of entire repository or files"""
                 class dui:
                     # 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 bump(self, rev):
                         self.rev = rev
                         self.hunk[rev] = []
                     def note(self, *args):
                         if self.verbose:
                             self.write(*args)
                     def status(self, *args):
                         if not self.quiet:
                             self.write(*args)
                     def write(self, *args):
                         self.hunk[self.rev].append(args)
                     def debug(self, *args):
                         if self.debugflag:
                             self.write(*args)
                     def __getattr__(self, key):
                         return getattr(self.ui, key)
                 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']]
                 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)
                         br = None
                         if opts['keyword']:
                             changes = repo.changelog.read(repo.changelog.node(rev))
                             miss = 0
                             for k in [kw.lower() for kw in opts['keyword']]:
                                 if not (k in changes[1].lower() or
                                         k in changes[4].lower() or
                                         k in " ".join(changes[3][:20]).lower()):
                                     miss = 1
                                     break
                             if miss:
                                 continue
                         if opts['branch']:
                             br = repo.branchlookup([repo.changelog.node(rev)])
                         show_changeset(du, repo, rev, brinfo=br)
                         if opts['patch']:
                             changenode = repo.changelog.node(rev)
                             prev, other = repo.changelog.parents(changenode)
                             dodiff(du, du, repo, prev, changenode, fns)
                             du.write("\n\n")
                     elif st == 'iter':
                         for args in du.hunk[rev]:
                             ui.write(*args)
             def manifest(ui, repo, rev=None):
                 """output the latest or given revision of the project manifest"""
                 if rev:
                     try:
                         # assume all revision numbers are for changesets
                         n = repo.lookup(rev)
                         change = repo.changelog.read(n)
                         n = change[0]
                     except hg.RepoError:
                         n = repo.manifest.lookup(rev)
                 else:
                     n = repo.manifest.tip()
                 m = repo.manifest.read(n)
                 mf = repo.manifest.readflags(n)
                 files = m.keys()
                 files.sort()
                 for f in files:
                     ui.write("%40s %3s %s\n" % (hex(m[f]), mf[f] and "755" or "644", f))
             def outgoing(ui, repo, dest="default-push", **opts):
                 """show changesets not found in destination"""
                 dest = ui.expandpath(dest)
                 other = hg.repository(ui, dest)
                 o = repo.findoutgoing(other)
                 o = repo.newer(o)
                 for n in o:
                     show_changeset(ui, repo, changenode=n)
                     if opts['patch']:
                         prev = repo.changelog.parents(n)[0]
                         dodiff(ui, ui, repo, prev, n)
                         ui.write("\n")
             def parents(ui, repo, rev=None):
                 """show the parents of the working dir or revision"""
                 if rev:
                     p = repo.changelog.parents(repo.lookup(rev))
                 else:
                     p = repo.dirstate.parents()
                 for n in p:
                     if n != nullid:
                         show_changeset(ui, repo, changenode=n)
             def paths(ui, search=None):
                 """show definition of symbolic path names"""
                 try:
                     repo = hg.repository(ui=ui)
                 except hg.RepoError:
                     pass
                 if search:
                     for name, path in ui.configitems("paths"):
                         if name == search:
                             ui.write("%s\n" % path)
                             return
                     ui.warn(_("not found!\n"))
                     return 1
                 else:
                     for name, path in ui.configitems("paths"):
                         ui.write("%s = %s\n" % (name, path))
             def pull(ui, repo, source="default", **opts):
                 """pull changes from the specified source"""
                 source = ui.expandpath(source)
                 ui.status(_('pulling from %s\n') % (source))
                 if opts['ssh']:
                     ui.setconfig("ui", "ssh", opts['ssh'])
                 if opts['remotecmd']:
                     ui.setconfig("ui", "remotecmd", opts['remotecmd'])
                 other = hg.repository(ui, source)
                 r = repo.pull(other)
                 if not r:
                     if opts['update']:
                         return update(ui, repo)
                     else:
                         ui.status(_("(run 'hg update' to get a working copy)\n"))
                 return r
             def push(ui, repo, dest="default-push", force=False, ssh=None, remotecmd=None):
                 """push changes to the specified destination"""
                 dest = ui.expandpath(dest)
                 ui.status('pushing to %s\n' % (dest))
                 if ssh:
                     ui.setconfig("ui", "ssh", ssh)
                 if remotecmd:
                     ui.setconfig("ui", "remotecmd", remotecmd)
                 other = hg.repository(ui, dest)
                 r = repo.push(other, force)
                 return r
             def rawcommit(ui, repo, *flist, **rc):
                 "raw commit interface"
                 if rc['text']:
                     ui.warn(_("Warning: -t and --text is deprecated,"
                               " please use -m or --message instead.\n"))
                 message = rc['message'] or rc['text']
                 if not message and rc['logfile']:
                     try:
                         message = open(rc['logfile']).read()
                     except IOError:
                         pass
                 if not message and not rc['logfile']:
                     raise util.Abort(_("missing commit message"))
                 files = relpath(repo, list(flist))
                 if rc['files']:
                     files += open(rc['files']).read().splitlines()
                 rc['parent'] = map(repo.lookup, rc['parent'])
                 try:
                     repo.rawcommit(files, message, rc['user'], rc['date'], *rc['parent'])
                 except ValueError, inst:
                     raise util.Abort(str(inst))
             def recover(ui, repo):
                 """roll back an interrupted transaction"""
                 repo.recover()
             def remove(ui, repo, pat, *pats, **opts):
                 """remove the specified files on the next commit"""
                 names = []
                 def okaytoremove(abs, rel, exact):
                     c, a, d, u = repo.changes(files = [abs])
                     reason = None
                     if c: reason = _('is modified')
                     elif a: reason = _('has been marked for add')
                     elif u: reason = _('is not managed')
                     if reason:
                         if exact: ui.warn(_('not removing %s: file %s\n') % (rel, reason))
                     else:
                         return True
                 for src, abs, rel, exact in walk(repo, (pat,) + pats, opts):
                     if okaytoremove(abs, rel, exact):
                         if ui.verbose or not exact: ui.status(_('removing %s\n') % rel)
                         names.append(abs)
                 for name in names:
                     try:
                         os.unlink(name)
                     except OSError, inst:
                         if inst.errno != errno.ENOENT: raise
                 repo.remove(names)
             def rename(ui, repo, *pats, **opts):
                 """rename files; equivalent of copy + remove"""
                 errs, copied = docopy(ui, repo, pats, opts)
                 names = []
                 for abs, rel, exact in copied:
                     if ui.verbose or not exact: ui.status(_('removing %s\n') % rel)
                     try:
                         os.unlink(rel)
                     except OSError, inst:
                         if inst.errno != errno.ENOENT: raise
                     names.append(abs)
                 repo.remove(names)
                 return errs
             def revert(ui, repo, *names, **opts):
                 """revert modified files or dirs back to their unmodified states"""
                 node = opts['rev'] and repo.lookup(opts['rev']) or \
                        repo.dirstate.parents()[0]
                 root = os.path.realpath(repo.root)
                 def trimpath(p):
                     p = os.path.realpath(p)
                     if p.startswith(root):
                         rest = p[len(root):]
                         if not rest:
                             return rest
                         if p.startswith(os.sep):
                             return rest[1:]
                         return p
                 relnames = map(trimpath, names or [os.getcwd()])
                 chosen = {}
                 def choose(name):
                     def body(name):
                         for r in relnames:
                             if not name.startswith(r):
                                 continue
                             rest = name[len(r):]
                             if not rest:
                                 return r, True
                             depth = rest.count(os.sep)
                             if not r:
                                 if depth == 0 or not opts['nonrecursive']:
                                     return r, True
                             elif rest[0] == os.sep:
                                 if depth == 1 or not opts['nonrecursive']:
                                     return r, True
                         return None, False
                     relname, ret = body(name)
                     if ret:
                         chosen[relname] = 1
                     return ret
                 r = repo.update(node, False, True, choose, False)
                 for n in relnames:
                     if n not in chosen:
                         ui.warn(_('error: no matches for %s\n') % n)
                         r = 1
                 sys.stdout.flush()
                 return r
             def root(ui, repo):
                 """print the root (top) of the current working dir"""
                 ui.write(repo.root + "\n")
             def serve(ui, repo, **opts):
                 """export the repository via HTTP"""
                 if opts["stdio"]:
                     fin, fout = sys.stdin, sys.stdout
                     sys.stdout = sys.stderr
                     def getarg():
                         argline = fin.readline()[:-1]
                         arg, l = argline.split()
                         val = fin.read(int(l))
                         return arg, val
                     def respond(v):
                         fout.write("%d\n" % len(v))
                         fout.write(v)
                         fout.flush()
                     lock = None
                     while 1:
                         cmd = fin.readline()[:-1]
                         if cmd == '':
                             return
                         if cmd == "heads":
                             h = repo.heads()
                             respond(" ".join(map(hex, h)) + "\n")
                         if cmd == "lock":
                             lock = repo.lock()
                             respond("")
                         if cmd == "unlock":
                             if lock:
                                 lock.release()
                             lock = None
                             respond("")
                         elif cmd == "branches":
                             arg, nodes = getarg()
                             nodes = map(bin, nodes.split(" "))
                             r = []
                             for b in repo.branches(nodes):
                                 r.append(" ".join(map(hex, b)) + "\n")
                             respond("".join(r))
                         elif cmd == "between":
                             arg, pairs = getarg()
                             pairs = [map(bin, p.split("-")) for p in pairs.split(" ")]
                             r = []
                             for b in repo.between(pairs):
                                 r.append(" ".join(map(hex, b)) + "\n")
                             respond("".join(r))
                         elif cmd == "changegroup":
                             nodes = []
                             arg, roots = getarg()
                             nodes = map(bin, roots.split(" "))
                             cg = repo.changegroup(nodes)
                             while 1:
                                 d = cg.read(4096)
                                 if not d:
                                     break
                                 fout.write(d)
                             fout.flush()
                         elif cmd == "addchangegroup":
                             if not lock:
                                 respond("not locked")
                                 continue
                             respond("")
                             r = repo.addchangegroup(fin)
                             respond("")
                 optlist = "name templates style address port ipv6 accesslog errorlog"
                 for o in optlist.split():
                     if opts[o]:
                         ui.setconfig("web", o, opts[o])
                 try:
                     httpd = hgweb.create_server(repo)
                 except socket.error, inst:
                     raise util.Abort('cannot start server: ' + inst.args[1])
                 if ui.verbose:
                     addr, port = httpd.socket.getsockname()
                     if addr == '0.0.0.0':
                         addr = socket.gethostname()
                     else:
                         try:
                             addr = socket.gethostbyaddr(addr)[0]
                         except socket.error:
                             pass
                     if port != 80:
                         ui.status(_('listening at http://%s:%d/\n') % (addr, port))
                     else:
                         ui.status(_('listening at http://%s/\n') % addr)
                 httpd.serve_forever()
             def status(ui, repo, *pats, **opts):
                 '''show changed files in the working directory
                 M = modified
                 A = added
                 R = removed
                 ? = not tracked
                 '''
                 cwd = repo.getcwd()
                 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),
                                (_('removed'), 'R', d),
                                (_('unknown'), '?', u)]
                 end = opts['print0'] and '\0' or '\n'
                 for opt, char, changes in ([ct for ct in changetypes if opts[ct[0]]]
                                            or changetypes):
                     if opts['no_status']:
                         format = "%%s%s" % end
                     else:
                         format = "%s %%s%s" % (char, end);
                     for f in changes:
                         ui.write(format % f)
             def tag(ui, repo, name, rev=None, **opts):
                 """add a tag for the current tip or a given revision"""
                 if opts['text']:
                     ui.warn(_("Warning: -t and --text is deprecated,"
                               " please use -m or --message instead.\n"))
                 if name == "tip":
                     raise util.Abort(_("the name 'tip' is reserved"))
                 if rev:
                     r = hex(repo.lookup(rev))
                 else:
                     r = hex(repo.changelog.tip())
                 if name.find(revrangesep) >= 0:
                     raise util.Abort(_("'%s' cannot be used in a tag name") % revrangesep)
                 if opts['local']:
                     repo.opener("localtags", "a").write("%s %s\n" % (r, name))
                     return
                 (c, a, d, u) = repo.changes()
                 for x in (c, a, d, u):
                     if ".hgtags" in x:
                         raise util.Abort(_("working copy of .hgtags is changed "
                                            "(please commit .hgtags manually)"))
                 repo.wfile(".hgtags", "ab").write("%s %s\n" % (r, name))
                 if repo.dirstate.state(".hgtags") == '?':
                     repo.add([".hgtags"])
                 message = (opts['message'] or opts['text'] or
                            _("Added tag %s for changeset %s") % (name, r))
                 try:
                     repo.commit([".hgtags"], message, opts['user'], opts['date'])
                 except ValueError, inst:
                     raise util.Abort(str(inst))
             def tags(ui, repo):
                 """list repository tags"""
                 l = repo.tagslist()
                 l.reverse()
                 for t, n in l:
                     try:
                         r = "%5d:%s" % (repo.changelog.rev(n), hex(n))
                     except KeyError:
                         r = "    ?:?"
                     ui.write("%-30s %s\n" % (t, r))
             def tip(ui, repo):
                 """show the tip revision"""
                 n = repo.changelog.tip()
                 show_changeset(ui, repo, changenode=n)
             def unbundle(ui, repo, fname):
                 """apply a changegroup file"""
                 f = urllib.urlopen(fname)
                 if f.read(4) != "HG10":
                     raise util.Abort(_("%s: not a Mercurial bundle file") % fname)
                 def bzgenerator(f):
                     zd = bz2.BZ2Decompressor()
                     for chunk in f:
                         yield zd.decompress(chunk)
                     yield zd.flush()
                 bzgen = bzgenerator(util.filechunkiter(f, 4096))
                 repo.addchangegroup(util.chunkbuffer(bzgen))
             def undo(ui, repo):
                 """undo the last commit or pull
                 Roll back the last pull or commit transaction on the
                 repository, restoring the project to its earlier state.
                 This command should be used with care. There is only one level of
                 undo and there is no redo.
                 This command is not intended for use on public repositories. Once
                 a change is visible for pull by other users, undoing it locally is
                 ineffective.
                 """
                 repo.undo()
             def update(ui, repo, node=None, merge=False, clean=False, branch=None):
                 '''update or merge working directory
                 If there are no outstanding changes in the working directory and
                 there is a linear relationship between the current version and the
                 requested version, the result is the requested version.
                 Otherwise the result is a merge between the contents of the
                 current working directory and the requested version. Files that
                 changed between either parent are marked as changed for the next
                 commit and a commit must be performed before any further updates
                 are allowed.
                 '''
                 if branch:
                     br = repo.branchlookup(branch=branch)
                     found = []
                     for x in br:
                         if branch in br[x]:
                             found.append(x)
                     if len(found) > 1:
                         ui.warn(_("Found multiple heads for %s\n") % branch)
                         for x in found:
                             show_changeset(ui, repo, changenode=x, brinfo=br)
                         return 1
                     if len(found) == 1:
                         node = found[0]
                         ui.warn(_("Using head %s for branch %s\n") % (short(node), branch))
                     else:
                         ui.warn(_("branch %s not found\n") % (branch))
                         return 1
                 else:
                     node = node and repo.lookup(node) or repo.changelog.tip()
                 return repo.update(node, allow=merge, force=clean)
             def verify(ui, repo):
                 """verify the integrity of the repository"""
                 return repo.verify()
             # Command options and aliases are listed here, alphabetically
             table = {
                 "^add":
                     (add,
                      [('I', 'include', [], _('include path in search')),
                       ('X', 'exclude', [], _('exclude path from search'))],
                      "hg add [OPTION]... [FILE]..."),
                 "addremove":
                     (addremove,
                      [('I', 'include', [], _('include path in search')),
                       ('X', 'exclude', [], _('exclude path from search'))],
                      _("hg addremove [OPTION]... [FILE]...")),
                 "^annotate":
                     (annotate,
                      [('r', 'rev', '', _('revision')),
                       ('a', 'text', None, _('treat all files as text')),
                       ('u', 'user', None, _('show user')),
                       ('n', 'number', None, _('show revision number')),
                       ('c', 'changeset', None, _('show changeset')),
                       ('I', 'include', [], _('include path in search')),
                       ('X', 'exclude', [], _('exclude path from search'))],
                      _('hg annotate [OPTION]... FILE...')),
                 "bundle":
                     (bundle,
                      [],
                      _('hg bundle FILE DEST')),
                 "cat":
                     (cat,
                      [('I', 'include', [], _('include path in search')),
                       ('X', 'exclude', [], _('exclude path from search')),
                       ('o', 'output', "", _('output to file')),
                       ('r', 'rev', '', _('revision'))],
                      _('hg cat [OPTION]... FILE...')),
                 "^clone":
                     (clone,
                      [('U', 'noupdate', None, _('skip update after cloning')),
                       ('e', 'ssh', "", _('ssh command')),
                       ('', 'pull', None, _('use pull protocol to copy metadata')),
                       ('', 'remotecmd', "", _('remote hg command'))],
                      _('hg clone [OPTION]... SOURCE [DEST]')),
                 "^commit|ci":
                     (commit,
                      [('A', 'addremove', None, _('run add/remove during commit')),
                       ('I', 'include', [], _('include path in search')),
                       ('X', 'exclude', [], _('exclude path from search')),
                       ('m', 'message', "", _('commit message')),
                       ('t', 'text', "", _('commit message (deprecated: use -m)')),
                       ('l', 'logfile', "", _('commit message file')),
                       ('d', 'date', "", _('date code')),
                       ('u', 'user', "", _('user'))],
                      _('hg commit [OPTION]... [FILE]...')),
                 "copy|cp": (copy,
                          [('I', 'include', [], _('include path in search')),
                           ('X', 'exclude', [], _('exclude path from search')),
                           ('A', 'after', None, _('record a copy after it has happened')),
                           ('f', 'force', None, _('replace destination if it exists')),
                           ('p', 'parents', None, _('append source path to dest'))],
                          _('hg copy [OPTION]... [SOURCE]... DEST')),
                 "debugancestor": (debugancestor, [], _('debugancestor INDEX REV1 REV2')),
                 "debugcheckstate": (debugcheckstate, [], _('debugcheckstate')),
                 "debugconfig": (debugconfig, [], _('debugconfig')),
                 "debugsetparents": (debugsetparents, [], _('debugsetparents REV1 [REV2]')),
                 "debugstate": (debugstate, [], _('debugstate')),
                 "debugdata": (debugdata, [], _('debugdata FILE REV')),
                 "debugindex": (debugindex, [], _('debugindex FILE')),
                 "debugindexdot": (debugindexdot, [], _('debugindexdot FILE')),
                 "debugrename": (debugrename, [], _('debugrename FILE [REV]')),
                 "debugwalk":
                     (debugwalk,
                      [('I', 'include', [], _('include path in search')),
                       ('X', 'exclude', [], _('exclude path from search'))],
                      _('debugwalk [OPTION]... [FILE]...')),
                 "^diff":
                     (diff,
                      [('r', 'rev', [], _('revision')),
                       ('a', 'text', None, _('treat all files as text')),
                       ('I', 'include', [], _('include path in search')),
                       ('X', 'exclude', [], _('exclude path from search'))],
                      _('hg diff [-a] [-I] [-X] [-r REV1 [-r REV2]] [FILE]...')),
                 "^export":
                     (export,
                      [('o', 'output', "", _('output to file')),
                       ('a', 'text', None, _('treat all files as text'))],
                      _("hg export [-a] [-o OUTFILE] REV...")),
                 "forget":
                     (forget,
                      [('I', 'include', [], _('include path in search')),
                       ('X', 'exclude', [], _('exclude path from search'))],
                      _("hg forget [OPTION]... FILE...")),
                 "grep":
                     (grep,
                      [('0', 'print0', None, _('end fields with NUL')),
                       ('I', 'include', [], _('include path in search')),
                       ('X', 'exclude', [], _('include path in search')),
                       ('', 'all', None, _('print all revisions with matches')),
                       ('i', 'ignore-case', None, _('ignore case when matching')),
                       ('l', 'files-with-matches', None, _('print names of files and revs with matches')),
                       ('n', 'line-number', None, _('print line numbers')),
                       ('r', 'rev', [], _('search in revision rev')),
                       ('u', 'user', None, _('print user who made change'))],
                      _("hg grep [OPTION]... PATTERN [FILE]...")),
                 "heads":
                     (heads,
                      [('b', 'branches', None, _('find branch info'))],
                      _('hg heads [-b]')),
                 "help": (help_, [], _('hg help [COMMAND]')),
                 "identify|id": (identify, [], _('hg identify')),
                 "import|patch":
                     (import_,
                      [('p', 'strip', 1, _('path strip')),
                       ('f', 'force', None, _('skip check for outstanding changes')),
                       ('b', 'base', "", _('base path'))],
                      _("hg import [-f] [-p NUM] [-b BASE] PATCH...")),
                 "incoming|in": (incoming,
                      [('p', 'patch', None, _('show patch'))],
                      _('hg incoming [-p] [SOURCE]')),
                 "^init": (init, [], _('hg init [DEST]')),
                 "locate":
                     (locate,
                      [('r', 'rev', '', _('revision')),
                       ('0', 'print0', None, _('end filenames with NUL')),
                       ('f', 'fullpath', None, _('print complete paths')),
                       ('I', 'include', [], _('include path in search')),
                       ('X', 'exclude', [], _('exclude path from search'))],
                      _('hg locate [OPTION]... [PATTERN]...')),
                 "^log|history":
                     (log,
                      [('I', 'include', [], _('include path in search')),
                       ('X', 'exclude', [], _('exclude path from search')),
                       ('b', 'branch', None, _('show branches')),
                       ('k', 'keyword', [], _('search for a keyword')),
                       ('r', 'rev', [], _('revision')),
                       ('p', 'patch', None, _('show patch'))],
                      _('hg log [-I] [-X] [-r REV]... [-p] [FILE]')),
                 "manifest": (manifest, [], _('hg manifest [REV]')),
                 "outgoing|out": (outgoing,
                      [('p', 'patch', None, _('show patch'))],
                      _('hg outgoing [-p] [DEST]')),
                 "parents": (parents, [], _('hg parents [REV]')),
                 "paths": (paths, [], _('hg paths [NAME]')),
                 "^pull":
                     (pull,
                      [('u', 'update', None, _('update working directory')),
                       ('e', 'ssh', "", _('ssh command')),
                       ('', 'remotecmd', "", _('remote hg command'))],
                      _('hg pull [-u] [-e FILE] [--remotecmd FILE] [SOURCE]')),
                 "^push":
                     (push,
                      [('f', 'force', None, _('force push')),
                       ('e', 'ssh', "", _('ssh command')),
                       ('', 'remotecmd', "", _('remote hg command'))],
                      _('hg push [-f] [-e FILE] [--remotecmd FILE] [DEST]')),
                 "rawcommit":
                     (rawcommit,
                      [('p', 'parent', [], _('parent')),
                       ('d', 'date', "", _('date code')),
                       ('u', 'user', "", _('user')),
                       ('F', 'files', "", _('file list')),
                       ('m', 'message', "", _('commit message')),
                       ('t', 'text', "", _('commit message (deprecated: use -m)')),
                       ('l', 'logfile', "", _('commit message file'))],
                      _('hg rawcommit [OPTION]... [FILE]...')),
                 "recover": (recover, [], _("hg recover")),
                 "^remove|rm": (remove,
                                [('I', 'include', [], _('include path in search')),
                                 ('X', 'exclude', [], _('exclude path from search'))],
                                _("hg remove [OPTION]... FILE...")),
                 "rename|mv": (rename,
                               [('I', 'include', [], _('include path in search')),
                                ('X', 'exclude', [], _('exclude path from search')),
                                ('A', 'after', None, _('record a copy after it has happened')),
                                ('f', 'force', None, _('replace destination if it exists')),
                                ('p', 'parents', None, _('append source path to dest'))],
                               _('hg rename [OPTION]... [SOURCE]... DEST')),
                 "^revert":
                     (revert,
                      [("n", "nonrecursive", None, _("don't recurse into subdirs")),
                       ("r", "rev", "", _("revision"))],
                      _("hg revert [-n] [-r REV] [NAME]...")),
                 "root": (root, [], _("hg root")),
                 "^serve":
                     (serve,
                      [('A', 'accesslog', '', _('access log file')),
                       ('E', 'errorlog', '', _('error log file')),
                       ('p', 'port', 0, _('listen port')),
                       ('a', 'address', '', _('interface address')),
                       ('n', 'name', "", _('repository name')),
                       ('', 'stdio', None, _('for remote clients')),
                       ('t', 'templates', "", _('template directory')),
                       ('', 'style', "", _('template style')),
                       ('6', 'ipv6', None, _('use IPv6 in addition to IPv4'))],
                      _("hg serve [OPTION]...")),
                 "^status":
                     (status,
                      [('m', 'modified', None, _('show only modified files')),
                       ('a', 'added', None, _('show only added files')),
                       ('r', 'removed', None, _('show only removed files')),
                       ('u', 'unknown', None, _('show only unknown (not tracked) files')),
                       ('n', 'no-status', None, _('hide status prefix')),
                       ('0', 'print0', None, _('end filenames with NUL')),
                       ('I', 'include', [], _('include path in search')),
                       ('X', 'exclude', [], _('exclude path from search'))],
                      _("hg status [OPTION]... [FILE]...")),
                 "tag":
                     (tag,
                      [('l', 'local', None, _('make the tag local')),
                       ('m', 'message', "", _('commit message')),
                       ('t', 'text', "", _('commit message (deprecated: use -m)')),
                       ('d', 'date', "", _('date code')),
                       ('u', 'user', "", _('user'))],
                      _('hg tag [OPTION]... NAME [REV]')),
                 "tags": (tags, [], _('hg tags')),
                 "tip": (tip, [], _('hg tip')),
                 "unbundle":
                     (unbundle,
                      [],
                      _('hg unbundle FILE')),
                 "undo": (undo, [], _('hg undo')),
                 "^update|up|checkout|co":
                     (update,
                      [('b', 'branch', "", _('checkout the head of a specific branch')),
                       ('m', 'merge', None, _('allow merging of conflicts')),
                       ('C', 'clean', None, _('overwrite locally modified files'))],
                      _('hg update [-b TAG] [-m] [-C] [REV]')),
                 "verify": (verify, [], _('hg verify')),
                 "version": (show_version, [], _('hg version')),
             }
             globalopts = [
                 ('R', 'repository', "", _('repository root directory')),
                 ('', 'cwd', '', _('change working directory')),
                 ('y', 'noninteractive', None, _('run non-interactively')),
                 ('q', 'quiet', None, _('quiet mode')),
                 ('v', 'verbose', None, _('verbose mode')),
                 ('', 'debug', None, _('debug mode')),
                 ('', 'debugger', None, _('start debugger')),
                 ('', 'traceback', None, _('print traceback on exception')),
                 ('', 'time', None, _('time how long the command takes')),
                 ('', 'profile', None, _('profile')),
                 ('', 'version', None, _('output version information and exit')),
                 ('h', 'help', None, _('display help and exit')),
             ]
             norepo = ("clone init version help debugancestor debugconfig debugdata"
                       " debugindex debugindexdot paths")
             def find(cmd):
                 for e in table.keys():
                     if re.match("(%s)$" % e, cmd):
                         return e, table[e]
                 raise UnknownCommand(cmd)
             class SignalInterrupt(Exception):
                 """Exception raised on SIGTERM and SIGHUP."""
             def catchterm(*args):
                 raise SignalInterrupt
             def run():
                 sys.exit(dispatch(sys.argv[1:]))
             class ParseError(Exception):
                 """Exception raised on errors in parsing the command line."""
             def parse(args):
                 options = {}
                 cmdoptions = {}
                 try:
                     args = fancyopts.fancyopts(args, globalopts, options)
                 except fancyopts.getopt.GetoptError, inst:
                     raise ParseError(None, inst)
                 if args:
                     cmd, args = args[0], args[1:]
                     i = find(cmd)[1]
                     c = list(i[1])
                 else:
                     cmd = None
                     c = []
                 # combine global options into local
                 for o in globalopts:
                     c.append((o[0], o[1], options[o[1]], o[3]))
                 try:
                     args = fancyopts.fancyopts(args, c, cmdoptions)
                 except fancyopts.getopt.GetoptError, inst:
                     raise ParseError(cmd, inst)
                 # separate global options back out
                 for o in globalopts:
                     n = o[1]
                     options[n] = cmdoptions[n]
                     del cmdoptions[n]
                 return (cmd, cmd and i[0] or None, args, options, cmdoptions)
             def dispatch(args):
                 signal.signal(signal.SIGTERM, catchterm)
                 try:
                     signal.signal(signal.SIGHUP, catchterm)
                 except AttributeError:
                     pass
                 u = ui.ui()
                 external = []
                 for x in u.extensions():
                     if x[1]:
                         try:
                             mod = imp.load_source(x[0], x[1])
                         except:
                             u.warn(_("*** failed to import extension %s\n") % x[1])
                             continue
                     else:
                         def importh(name):
                             mod = __import__(name)
                             components = name.split('.')
                             for comp in components[1:]:
                                 mod = getattr(mod, comp)
                             return mod
                         try:
                             mod = importh(x[0])
                         except:
                             u.warn(_("failed to import extension %s\n") % x[0])
                             continue
                     external.append(mod)
                 for x in external:
                     cmdtable = getattr(x, 'cmdtable', {})
                     for t in cmdtable:
                         if t in table:
                             u.warn(_("module %s overrides %s\n") % (x.__name__, t))
                     table.update(cmdtable)
                 try:
                     cmd, func, args, options, cmdoptions = parse(args)
                 except ParseError, inst:
                     if inst.args[0]:
                         u.warn(_("hg %s: %s\n") % (inst.args[0], inst.args[1]))
                         help_(u, inst.args[0])
                     else:
                         u.warn(_("hg: %s\n") % inst.args[1])
                         help_(u, 'shortlist')
                     sys.exit(-1)
                 except UnknownCommand, inst:
                     u.warn(_("hg: unknown command '%s'\n") % inst.args[0])
                     help_(u, 'shortlist')
                     sys.exit(1)
                 if options["time"]:
                     def get_times():
                         t = os.times()
                         if t[4] == 0.0: # Windows leaves this as zero, so use time.clock()
                             t = (t[0], t[1], t[2], t[3], time.clock())
                         return t
                     s = get_times()
                     def print_time():
                         t = get_times()
                         u.warn(_("Time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n") %
                             (t[4]-s[4], t[0]-s[0], t[2]-s[2], t[1]-s[1], t[3]-s[3]))
                     atexit.register(print_time)
                 u.updateopts(options["verbose"], options["debug"], options["quiet"],
                           not options["noninteractive"])
                 # enter the debugger before command execution
                 if options['debugger']:
                     pdb.set_trace()
                 try:
                     try:
                         if options['help']:
                             help_(u, cmd, options['version'])
                             sys.exit(0)
                         elif options['version']:
                             show_version(u)
                             sys.exit(0)
                         elif not cmd:
                             help_(u, 'shortlist')
                             sys.exit(0)
                         if options['cwd']:
                             try:
                                 os.chdir(options['cwd'])
                             except OSError, inst:
                                 raise util.Abort('%s: %s' %
                                                  (options['cwd'], inst.strerror))
                         if cmd not in norepo.split():
                             path = options["repository"] or ""
                             repo = hg.repository(ui=u, path=path)
                             for x in external:
                                 if hasattr(x, 'reposetup'): x.reposetup(u, repo)
                             d = lambda: func(u, repo, *args, **cmdoptions)
                         else:
                             d = lambda: func(u, *args, **cmdoptions)
                         if options['profile']:
                             import hotshot, hotshot.stats
                             prof = hotshot.Profile("hg.prof")
                             r = prof.runcall(d)
                             prof.close()
                             stats = hotshot.stats.load("hg.prof")
                             stats.strip_dirs()
                             stats.sort_stats('time', 'calls')
                             stats.print_stats(40)
                             return r
                         else:
                             return d()
                     except:
                         # enter the debugger when we hit an exception
                         if options['debugger']:
                             pdb.post_mortem(sys.exc_info()[2])
                         if options['traceback']:
                             traceback.print_exc()
                         raise
                 except hg.RepoError, inst:
                     u.warn(_("abort: "), inst, "!\n")
                 except revlog.RevlogError, inst:
                     u.warn(_("abort: "), inst, "!\n")
                 except SignalInterrupt:
                     u.warn(_("killed!\n"))
                 except KeyboardInterrupt:
                     try:
                         u.warn(_("interrupted!\n"))
                     except IOError, inst:
                         if inst.errno == errno.EPIPE:
                             if u.debugflag:
                                 u.warn(_("\nbroken pipe\n"))
                         else:
                             raise
                 except IOError, inst:
                     if hasattr(inst, "code"):
                         u.warn(_("abort: %s\n") % inst)
                     elif hasattr(inst, "reason"):
                         u.warn(_("abort: error: %s\n") % inst.reason[1])
                     elif hasattr(inst, "args") and inst[0] == errno.EPIPE:
                         if u.debugflag:
                             u.warn(_("broken pipe\n"))
                     elif getattr(inst, "strerror", None):
                         if getattr(inst, "filename", None):
                             u.warn(_("abort: %s - %s\n") % (inst.strerror, inst.filename))
                         else:
                             u.warn(_("abort: %s\n") % inst.strerror)
                     else:
                         raise
                 except OSError, inst:
                     if hasattr(inst, "filename"):
                         u.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename))
                     else:
                         u.warn(_("abort: %s\n") % inst.strerror)
                 except util.Abort, inst:
                     u.warn(_('abort: '), inst.args[0] % inst.args[1:], '\n')
                     sys.exit(1)
                 except TypeError, inst:
                     # was this an argument error?
                     tb = traceback.extract_tb(sys.exc_info()[2])
                     if len(tb) > 2: # no
                         raise
                     u.debug(inst, "\n")
                     u.warn(_("%s: invalid arguments\n") % cmd)
                     help_(u, cmd)
                 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"))
                     raise
                 sys.exit(-1)

             """
             util.py - Mercurial utility functions and platform specfic implementations
              Copyright 2005 K. Thananchayan <thananck@yahoo.com>
             This software may be used and distributed according to the terms
             of the GNU General Public License, incorporated herein by reference.
             This contains helper routines that are independent of the SCM core and hide
             platform-specific details from the core.
             """
             import os, errno
             from i18n import gettext as _
             from demandload import *
             demandload(globals(), "re cStringIO shutil popen2 tempfile threading time")
             def pipefilter(s, cmd):
                 '''filter string S through command CMD, returning its output'''
                 (pout, pin) = popen2.popen2(cmd, -1, 'b')
                 def writer():
                     pin.write(s)
                     pin.close()
                 # we should use select instead on UNIX, but this will work on most
                 # systems, including Windows
                 w = threading.Thread(target=writer)
                 w.start()
                 f = pout.read()
                 pout.close()
                 w.join()
                 return f
             def tempfilter(s, cmd):
                 '''filter string S through a pair of temporary files with CMD.
                 CMD is used as a template to create the real command to be run,
                 with the strings INFILE and OUTFILE replaced by the real names of
                 the temporary files generated.'''
                 inname, outname = None, None
                 try:
                     infd, inname = tempfile.mkstemp(prefix='hgfin')
                     fp = os.fdopen(infd, 'wb')
                     fp.write(s)
                     fp.close()
                     outfd, outname = tempfile.mkstemp(prefix='hgfout')
                     os.close(outfd)
                     cmd = cmd.replace('INFILE', inname)
                     cmd = cmd.replace('OUTFILE', outname)
                     code = os.system(cmd)
                     if code: raise Abort(_("command '%s' failed: %s") %
                                          (cmd, explain_exit(code)))
                     return open(outname, 'rb').read()
                 finally:
                     try:
                         if inname: os.unlink(inname)
                     except: pass
                     try:
                         if outname: os.unlink(outname)
                     except: pass
             filtertable = {
                 'tempfile:': tempfilter,
                 'pipe:': pipefilter,
                 }
             def filter(s, cmd):
                 "filter a string through a command that transforms its input to its output"
                 for name, fn in filtertable.iteritems():
                     if cmd.startswith(name):
                         return fn(s, cmd[len(name):].lstrip())
                 return pipefilter(s, cmd)
             def patch(strip, patchname, ui):
                 """apply the patch <patchname> to the working directory.
                 a list of patched files is returned"""
                 fp = os.popen('patch -p%d < "%s"' % (strip, patchname))
                 files = {}
                 for line in fp:
                     line = line.rstrip()
                     ui.status("%s\n" % line)
                     if line.startswith('patching file '):
                         pf = parse_patch_output(line)
                         files.setdefault(pf, 1)
                 code = fp.close()
                 if code:
                     raise Abort(_("patch command failed: %s") % explain_exit(code)[0])
                 return files.keys()
             def binary(s):
                 """return true if a string is binary data using diff's heuristic"""
                 if s and '\0' in s[:4096]:
                     return True
                 return False
             def unique(g):
                 """return the uniq elements of iterable g"""
                 seen = {}
                 for f in g:
                     if f not in seen:
                         seen[f] = 1
                         yield f
             class Abort(Exception):
                 """Raised if a command needs to print an error and exit."""
             def always(fn): return True
             def never(fn): return False
             def globre(pat, head='^', tail='$'):
                 "convert a glob pattern into a regexp"
                 i, n = 0, len(pat)
                 res = ''
                 group = False
                 def peek(): return i < n and pat[i]
                 while i < n:
                     c = pat[i]
                     i = i+1
                     if c == '*':
                         if peek() == '*':
                             i += 1
                             res += '.*'
                         else:
                             res += '[^/]*'
                     elif c == '?':
                         res += '.'
                     elif c == '[':
                         j = i
                         if j < n and pat[j] in '!]':
                             j += 1
                         while j < n and pat[j] != ']':
                             j += 1
                         if j >= n:
                             res += '\\['
                         else:
                             stuff = pat[i:j].replace('\\','\\\\')
                             i = j + 1
                             if stuff[0] == '!':
                                 stuff = '^' + stuff[1:]
                             elif stuff[0] == '^':
                                 stuff = '\\' + stuff
                             res = '%s[%s]' % (res, stuff)
                     elif c == '{':
                         group = True
                         res += '(?:'
                     elif c == '}' and group:
                         res += ')'
                         group = False
                     elif c == ',' and group:
                         res += '|'
                     else:
                         res += re.escape(c)
                 return head + res + tail
             _globchars = {'[': 1, '{': 1, '*': 1, '?': 1}
             def pathto(n1, n2):
                 '''return the relative path from one place to another.
                 this returns a path in the form used by the local filesystem, not hg.'''
                 if not n1: return localpath(n2)
                 a, b = n1.split('/'), n2.split('/')
                 a.reverse(), b.reverse()
                 while a and b and a[-1] == b[-1]:
                     a.pop(), b.pop()
                 b.reverse()
                 return os.sep.join((['..'] * len(a)) + b)
             def canonpath(root, cwd, myname):
                 """return the canonical path of myname, given cwd and root"""
                 rootsep = root + os.sep
                 name = myname
                 if not name.startswith(os.sep):
                     name = os.path.join(root, cwd, name)
                 name = os.path.normpath(name)
                 if name.startswith(rootsep):
                     return pconvert(name[len(rootsep):])
                 elif name == root:
                     return ''
                 else:
                     raise Abort('%s not under root' % myname)
             def matcher(canonroot, cwd='', names=['.'], inc=[], exc=[], head=''):
+                return _matcher(canonroot, cwd, names, inc, exc, head, 'glob')
+            def cmdmatcher(canonroot, cwd='', names=['.'], inc=[], exc=[], head=''):
+                if os.name == 'nt':
+                    dflt_pat = 'glob'
+                else:
+                    dflt_pat = 'relpath'
+                return _matcher(canonroot, cwd, names, inc, exc, head, dflt_pat)
+            def _matcher(canonroot, cwd, names, inc, exc, head, dflt_pat):
                 """build a function to match a set of file patterns
                 arguments:
                 canonroot - the canonical root of the tree you're matching against
                 cwd - the current working directory, if relevant
                 names - patterns to find
                 inc - patterns to include
                 exc - patterns to exclude
                 head - a regex to prepend to patterns to control whether a match is rooted
                 a pattern is one of:
                 'glob:<rooted glob>'
                 're:<rooted regexp>'
                 'path:<rooted path>'
                 'relglob:<relative glob>'
                 'relpath:<relative path>'
                 'relre:<relative regexp>'
                 '<rooted path or regexp>'
                 returns:
                 a 3-tuple containing
                 - list of explicit non-pattern names passed in
                 - a bool match(filename) function
                 - a bool indicating if any patterns were passed in
                 todo:
                 make head regex a rooted bool
                 """
-                def patkind(name):
+                def patkind(name, dflt_pat='glob'):
                     for prefix in 're', 'glob', 'path', 'relglob', 'relpath', 'relre':
                         if name.startswith(prefix + ':'): return name.split(':', 1)
+                    return dflt_pat, name
+                def contains_glob(name):
                     for c in name:
-                        if c in _globchars: return 'glob', name
+                        if c in _globchars: return True
-                    return 'relpath', name
+                    return False
                 def regex(kind, name, tail):
                     '''convert a pattern into a regular expression'''
                     if kind == 're':
                         return name
                     elif kind == 'path':
                         return '^' + re.escape(name) + '(?:/|$)'
                     elif kind == 'relglob':
                         return head + globre(name, '(?:|.*/)', tail)
                     elif kind == 'relpath':
                         return head + re.escape(name) + tail
                     elif kind == 'relre':
                         if name.startswith('^'):
                             return name
                         return '.*' + name
                     return head + globre(name, '', tail)
                 def matchfn(pats, tail):
                     """build a matching function from a set of patterns"""
                     if pats:
                         pat = '(?:%s)' % '|'.join([regex(k, p, tail) for (k, p) in pats])
                         return re.compile(pat).match
                 def globprefix(pat):
                     '''return the non-glob prefix of a path, e.g. foo/* -> foo'''
                     root = []
                     for p in pat.split(os.sep):
-                        if patkind(p)[0] == 'glob': break
+                        if contains_glob(p): break
                         root.append(p)
                     return '/'.join(root)
                 pats = []
                 files = []
                 roots = []
-                for kind, name in map(patkind, names):
+                for kind, name in [patkind(p, dflt_pat) for p in names]:
                     if kind in ('glob', 'relpath'):
                         name = canonpath(canonroot, cwd, name)
                         if name == '':
                             kind, name = 'glob', '**'
                     if kind in ('glob', 'path', 're'):
                         pats.append((kind, name))
                     if kind == 'glob':
                         root = globprefix(name)
                         if root: roots.append(root)
                     elif kind == 'relpath':
                         files.append((kind, name))
                         roots.append(name)
                 patmatch = matchfn(pats, '$') or always
                 filematch = matchfn(files, '(?:/|$)') or always
                 incmatch = always
                 if inc:
                     incmatch = matchfn(map(patkind, inc), '(?:/|$)')
                 excmatch = lambda fn: False
                 if exc:
                     excmatch = matchfn(map(patkind, exc), '(?:/|$)')
                 return (roots,
                         lambda fn: (incmatch(fn) and not excmatch(fn) and
                                     (fn.endswith('/') or
                                      (not pats and not files) or
                                      (pats and patmatch(fn)) or
                                      (files and filematch(fn)))),
                         (inc or exc or (pats and pats != [('glob', '**')])) and True)
             def system(cmd, errprefix=None):
                 """execute a shell command that must succeed"""
                 rc = os.system(cmd)
                 if rc:
                     errmsg = "%s %s" % (os.path.basename(cmd.split(None, 1)[0]),
                                         explain_exit(rc)[0])
                     if errprefix:
                         errmsg = "%s: %s" % (errprefix, errmsg)
                     raise Abort(errmsg)
             def rename(src, dst):
                 """forcibly rename a file"""
                 try:
                     os.rename(src, dst)
                 except:
                     os.unlink(dst)
                     os.rename(src, dst)
             def copyfiles(src, dst, hardlink=None):
                 """Copy a directory tree using hardlinks if possible"""
                 if hardlink is None:
                     hardlink = (os.stat(src).st_dev ==
                                 os.stat(os.path.dirname(dst)).st_dev)
                 if os.path.isdir(src):
                     os.mkdir(dst)
                     for name in os.listdir(src):
                         srcname = os.path.join(src, name)
                         dstname = os.path.join(dst, name)
                         copyfiles(srcname, dstname, hardlink)
                 else:
                     if hardlink:
                         try:
                             os_link(src, dst)
                         except:
                             hardlink = False
                             shutil.copy2(src, dst)
                     else:
                         shutil.copy2(src, dst)
             def opener(base):
                 """
                 return a function that opens files relative to base
                 this function is used to hide the details of COW semantics and
                 remote file access from higher level code.
                 """
                 p = base
                 def o(path, mode="r", text=False):
                     f = os.path.join(p, path)
                     if not text:
                         mode += "b" # for that other OS
                     if mode[0] != "r":
                         try:
                             nlink = nlinks(f)
                         except OSError:
                             d = os.path.dirname(f)
                             if not os.path.isdir(d):
                                 os.makedirs(d)
                         else:
                             if nlink > 1:
                                 file(f + ".tmp", "wb").write(file(f, "rb").read())
                                 rename(f+".tmp", f)
                     return file(f, mode)
                 return o
             def _makelock_file(info, pathname):
                 ld = os.open(pathname, os.O_CREAT | os.O_WRONLY | os.O_EXCL)
                 os.write(ld, info)
                 os.close(ld)
             def _readlock_file(pathname):
                 return file(pathname).read()
             def nlinks(pathname):
                 """Return number of hardlinks for the given file."""
                 return os.stat(pathname).st_nlink
             if hasattr(os, 'link'):
                 os_link = os.link
             else:
                 def os_link(src, dst):
                     raise OSError(0, _("Hardlinks not supported"))
             # Platform specific variants
             if os.name == 'nt':
                 nulldev = 'NUL:'
                 try:
                     import win32api, win32process
                     filename = win32process.GetModuleFileNameEx(win32api.GetCurrentProcess(), 0)
                     systemrc = os.path.join(os.path.dirname(filename), 'mercurial.ini')
                 except ImportError:
                     systemrc = r'c:\mercurial\mercurial.ini'
                     pass
                 rcpath = (systemrc,
                           os.path.join(os.path.expanduser('~'), 'mercurial.ini'))
                 def parse_patch_output(output_line):
                     """parses the output produced by patch and returns the file name"""
                     pf = output_line[14:]
                     if pf[0] == '`':
                         pf = pf[1:-1] # Remove the quotes
                     return pf
                 try: # ActivePython can create hard links using win32file module
                     import win32file
                     def os_link(src, dst): # NB will only succeed on NTFS
                         win32file.CreateHardLink(dst, src)
                     def nlinks(pathname):
                         """Return number of hardlinks for the given file."""
                         try:
                             fh = win32file.CreateFile(pathname,
                                 win32file.GENERIC_READ, win32file.FILE_SHARE_READ,
                                 None, win32file.OPEN_EXISTING, 0, None)
                             res = win32file.GetFileInformationByHandle(fh)
                             fh.Close()
                             return res[7]
                         except:
                             return os.stat(pathname).st_nlink
                 except ImportError:
                     pass
                 def is_exec(f, last):
                     return last
                 def set_exec(f, mode):
                     pass
                 def pconvert(path):
                     return path.replace("\\", "/")
                 def localpath(path):
                     return path.replace('/', '\\')
                 def normpath(path):
                     return pconvert(os.path.normpath(path))
                 makelock = _makelock_file
                 readlock = _readlock_file
                 def explain_exit(code):
                     return _("exited with status %d") % code, code
             else:
                 nulldev = '/dev/null'
                 hgrcd = '/etc/mercurial/hgrc.d'
                 hgrcs = []
                 if os.path.isdir(hgrcd):
                     hgrcs = [f for f in os.listdir(hgrcd) if f.endswith(".rc")]
                 rcpath = map(os.path.normpath, hgrcs +
                              ['/etc/mercurial/hgrc', os.path.expanduser('~/.hgrc')])
                 def parse_patch_output(output_line):
                     """parses the output produced by patch and returns the file name"""
                     return output_line[14:]
                 def is_exec(f, last):
                     """check whether a file is executable"""
                     return (os.stat(f).st_mode & 0100 != 0)
                 def set_exec(f, mode):
                     s = os.stat(f).st_mode
                     if (s & 0100 != 0) == mode:
                         return
                     if mode:
                         # Turn on +x for every +r bit when making a file executable
                         # and obey umask.
                         umask = os.umask(0)
                         os.umask(umask)
                         os.chmod(f, s | (s & 0444) >> 2 & ~umask)
                     else:
                         os.chmod(f, s & 0666)
                 def pconvert(path):
                     return path
                 def localpath(path):
                     return path
                 normpath = os.path.normpath
                 def makelock(info, pathname):
                     try:
                         os.symlink(info, pathname)
                     except OSError, why:
                         if why.errno == errno.EEXIST:
                             raise
                         else:
                             _makelock_file(info, pathname)
                 def readlock(pathname):
                     try:
                         return os.readlink(pathname)
                     except OSError, why:
                         if why.errno == errno.EINVAL:
                             return _readlock_file(pathname)
                         else:
                             raise
                 def explain_exit(code):
                     """return a 2-tuple (desc, code) describing a process's status"""
                     if os.WIFEXITED(code):
                         val = os.WEXITSTATUS(code)
                         return _("exited with status %d") % val, val
                     elif os.WIFSIGNALED(code):
                         val = os.WTERMSIG(code)
                         return _("killed by signal %d") % val, val
                     elif os.WIFSTOPPED(code):
                         val = os.WSTOPSIG(code)
                         return _("stopped by signal %d") % val, val
                     raise ValueError(_("invalid exit code"))
             class chunkbuffer(object):
                 """Allow arbitrary sized chunks of data to be efficiently read from an
                 iterator over chunks of arbitrary size."""
                 def __init__(self, in_iter, targetsize = 2**16):
                     """in_iter is the iterator that's iterating over the input chunks.
                     targetsize is how big a buffer to try to maintain."""
                     self.in_iter = iter(in_iter)
                     self.buf = ''
                     self.targetsize = int(targetsize)
                     if self.targetsize <= 0:
                         raise ValueError(_("targetsize must be greater than 0, was %d") %
                                          targetsize)
                     self.iterempty = False
                 def fillbuf(self):
                     """Ignore target size; read every chunk from iterator until empty."""
                     if not self.iterempty:
                         collector = cStringIO.StringIO()
                         collector.write(self.buf)
                         for ch in self.in_iter:
                             collector.write(ch)
                         self.buf = collector.getvalue()
                         self.iterempty = True
                 def read(self, l):
                     """Read L bytes of data from the iterator of chunks of data.
                     Returns less than L bytes if the iterator runs dry."""
                     if l > len(self.buf) and not self.iterempty:
                         # Clamp to a multiple of self.targetsize
                         targetsize = self.targetsize * ((l // self.targetsize) + 1)
                         collector = cStringIO.StringIO()
                         collector.write(self.buf)
                         collected = len(self.buf)
                         for chunk in self.in_iter:
                             collector.write(chunk)
                             collected += len(chunk)
                             if collected >= targetsize:
                                 break
                         if collected < targetsize:
                             self.iterempty = True
                         self.buf = collector.getvalue()
                     s, self.buf = self.buf[:l], buffer(self.buf, l)
                     return s
             def filechunkiter(f, size = 65536):
                 """Create a generator that produces all the data in the file size
                 (default 65536) bytes at a time.  Chunks may be less than size
                 bytes if the chunk is the last chunk in the file, or the file is a
                 socket or some other type of file that sometimes reads less data
                 than is requested."""
                 s = f.read(size)
                 while len(s) > 0:
                     yield s
                     s = f.read(size)
             def makedate():
                 t = time.time()
                 if time.daylight: tz = time.altzone
                 else: tz = time.timezone
                 return t, tz
             def datestr(date=None, format='%c'):
                 """represent a (unixtime, offset) tuple as a localized time.
                 unixtime is seconds since the epoch, and offset is the time zone's
                 number of seconds away from UTC."""
                 t, tz = date or makedate()
                 return ("%s %+03d%02d" %
                         (time.strftime(format, time.gmtime(float(t) - tz)),
                          -tz / 3600,
                          ((-tz % 3600) / 60)))