upstream/mercurial-mirror Commit - r1090:1bca39b8

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

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

9

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

10

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

10

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

11

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

11

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

12

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

12

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

13

14

class UnknownCommand(Exception):

14

class UnknownCommand(Exception):

15

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

15

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

16

17

def filterfiles(filters, files):

17

def filterfiles(filters, files):

18

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

18

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

19

20

for t in filters:

20

for t in filters:

21

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

21

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

22

t += "/"

22

t += "/"

23

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

23

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

24

return l

24

return l

25

26

def relpath(repo, args):

26

def relpath(repo, args):

27

cwd = repo.getcwd()

27

cwd = repo.getcwd()

28

if cwd:

28

if cwd:

29

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

29

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

30

return args

30

return args

31

32

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

32

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

33

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

33

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

34

opts.get('exclude'), head)

34

opts.get('exclude'), head)

35

36

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

36

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

37

cwd = repo.getcwd()

37

cwd = repo.getcwd()

38

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

38

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

39

exact = dict(zip(files, files))

39

exact = dict(zip(files, files))

40

def walk():

40

def walk():

41

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

41

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

42

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

42

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

43

return files, matchfn, walk()

43

return files, matchfn, walk()

44

45

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

45

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

46

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

46

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

47

for r in results:

47

for r in results:

48

yield r

48

yield r

49

50

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

50

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

51

# This code most commonly needs to iterate backwards over the

51

# This code most commonly needs to iterate backwards over the

52

# history it is interested in. Doing so has awful

52

# history it is interested in. Doing so has awful

53

# (quadratic-looking) performance, so we use iterators in a

53

# (quadratic-looking) performance, so we use iterators in a

54

# "windowed" way. Walk forwards through a window of revisions,

54

# "windowed" way. Walk forwards through a window of revisions,

55

# yielding them in the desired order, and walk the windows

55

# yielding them in the desired order, and walk the windows

56

# themselves backwards.

56

# themselves backwards.

57

cwd = repo.getcwd()

57

cwd = repo.getcwd()

58

if not pats and cwd:

58

if not pats and cwd:

59

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

59

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

60

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

60

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

61

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

61

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

62

pats, opts)

62

pats, opts)

63

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

63

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

64

wanted = {}

64

wanted = {}

65

slowpath = anypats

65

slowpath = anypats

66

window = 300

66

window = 300

67

fncache = {}

67

fncache = {}

68

if not slowpath and not files:

68

if not slowpath and not files:

69

# No files, no patterns. Display all revs.

69

# No files, no patterns. Display all revs.

70

wanted = dict(zip(revs, revs))

70

wanted = dict(zip(revs, revs))

71

if not slowpath:

71

if not slowpath:

72

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

72

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

73

def filerevgen(filelog):

73

def filerevgen(filelog):

74

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

74

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

75

revs = []

75

revs = []

76

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

76

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

77

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

77

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

78

revs.reverse()

78

revs.reverse()

79

for rev in revs:

79

for rev in revs:

80

yield rev

80

yield rev

81

82

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

82

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

83

for file in files:

83

for file in files:

84

filelog = repo.file(file)

84

filelog = repo.file(file)

85

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

85

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

86

# try to find matching entries on the slow path.

86

# try to find matching entries on the slow path.

87

if filelog.count() == 0:

87

if filelog.count() == 0:

88

slowpath = True

88

slowpath = True

89

break

89

break

90

for rev in filerevgen(filelog):

90

for rev in filerevgen(filelog):

91

if rev <= maxrev:

91

if rev <= maxrev:

92

if rev < minrev:

92

if rev < minrev:

93

break

93

break

94

fncache.setdefault(rev, [])

94

fncache.setdefault(rev, [])

95

fncache[rev].append(file)

95

fncache[rev].append(file)

96

wanted[rev] = 1

96

wanted[rev] = 1

97

if slowpath:

97

if slowpath:

98

# The slow path checks files modified in every changeset.

98

# The slow path checks files modified in every changeset.

99

def changerevgen():

99

def changerevgen():

100

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

100

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

101

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

101

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

102

yield j, repo.changelog.read(repo.lookup(str(j)))[3]

102

yield j, repo.changelog.read(repo.lookup(str(j)))[3]

103

104

for rev, changefiles in changerevgen():

104

for rev, changefiles in changerevgen():

105

matches = filter(matchfn, changefiles)

105

matches = filter(matchfn, changefiles)

106

if matches:

106

if matches:

107

fncache[rev] = matches

107

fncache[rev] = matches

108

wanted[rev] = 1

108

wanted[rev] = 1

109

110

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

110

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

111

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

111

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

112

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

112

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

113

if rev in wanted]

113

if rev in wanted]

114

srevs = list(nrevs)

114

srevs = list(nrevs)

115

srevs.sort()

115

srevs.sort()

116

for rev in srevs:

116

for rev in srevs:

117

fns = fncache.get(rev)

117

fns = fncache.get(rev)

118

if not fns:

118

if not fns:

119

fns = repo.changelog.read(repo.lookup(str(rev)))[3]

119

fns = repo.changelog.read(repo.lookup(str(rev)))[3]

120

fns = filter(matchfn, fns)

120

fns = filter(matchfn, fns)

121

yield 'add', rev, fns

121

yield 'add', rev, fns

122

for rev in nrevs:

122

for rev in nrevs:

123

yield 'iter', rev, None

123

yield 'iter', rev, None

124

125

revrangesep = ':'

125

revrangesep = ':'

126

127

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

127

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

128

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

128

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

129

if revlog is None:

129

if revlog is None:

130

revlog = repo.changelog

130

revlog = repo.changelog

131

revcount = revlog.count()

131

revcount = revlog.count()

132

def fix(val, defval):

132

def fix(val, defval):

133

if not val:

133

if not val:

134

return defval

134

return defval

135

try:

135

try:

136

num = int(val)

136

num = int(val)

137

if str(num) != val:

137

if str(num) != val:

138

raise ValueError

138

raise ValueError

139

if num < 0:

139

if num < 0:

140

num += revcount

140

num += revcount

141

if not (0 <= num < revcount):

141

if not (0 <= num < revcount):

142

raise ValueError

142

raise ValueError

143

except ValueError:

143

except ValueError:

144

try:

144

try:

145

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

145

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

146

except KeyError:

146

except KeyError:

147

try:

147

try:

148

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

148

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

149

except KeyError:

149

except KeyError:

150

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

150

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

151

return num

151

return num

152

for spec in revs:

152

for spec in revs:

153

if spec.find(revrangesep) >= 0:

153

if spec.find(revrangesep) >= 0:

154

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

154

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

155

start = fix(start, 0)

155

start = fix(start, 0)

156

end = fix(end, revcount - 1)

156

end = fix(end, revcount - 1)

157

step = start > end and -1 or 1

157

step = start > end and -1 or 1

158

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

158

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

159

yield str(rev)

159

yield str(rev)

160

else:

160

else:

161

yield str(fix(spec, None))

161

yield str(fix(spec, None))

162

163

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

163

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

164

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

164

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

165

node_expander = {

165

node_expander = {

166

'H': lambda: hg.hex(node),

166

'H': lambda: hg.hex(node),

167

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

167

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

168

'h': lambda: hg.short(node),

168

'h': lambda: hg.short(node),

169

}

169

}

170

expander = {

170

expander = {

171

'%': lambda: '%',

171

'%': lambda: '%',

172

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

172

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

173

}

173

}

174

175

try:

175

try:

176

if node:

176

if node:

177

expander.update(node_expander)

177

expander.update(node_expander)

178

if node and revwidth is not None:

178

if node and revwidth is not None:

179

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

179

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

180

if total is not None:

180

if total is not None:

181

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

181

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

182

if seqno is not None:

182

if seqno is not None:

183

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

183

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

184

if total is not None and seqno is not None:

184

if total is not None and seqno is not None:

185

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

185

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

186

187

newname = []

187

newname = []

188

patlen = len(pat)

188

patlen = len(pat)

189

i = 0

189

i = 0

190

while i < patlen:

190

while i < patlen:

191

c = pat[i]

191

c = pat[i]

192

if c == '%':

192

if c == '%':

193

i += 1

193

i += 1

194

c = pat[i]

194

c = pat[i]

195

c = expander[c]()

195

c = expander[c]()

196

newname.append(c)

196

newname.append(c)

197

i += 1

197

i += 1

198

return ''.join(newname)

198

return ''.join(newname)

199

except KeyError, inst:

199

except KeyError, inst:

200

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

200

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

201

inst.args[0])

201

inst.args[0])

202

203

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

203

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

204

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

204

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

205

if not pat or pat == '-':

205

if not pat or pat == '-':

206

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

206

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

207

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

207

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

208

return pat

208

return pat

209

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

209

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

210

return pat

210

return pat

211

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

211

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

212

mode)

212

mode)

213

214

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

214

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

215

changes=None, text=False):

215

changes=None, text=False):

216

def date(c):

216

def date(c):

217

return time.asctime(time.gmtime(float(c[2].split(' ')[0])))

217

return time.asctime(time.gmtime(float(c[2].split(' ')[0])))

218

219

if not changes:

219

if not changes:

220

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

220

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

221

else:

221

else:

222

(c, a, d, u) = changes

222

(c, a, d, u) = changes

223

if files:

223

if files:

224

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

224

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

225

226

if not c and not a and not d:

226

if not c and not a and not d:

227

return

227

return

228

229

if node2:

229

if node2:

230

change = repo.changelog.read(node2)

230

change = repo.changelog.read(node2)

231

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

231

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

232

date2 = date(change)

232

date2 = date(change)

233

def read(f):

233

def read(f):

234

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

234

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

235

else:

235

else:

236

date2 = time.asctime()

236

date2 = time.asctime()

237

if not node1:

237

if not node1:

238

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

238

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

239

def read(f):

239

def read(f):

240

return repo.wfile(f).read()

240

return repo.wfile(f).read()

241

242

if ui.quiet:

242

if ui.quiet:

243

r = None

243

r = None

244

else:

244

else:

245

hexfunc = ui.verbose and hg.hex or hg.short

245

hexfunc = ui.verbose and hg.hex or hg.short

246

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

246

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

247

248

change = repo.changelog.read(node1)

248

change = repo.changelog.read(node1)

249

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

249

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

250

date1 = date(change)

250

date1 = date(change)

251

252

for f in c:

252

for f in c:

253

to = None

253

to = None

254

if f in mmap:

254

if f in mmap:

255

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

255

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

256

tn = read(f)

256

tn = read(f)

257

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

257

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

258

for f in a:

258

for f in a:

259

to = None

259

to = None

260

tn = read(f)

260

tn = read(f)

261

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

261

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

262

for f in d:

262

for f in d:

263

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

263

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

264

tn = None

264

tn = None

265

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

265

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

266

267

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

267

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

268

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

268

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

269

log = repo.changelog

269

log = repo.changelog

270

if changenode is None:

270

if changenode is None:

271

changenode = log.node(rev)

271

changenode = log.node(rev)

272

elif not rev:

272

elif not rev:

273

rev = log.rev(changenode)

273

rev = log.rev(changenode)

274

275

if ui.quiet:

275

if ui.quiet:

276

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

276

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

277

return

277

return

278

279

changes = log.read(changenode)

279

changes = log.read(changenode)

280

281

t, tz = changes[2].split(' ')

281

t, tz = changes[2].split(' ')

282

# a conversion tool was sticking non-integer offsets into repos

282

# a conversion tool was sticking non-integer offsets into repos

283

try:

283

try:

284

tz = int(tz)

284

tz = int(tz)

285

except ValueError:

285

except ValueError:

286

tz = 0

286

tz = 0

287

date = time.asctime(time.localtime(float(t))) + " %+05d" % (int(tz)/-36)

287

date = time.asctime(time.localtime(float(t))) + " %+05d" % (int(tz)/-36)

288

289

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

289

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

290

for p in log.parents(changenode)

290

for p in log.parents(changenode)

291

if ui.debugflag or p != hg.nullid]

291

if ui.debugflag or p != hg.nullid]

292

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

292

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

293

parents = []

293

parents = []

294

295

if ui.verbose:

295

if ui.verbose:

296

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

296

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

297

else:

297

else:

298

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

298

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

299

300

for tag in repo.nodetags(changenode):

300

for tag in repo.nodetags(changenode):

301

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

301

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

302

for parent in parents:

302

for parent in parents:

303

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

303

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

304

305

if brinfo and changenode in brinfo:

305

if brinfo and changenode in brinfo:

306

br = brinfo[changenode]

306

br = brinfo[changenode]

307

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

307

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

308

309

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

309

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

310

hg.hex(changes[0])))

310

hg.hex(changes[0])))

311

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

311

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

312

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

312

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

313

314

if ui.debugflag:

314

if ui.debugflag:

315

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

315

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

316

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

316

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

317

if value:

317

if value:

318

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

318

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

319

else:

319

else:

320

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

320

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

321

322

description = changes[4].strip()

322

description = changes[4].strip()

323

if description:

323

if description:

324

if ui.verbose:

324

if ui.verbose:

325

ui.status("description:\n")

325

ui.status("description:\n")

326

ui.status(description)

326

ui.status(description)

327

ui.status("\n\n")

327

ui.status("\n\n")

328

else:

328

else:

329

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

329

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

330

ui.status("\n")

330

ui.status("\n")

331

332

def show_version(ui):

332

def show_version(ui):

333

"""output version and copyright information"""

333

"""output version and copyright information"""

334

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

334

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

335

% version.get_version())

335

% version.get_version())

336

ui.status(

336

ui.status(

337

338

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

338

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

339

"There is NO\nwarranty; "

339

"There is NO\nwarranty; "

340

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

340

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

341

)

341

)

342

343

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

343

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

344

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

344

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

345

option_lists = []

345

option_lists = []

346

if cmd and cmd != 'shortlist':

346

if cmd and cmd != 'shortlist':

347

if with_version:

347

if with_version:

348

show_version(ui)

348

show_version(ui)

349

ui.write('\n')

349

ui.write('\n')

350

key, i = find(cmd)

350

key, i = find(cmd)

351

# synopsis

351

# synopsis

352

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

352

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

353

354

# description

354

# description

355

doc = i[0].__doc__

355

doc = i[0].__doc__

356

if ui.quiet:

356

if ui.quiet:

357

doc = doc.splitlines(0)[0]

357

doc = doc.splitlines(0)[0]

358

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

358

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

359

360

if not ui.quiet:

360

if not ui.quiet:

361

# aliases

361

# aliases

362

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

362

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

363

if aliases:

363

if aliases:

364

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

364

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

365

366

# options

366

# options

367

if i[1]:

367

if i[1]:

368

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

368

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

369

370

else:

370

else:

371

# program name

371

# program name

372

if ui.verbose or with_version:

372

if ui.verbose or with_version:

373

show_version(ui)

373

show_version(ui)

374

else:

374

else:

375

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

375

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

376

ui.status('\n')

376

ui.status('\n')

377

378

# list of commands

378

# list of commands

379

if cmd == "shortlist":

379

if cmd == "shortlist":

380

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

380

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

381

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

381

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

382

elif ui.verbose:

382

elif ui.verbose:

383

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

383

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

384

else:

384

else:

385

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

385

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

386

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

386

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

387

388

h = {}

388

h = {}

389

cmds = {}

389

cmds = {}

390

for c, e in table.items():

390

for c, e in table.items():

391

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

391

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

392

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

392

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

393

continue

393

continue

394

f = f.lstrip("^")

394

f = f.lstrip("^")

395

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

395

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

396

continue

396

continue

397

d = ""

397

d = ""

398

if e[0].__doc__:

398

if e[0].__doc__:

399

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

399

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

400

h[f] = d

400

h[f] = d

401

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

401

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

402

403

fns = h.keys()

403

fns = h.keys()

404

fns.sort()

404

fns.sort()

405

m = max(map(len, fns))

405

m = max(map(len, fns))

406

for f in fns:

406

for f in fns:

407

if ui.verbose:

407

if ui.verbose:

408

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

408

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

409

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

409

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

410

else:

410

else:

411

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

411

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

412

413

# global options

413

# global options

414

if ui.verbose:

414

if ui.verbose:

415

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

415

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

416

417

# list all option lists

417

# list all option lists

418

opt_output = []

418

opt_output = []

419

for title, options in option_lists:

419

for title, options in option_lists:

420

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

420

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

421

for shortopt, longopt, default, desc in options:

421

for shortopt, longopt, default, desc in options:

422

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

422

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

423

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

423

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

424

"%s%s" % (desc,

424

"%s%s" % (desc,

425

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

425

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

426

or "")))

426

or "")))

427

428

if opt_output:

428

if opt_output:

429

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

429

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

430

for first, second in opt_output:

430

for first, second in opt_output:

431

if second:

431

if second:

432

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

432

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

433

else:

433

else:

434

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

434

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

435

436

# Commands start here, listed alphabetically

436

# Commands start here, listed alphabetically

437

438

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

438

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

439

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

439

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

440

names = []

440

names = []

441

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

441

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

442

if exact:

442

if exact:

443

names.append(abs)

443

names.append(abs)

444

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

444

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

445

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

445

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

446

names.append(abs)

446

names.append(abs)

447

repo.add(names)

447

repo.add(names)

448

449

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

449

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

450

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

450

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

451

add, remove = [], []

451

add, remove = [], []

452

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

452

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

453

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

453

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

454

add.append(abs)

454

add.append(abs)

455

if not exact:

455

if not exact:

456

ui.status('adding ', rel, '\n')

456

ui.status('adding ', rel, '\n')

457

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

457

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

458

remove.append(abs)

458

remove.append(abs)

459

if not exact:

459

if not exact:

460

ui.status('removing ', rel, '\n')

460

ui.status('removing ', rel, '\n')

461

repo.add(add)

461

repo.add(add)

462

repo.remove(remove)

462

repo.remove(remove)

463

464

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

464

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

465

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

465

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

466

def getnode(rev):

466

def getnode(rev):

467

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

467

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

468

469

def getname(rev):

469

def getname(rev):

470

try:

470

try:

471

return bcache[rev]

471

return bcache[rev]

472

except KeyError:

472

except KeyError:

473

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

473

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

474

name = cl[1]

474

name = cl[1]

475

f = name.find('@')

475

f = name.find('@')

476

if f >= 0:

476

if f >= 0:

477

name = name[:f]

477

name = name[:f]

478

f = name.find('<')

478

f = name.find('<')

479

if f >= 0:

479

if f >= 0:

480

name = name[f+1:]

480

name = name[f+1:]

481

bcache[rev] = name

481

bcache[rev] = name

482

return name

482

return name

483

484

if not pats:

484

if not pats:

485

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

485

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

486

487

bcache = {}

487

bcache = {}

488

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

488

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

489

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

489

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

490

opts['number'] = 1

490

opts['number'] = 1

491

492

if opts['rev']:

492

if opts['rev']:

493

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

493

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

494

else:

494

else:

495

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

495

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

496

change = repo.changelog.read(node)

496

change = repo.changelog.read(node)

497

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

497

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

498

499

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

499

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

500

if abs not in mmap:

500

if abs not in mmap:

501

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

501

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

502

continue

502

continue

503

504

f = repo.file(abs)

504

f = repo.file(abs)

505

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

505

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

506

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

506

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

507

continue

507

continue

508

509

lines = f.annotate(mmap[abs])

509

lines = f.annotate(mmap[abs])

510

pieces = []

510

pieces = []

511

512

for o, f in opmap:

512

for o, f in opmap:

513

if opts[o]:

513

if opts[o]:

514

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

514

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

515

if l:

515

if l:

516

m = max(map(len, l))

516

m = max(map(len, l))

517

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

517

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

518

519

if pieces:

519

if pieces:

520

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

520

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

521

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

521

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

522

523

def cat(ui, repo, file1, rev=None, **opts):

523

def cat(ui, repo, file1, rev=None, **opts):

524

"""output the latest or given revision of a file"""

524

"""output the latest or given revision of a file"""

525

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

525

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

526

if rev:

526

if rev:

527

try:

527

try:

528

# assume all revision numbers are for changesets

528

# assume all revision numbers are for changesets

529

n = repo.lookup(rev)

529

n = repo.lookup(rev)

530

change = repo.changelog.read(n)

530

change = repo.changelog.read(n)

531

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

531

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

532

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

532

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

533

except hg.RepoError, KeyError:

533

except hg.RepoError, KeyError:

534

n = r.lookup(rev)

534

n = r.lookup(rev)

535

else:

535

else:

536

n = r.tip()

536

n = r.tip()

537

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

537

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

538

fp.write(r.read(n))

538

fp.write(r.read(n))

539

540

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

540

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

541

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

541

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

542

if dest is None:

542

if dest is None:

543

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

543

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

544

545

if os.path.exists(dest):

545

if os.path.exists(dest):

546

ui.warn("abort: destination '%s' already exists\n" % dest)

546

ui.warn("abort: destination '%s' already exists\n" % dest)

547

return 1

547

return 1

548

549

dest = os.path.realpath(dest)

549

dest = os.path.realpath(dest)

550

551

class Dircleanup:

551

class Dircleanup:

552

def __init__(self, dir_):

552

def __init__(self, dir_):

553

self.rmtree = shutil.rmtree

553

self.rmtree = shutil.rmtree

554

self.dir_ = dir_

554

self.dir_ = dir_

555

os.mkdir(dir_)

555

os.mkdir(dir_)

556

def close(self):

556

def close(self):

557

self.dir_ = None

557

self.dir_ = None

558

def __del__(self):

558

def __del__(self):

559

if self.dir_:

559

if self.dir_:

560

self.rmtree(self.dir_, True)

560

self.rmtree(self.dir_, True)

561

562

if opts['ssh']:

562

if opts['ssh']:

563

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

563

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

564

if opts['remotecmd']:

564

if opts['remotecmd']:

565

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

565

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

566

567

d = Dircleanup(dest)

567

d = Dircleanup(dest)

568

source = ui.expandpath(source)

568

source = ui.expandpath(source)

569

abspath = source

569

abspath = source

570

other = hg.repository(ui, source)

570

other = hg.repository(ui, source)

571

572

if other.dev() != -1:

572

if other.dev() != -1:

573

abspath = os.path.abspath(source)

573

abspath = os.path.abspath(source)

574

copyfile = (os.stat(dest).st_dev == other.dev()

574

copyfile = (os.stat(dest).st_dev == other.dev()

575

and getattr(os, 'link', None) or shutil.copy2)

575

and getattr(os, 'link', None) or shutil.copy2)

576

if copyfile is not shutil.copy2:

576

if copyfile is not shutil.copy2:

577

ui.note("cloning by hardlink\n")

577

ui.note("cloning by hardlink\n")

578

# we use a lock here because because we're not nicely ordered

578

# we use a lock here because because we're not nicely ordered

579

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

579

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

580

581

util.copytree(os.path.join(source, ".hg"), os.path.join(dest, ".hg"),

581

util.copytree(os.path.join(source, ".hg"), os.path.join(dest, ".hg"),

582

copyfile)

582

copyfile)

583

try:

583

try:

584

os.unlink(os.path.join(dest, ".hg", "dirstate"))

584

os.unlink(os.path.join(dest, ".hg", "dirstate"))

585

except OSError:

585

except OSError:

586

pass

586

pass

587

588

repo = hg.repository(ui, dest)

588

repo = hg.repository(ui, dest)

589

590

else:

590

else:

591

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

591

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

592

repo.pull(other)

592

repo.pull(other)

593

594

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

594

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

595

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

595

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

596

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

596

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

597

598

if not opts['noupdate']:

598

if not opts['noupdate']:

599

update(ui, repo)

599

update(ui, repo)

600

601

d.close()

601

d.close()

602

603

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

603

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

604

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

604

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

605

if opts['text']:

605

if opts['text']:

606

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

606

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

607

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

607

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

608

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

608

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

609

logfile = opts['logfile']

609

logfile = opts['logfile']

610

if not message and logfile:

610

if not message and logfile:

611

try:

611

try:

612

if logfile == '-':

612

if logfile == '-':

613

message = sys.stdin.read()

613

message = sys.stdin.read()

614

else:

614

else:

615

message = open(logfile).read()

615

message = open(logfile).read()

616

except IOError, why:

616

except IOError, why:

617

ui.warn("Can't read commit message %s: %s\n" % (logfile, why))

617

ui.warn("Can't read commit message %s: %s\n" % (logfile, why))

618

619

if opts['addremove']:

619

if opts['addremove']:

620

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

620

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

621

cwd = repo.getcwd()

621

cwd = repo.getcwd()

622

if not pats and cwd:

622

if not pats and cwd:

623

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

623

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

624

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

624

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

625

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

625

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

626

pats, opts)

626

pats, opts)

627

if pats:

627

if pats:

628

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

628

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

629

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

629

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

630

else:

630

else:

631

files = []

631

files = []

632

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

632

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

633

634

def copy(ui, repo, source, dest):

634

def copy(ui, repo, source, dest):

635

"""mark a file as copied or renamed for the next commit"""

635

"""mark a file as copied or renamed for the next commit"""

636

return repo.copy(*relpath(repo, (source, dest)))

636

return repo.copy(*relpath(repo, (source, dest)))

637

638

def debugcheckstate(ui, repo):

638

def debugcheckstate(ui, repo):

639

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

639

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

640

parent1, parent2 = repo.dirstate.parents()

640

parent1, parent2 = repo.dirstate.parents()

641

repo.dirstate.read()

641

repo.dirstate.read()

642

dc = repo.dirstate.map

642

dc = repo.dirstate.map

643

keys = dc.keys()

643

keys = dc.keys()

644

keys.sort()

644

keys.sort()

645

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

645

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

646

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

646

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

647

m1 = repo.manifest.read(m1n)

647

m1 = repo.manifest.read(m1n)

648

m2 = repo.manifest.read(m2n)

648

m2 = repo.manifest.read(m2n)

649

errors = 0

649

errors = 0

650

for f in dc:

650

for f in dc:

651

state = repo.dirstate.state(f)

651

state = repo.dirstate.state(f)

652

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

652

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

653

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

653

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

654

errors += 1

654

errors += 1

655

if state in "a" and f in m1:

655

if state in "a" and f in m1:

656

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

656

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

657

errors += 1

657

errors += 1

658

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

658

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

659

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

659

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

660

(f, state))

660

(f, state))

661

errors += 1

661

errors += 1

662

for f in m1:

662

for f in m1:

663

state = repo.dirstate.state(f)

663

state = repo.dirstate.state(f)

664

if state not in "nrm":

664

if state not in "nrm":

665

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

665

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

666

errors += 1

666

errors += 1

667

if errors:

667

if errors:

668

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

668

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

669

670

def debugconfig(ui):

670

def debugconfig(ui):

671

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

671

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

672

try:

672

try:

673

repo = hg.repository(ui)

673

repo = hg.repository(ui)

674

except hg.RepoError:

674

except hg.RepoError:

675

pass

675

pass

676

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

676

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

677

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

677

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

678

679

def debugstate(ui, repo):

679

def debugstate(ui, repo):

680

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

680

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

681

repo.dirstate.read()

681

repo.dirstate.read()

682

dc = repo.dirstate.map

682

dc = repo.dirstate.map

683

keys = dc.keys()

683

keys = dc.keys()

684

keys.sort()

684

keys.sort()

685

for file_ in keys:

685

for file_ in keys:

686

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

686

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

687

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

687

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

688

time.strftime("%x %X",

688

time.strftime("%x %X",

689

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

689

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

690

691

def debugdata(ui, file_, rev):

691

def debugdata(ui, file_, rev):

692

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

692

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

693

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

693

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

694

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

694

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

695

696

def debugindex(ui, file_):

696

def debugindex(ui, file_):

697

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

697

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

698

r = hg.revlog(hg.~~opener~~(""), file_, "")

698

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

699

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

699

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

700

" nodeid p1 p2\n")

700

" nodeid p1 p2\n")

701

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

701

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

702

e = r.index[i]

702

e = r.index[i]

703

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

703

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

704

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

704

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

705

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

705

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

706

707

def debugindexdot(ui, file_):

707

def debugindexdot(ui, file_):

708

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

708

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

709

r = hg.revlog(hg.~~opener~~(""), file_, "")

709

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

710

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

710

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

711

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

711

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

712

e = r.index[i]

712

e = r.index[i]

713

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

713

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

714

if e[5] != hg.nullid:

714

if e[5] != hg.nullid:

715

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

715

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

716

ui.write("}\n")

716

ui.write("}\n")

717

718

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

718

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

719

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

719

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

720

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

720

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

721

if not items:

721

if not items:

722

return

722

return

723

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

723

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

724

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

724

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

725

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

725

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

726

for src, abs, rel, exact in items:

726

for src, abs, rel, exact in items:

727

ui.write(fmt % (src, abs, rel, exact and 'exact' or ''))

727

ui.write(fmt % (src, abs, rel, exact and 'exact' or ''))

728

729

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

729

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

730

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

730

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

731

node1, node2 = None, None

731

node1, node2 = None, None

732

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

732

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

733

734

if len(revs) > 0:

734

if len(revs) > 0:

735

node1 = revs[0]

735

node1 = revs[0]

736

if len(revs) > 1:

736

if len(revs) > 1:

737

node2 = revs[1]

737

node2 = revs[1]

738

if len(revs) > 2:

738

if len(revs) > 2:

739

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

739

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

740

741

files = []

741

files = []

742

match = util.always

742

match = util.always

743

if pats:

743

if pats:

744

roots, match, results = makewalk(repo, pats, opts)

744

roots, match, results = makewalk(repo, pats, opts)

745

for src, abs, rel, exact in results:

745

for src, abs, rel, exact in results:

746

files.append(abs)

746

files.append(abs)

747

748

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

748

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

749

text=opts['text'])

749

text=opts['text'])

750

751

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

751

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

752

node = repo.lookup(changeset)

752

node = repo.lookup(changeset)

753

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

753

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

754

change = repo.changelog.read(node)

754

change = repo.changelog.read(node)

755

756

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

756

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

757

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

757

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

758

revwidth=revwidth)

758

revwidth=revwidth)

759

if fp != sys.stdout:

759

if fp != sys.stdout:

760

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

760

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

761

762

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

762

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

763

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

763

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

764

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

764

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

765

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

765

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

766

if other != hg.nullid:

766

if other != hg.nullid:

767

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

767

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

768

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

768

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

769

fp.write("\n\n")

769

fp.write("\n\n")

770

771

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

771

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

772

if fp != sys.stdout:

772

if fp != sys.stdout:

773

fp.close()

773

fp.close()

774

775

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

775

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

776

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

776

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

777

if not changesets:

777

if not changesets:

778

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

778

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

779

seqno = 0

779

seqno = 0

780

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

780

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

781

total = len(revs)

781

total = len(revs)

782

revwidth = max(map(len, revs))

782

revwidth = max(map(len, revs))

783

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

783

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

784

for cset in revs:

784

for cset in revs:

785

seqno += 1

785

seqno += 1

786

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

786

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

787

788

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

788

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

789

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

789

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

790

forget = []

790

forget = []

791

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

791

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

792

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

792

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

793

forget.append(abs)

793

forget.append(abs)

794

if not exact:

794

if not exact:

795

ui.status('forgetting ', rel, '\n')

795

ui.status('forgetting ', rel, '\n')

796

repo.forget(forget)

796

repo.forget(forget)

797

798

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

798

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

799

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

799

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

800

if pattern is None:

800

if pattern is None:

801

pattern = opts['regexp']

801

pattern = opts['regexp']

802

if not pattern:

802

if not pattern:

803

raise util.Abort('no pattern to search for')

803

raise util.Abort('no pattern to search for')

804

reflags = 0

804

reflags = 0

805

if opts['ignore_case']:

805

if opts['ignore_case']:

806

reflags |= re.I

806

reflags |= re.I

807

regexp = re.compile(pattern, reflags)

807

regexp = re.compile(pattern, reflags)

808

sep, end = ':', '\n'

808

sep, end = ':', '\n'

809

if opts['null'] or opts['print0']:

809

if opts['null'] or opts['print0']:

810

sep = end = '\0'

810

sep = end = '\0'

811

812

fcache = {}

812

fcache = {}

813

def getfile(fn):

813

def getfile(fn):

814

if fn not in fcache:

814

if fn not in fcache:

815

fcache[fn] = repo.file(fn)

815

fcache[fn] = repo.file(fn)

816

return fcache[fn]

816

return fcache[fn]

817

818

def matchlines(body):

818

def matchlines(body):

819

begin = 0

819

begin = 0

820

linenum = 0

820

linenum = 0

821

while True:

821

while True:

822

match = regexp.search(body, begin)

822

match = regexp.search(body, begin)

823

if not match:

823

if not match:

824

break

824

break

825

mstart, mend = match.span()

825

mstart, mend = match.span()

826

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

826

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

827

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

827

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

828

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

828

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

829

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

829

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

830

begin = lend + 1

830

begin = lend + 1

831

832

class linestate:

832

class linestate:

833

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

833

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

834

self.line = line

834

self.line = line

835

self.linenum = linenum

835

self.linenum = linenum

836

self.colstart = colstart

836

self.colstart = colstart

837

self.colend = colend

837

self.colend = colend

838

def __eq__(self, other):

838

def __eq__(self, other):

839

return self.line == other.line

839

return self.line == other.line

840

def __hash__(self):

840

def __hash__(self):

841

return hash(self.line)

841

return hash(self.line)

842

843

matches = {}

843

matches = {}

844

def grepbody(fn, rev, body):

844

def grepbody(fn, rev, body):

845

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

845

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

846

m = matches[rev][fn]

846

m = matches[rev][fn]

847

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

847

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

848

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

848

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

849

m[s] = s

849

m[s] = s

850

851

prev = {}

851

prev = {}

852

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

852

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

853

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

853

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

854

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

854

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

855

for l in diff:

855

for l in diff:

856

if incrementing:

856

if incrementing:

857

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

857

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

858

r = rev

858

r = rev

859

else:

859

else:

860

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

860

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

861

r = prev[fn]

861

r = prev[fn]

862

ui.write('%s:%s:%s:%s%s\n' % (fn, r, l.linenum, change, l.line))

862

ui.write('%s:%s:%s:%s%s\n' % (fn, r, l.linenum, change, l.line))

863

864

fstate = {}

864

fstate = {}

865

for st, rev, fns in walkchangerevs(ui, repo, repo.getcwd(), pats, opts):

865

for st, rev, fns in walkchangerevs(ui, repo, repo.getcwd(), pats, opts):

866

if st == 'window':

866

if st == 'window':

867

incrementing = rev

867

incrementing = rev

868

matches.clear()

868

matches.clear()

869

elif st == 'add':

869

elif st == 'add':

870

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

870

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

871

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

871

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

872

matches[rev] = {}

872

matches[rev] = {}

873

for fn in fns:

873

for fn in fns:

874

fstate.setdefault(fn, {})

874

fstate.setdefault(fn, {})

875

try:

875

try:

876

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

876

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

877

except KeyError:

877

except KeyError:

878

pass

878

pass

879

elif st == 'iter':

879

elif st == 'iter':

880

states = matches[rev].items()

880

states = matches[rev].items()

881

states.sort()

881

states.sort()

882

for fn, m in states:

882

for fn, m in states:

883

if incrementing or fstate[fn]:

883

if incrementing or fstate[fn]:

884

display(fn, rev, m, fstate[fn])

884

display(fn, rev, m, fstate[fn])

885

fstate[fn] = m

885

fstate[fn] = m

886

prev[fn] = rev

886

prev[fn] = rev

887

888

if not incrementing:

888

if not incrementing:

889

fstate = fstate.items()

889

fstate = fstate.items()

890

fstate.sort()

890

fstate.sort()

891

for fn, state in fstate:

891

for fn, state in fstate:

892

display(fn, rev, {}, state)

892

display(fn, rev, {}, state)

893

894

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

894

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

895

"""show current repository heads"""

895

"""show current repository heads"""

896

heads = repo.changelog.heads()

896

heads = repo.changelog.heads()

897

br = None

897

br = None

898

if opts['branches']:

898

if opts['branches']:

899

br = repo.branchlookup(heads)

899

br = repo.branchlookup(heads)

900

for n in repo.changelog.heads():

900

for n in repo.changelog.heads():

901

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

901

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

902

903

def identify(ui, repo):

903

def identify(ui, repo):

904

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

904

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

905

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

905

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

906

if not parents:

906

if not parents:

907

ui.write("unknown\n")

907

ui.write("unknown\n")

908

return

908

return

909

910

hexfunc = ui.verbose and hg.hex or hg.short

910

hexfunc = ui.verbose and hg.hex or hg.short

911

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

911

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

912

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

912

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

913

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

913

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

914

915

if not ui.quiet:

915

if not ui.quiet:

916

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

916

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

917

parenttags = ['/'.join(tags)

917

parenttags = ['/'.join(tags)

918

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

918

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

919

# tags for multiple parents separated by ' + '

919

# tags for multiple parents separated by ' + '

920

if parenttags:

920

if parenttags:

921

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

921

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

922

923

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

923

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

924

925

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

925

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

926

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

926

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

927

patches = (patch1,) + patches

927

patches = (patch1,) + patches

928

929

if not opts['force']:

929

if not opts['force']:

930

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

930

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

931

if c or a or d:

931

if c or a or d:

932

ui.warn("abort: outstanding uncommitted changes!\n")

932

ui.warn("abort: outstanding uncommitted changes!\n")

933

return 1

933

return 1

934

935

d = opts["base"]

935

d = opts["base"]

936

strip = opts["strip"]

936

strip = opts["strip"]

937

938

for patch in patches:

938

for patch in patches:

939

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

939

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

940

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

940

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

941

942

message = []

942

message = []

943

user = None

943

user = None

944

hgpatch = False

944

hgpatch = False

945

for line in file(pf):

945

for line in file(pf):

946

line = line.rstrip()

946

line = line.rstrip()

947

if line.startswith("--- ") or line.startswith("diff -r"):

947

if line.startswith("--- ") or line.startswith("diff -r"):

948

break

948

break

949

elif hgpatch:

949

elif hgpatch:

950

# parse values when importing the result of an hg export

950

# parse values when importing the result of an hg export

951

if line.startswith("# User "):

951

if line.startswith("# User "):

952

user = line[7:]

952

user = line[7:]

953

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

953

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

954

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

954

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

955

message.append(line)

955

message.append(line)

956

hgpatch = False

956

hgpatch = False

957

elif line == '# HG changeset patch':

957

elif line == '# HG changeset patch':

958

hgpatch = True

958

hgpatch = True

959

message = [] # We may have collected garbage

959

message = [] # We may have collected garbage

960

else:

960

else:

961

message.append(line)

961

message.append(line)

962

963

# make sure message isn't empty

963

# make sure message isn't empty

964

if not message:

964

if not message:

965

message = "imported patch %s\n" % patch

965

message = "imported patch %s\n" % patch

966

else:

966

else:

967

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

967

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

968

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

968

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

969

970

f = os.popen("patch -p%d < '%s'" % (strip, pf))

970

f = os.popen("patch -p%d < '%s'" % (strip, pf))

971

files = []

971

files = []

972

for l in f.read().splitlines():

972

for l in f.read().splitlines():

973

l.rstrip('\r\n');

973

l.rstrip('\r\n');

974

ui.status("%s\n" % l)

974

ui.status("%s\n" % l)

975

if l.startswith('patching file '):

975

if l.startswith('patching file '):

976

pf = l[14:]

976

pf = l[14:]

977

if pf not in files:

977

if pf not in files:

978

files.append(pf)

978

files.append(pf)

979

patcherr = f.close()

979

patcherr = f.close()

980

if patcherr:

980

if patcherr:

981

raise util.Abort("patch failed")

981

raise util.Abort("patch failed")

982

983

if len(files) > 0:

983

if len(files) > 0:

984

addremove(ui, repo, *files)

984

addremove(ui, repo, *files)

985

repo.commit(files, message, user)

985

repo.commit(files, message, user)

986

987

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

987

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

988

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

988

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

989

source = ui.expandpath(source)

989

source = ui.expandpath(source)

990

other = hg.repository(ui, source)

990

other = hg.repository(ui, source)

991

if not other.local():

991

if not other.local():

992

ui.warn("abort: incoming doesn't work for remote"

992

ui.warn("abort: incoming doesn't work for remote"

993

+ " repositories yet, sorry!\n")

993

+ " repositories yet, sorry!\n")

994

return 1

994

return 1

995

o = repo.findincoming(other)

995

o = repo.findincoming(other)

996

if not o:

996

if not o:

997

return

997

return

998

o = other.newer(o)

998

o = other.newer(o)

999

o.reverse()

999

o.reverse()

1000

for n in o:

1000

for n in o:

1001

show_changeset(ui, other, changenode=n)

1001

show_changeset(ui, other, changenode=n)

1002

1003

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

1003

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

1004

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

1004

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

1005

if not os.path.exists(dest):

1005

if not os.path.exists(dest):

1006

os.mkdir(dest)

1006

os.mkdir(dest)

1007

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

1007

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

1008

1009

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

1009

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

1010

"""locate files matching specific patterns"""

1010

"""locate files matching specific patterns"""

1011

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

1011

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

1012

1013

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

1013

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

1014

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

1014

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

1015

continue

1015

continue

1016

if opts['fullpath']:

1016

if opts['fullpath']:

1017

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

1017

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

1018

else:

1018

else:

1019

ui.write(rel, end)

1019

ui.write(rel, end)

1020

1021

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

1021

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

1022

"""show revision history of entire repository or files"""

1022

"""show revision history of entire repository or files"""

1023

class dui:

1023

class dui:

1024

# Implement and delegate some ui protocol. Save hunks of

1024

# Implement and delegate some ui protocol. Save hunks of

1025

# output for later display in the desired order.

1025

# output for later display in the desired order.

1026

def __init__(self, ui):

1026

def __init__(self, ui):

1027

self.ui = ui

1027

self.ui = ui

1028

self.hunk = {}

1028

self.hunk = {}

1029

def bump(self, rev):

1029

def bump(self, rev):

1030

self.rev = rev

1030

self.rev = rev

1031

self.hunk[rev] = []

1031

self.hunk[rev] = []

1032

def note(self, *args):

1032

def note(self, *args):

1033

if self.verbose:

1033

if self.verbose:

1034

self.write(*args)

1034

self.write(*args)

1035

def status(self, *args):

1035

def status(self, *args):

1036

if not self.quiet:

1036

if not self.quiet:

1037

self.write(*args)

1037

self.write(*args)

1038

def write(self, *args):

1038

def write(self, *args):

1039

self.hunk[self.rev].append(args)

1039

self.hunk[self.rev].append(args)

1040

def __getattr__(self, key):

1040

def __getattr__(self, key):

1041

return getattr(self.ui, key)

1041

return getattr(self.ui, key)

1042

cwd = repo.getcwd()

1042

cwd = repo.getcwd()

1043

if not pats and cwd:

1043

if not pats and cwd:

1044

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

1044

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

1045

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

1045

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

1046

for st, rev, fns in walkchangerevs(ui, repo, (pats and cwd) or '', pats,

1046

for st, rev, fns in walkchangerevs(ui, repo, (pats and cwd) or '', pats,

1047

opts):

1047

opts):

1048

if st == 'window':

1048

if st == 'window':

1049

du = dui(ui)

1049

du = dui(ui)

1050

elif st == 'add':

1050

elif st == 'add':

1051

du.bump(rev)

1051

du.bump(rev)

1052

show_changeset(du, repo, rev)

1052

show_changeset(du, repo, rev)

1053

if opts['patch']:

1053

if opts['patch']:

1054

changenode = repo.changelog.node(rev)

1054

changenode = repo.changelog.node(rev)

1055

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

1055

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

1056

dodiff(du, du, repo, prev, changenode, fns)

1056

dodiff(du, du, repo, prev, changenode, fns)

1057

du.write("\n\n")

1057

du.write("\n\n")

1058

elif st == 'iter':

1058

elif st == 'iter':

1059

for args in du.hunk[rev]:

1059

for args in du.hunk[rev]:

1060

ui.write(*args)

1060

ui.write(*args)

1061

1062

def manifest(ui, repo, rev=None):

1062

def manifest(ui, repo, rev=None):

1063

"""output the latest or given revision of the project manifest"""

1063

"""output the latest or given revision of the project manifest"""

1064

if rev:

1064

if rev:

1065

try:

1065

try:

1066

# assume all revision numbers are for changesets

1066

# assume all revision numbers are for changesets

1067

n = repo.lookup(rev)

1067

n = repo.lookup(rev)

1068

change = repo.changelog.read(n)

1068

change = repo.changelog.read(n)

1069

n = change[0]

1069

n = change[0]

1070

except hg.RepoError:

1070

except hg.RepoError:

1071

n = repo.manifest.lookup(rev)

1071

n = repo.manifest.lookup(rev)

1072

else:

1072

else:

1073

n = repo.manifest.tip()

1073

n = repo.manifest.tip()

1074

m = repo.manifest.read(n)

1074

m = repo.manifest.read(n)

1075

mf = repo.manifest.readflags(n)

1075

mf = repo.manifest.readflags(n)

1076

files = m.keys()

1076

files = m.keys()

1077

files.sort()

1077

files.sort()

1078

1079

for f in files:

1079

for f in files:

1080

ui.write("%40s %3s %s\n" % (hg.hex(m[f]), mf[f] and "755" or "644", f))

1080

ui.write("%40s %3s %s\n" % (hg.hex(m[f]), mf[f] and "755" or "644", f))

1081

1082

def outgoing(ui, repo, dest="default-push"):

1082

def outgoing(ui, repo, dest="default-push"):

1083

"""show changesets not found in destination"""

1083

"""show changesets not found in destination"""

1084

dest = ui.expandpath(dest)

1084

dest = ui.expandpath(dest)

1085

other = hg.repository(ui, dest)

1085

other = hg.repository(ui, dest)

1086

o = repo.findoutgoing(other)

1086

o = repo.findoutgoing(other)

1087

o = repo.newer(o)

1087

o = repo.newer(o)

1088

o.reverse()

1088

o.reverse()

1089

for n in o:

1089

for n in o:

1090

show_changeset(ui, repo, changenode=n)

1090

show_changeset(ui, repo, changenode=n)

1091

1092

def parents(ui, repo, rev=None):

1092

def parents(ui, repo, rev=None):

1093

"""show the parents of the working dir or revision"""

1093

"""show the parents of the working dir or revision"""

1094

if rev:

1094

if rev:

1095

p = repo.changelog.parents(repo.lookup(rev))

1095

p = repo.changelog.parents(repo.lookup(rev))

1096

else:

1096

else:

1097

p = repo.dirstate.parents()

1097

p = repo.dirstate.parents()

1098

1099

for n in p:

1099

for n in p:

1100

if n != hg.nullid:

1100

if n != hg.nullid:

1101

show_changeset(ui, repo, changenode=n)

1101

show_changeset(ui, repo, changenode=n)

1102

1103

def paths(ui, search=None):

1103

def paths(ui, search=None):

1104

"""show definition of symbolic path names"""

1104

"""show definition of symbolic path names"""

1105

try:

1105

try:

1106

repo = hg.repository(ui=ui)

1106

repo = hg.repository(ui=ui)

1107

except hg.RepoError:

1107

except hg.RepoError:

1108

pass

1108

pass

1109

1110

if search:

1110

if search:

1111

for name, path in ui.configitems("paths"):

1111

for name, path in ui.configitems("paths"):

1112

if name == search:

1112

if name == search:

1113

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

1113

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

1114

return

1114

return

1115

ui.warn("not found!\n")

1115

ui.warn("not found!\n")

1116

return 1

1116

return 1

1117

else:

1117

else:

1118

for name, path in ui.configitems("paths"):

1118

for name, path in ui.configitems("paths"):

1119

ui.write("%s = %s\n" % (name, path))

1119

ui.write("%s = %s\n" % (name, path))

1120

1121

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

1121

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

1122

"""pull changes from the specified source"""

1122

"""pull changes from the specified source"""

1123

source = ui.expandpath(source)

1123

source = ui.expandpath(source)

1124

ui.status('pulling from %s\n' % (source))

1124

ui.status('pulling from %s\n' % (source))

1125

1126

if opts['ssh']:

1126

if opts['ssh']:

1127

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

1127

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

1128

if opts['remotecmd']:

1128

if opts['remotecmd']:

1129

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

1129

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

1130

1131

other = hg.repository(ui, source)

1131

other = hg.repository(ui, source)

1132

r = repo.pull(other)

1132

r = repo.pull(other)

1133

if not r:

1133

if not r:

1134

if opts['update']:

1134

if opts['update']:

1135

return update(ui, repo)

1135

return update(ui, repo)

1136

else:

1136

else:

1137

ui.status("(run 'hg update' to get a working copy)\n")

1137

ui.status("(run 'hg update' to get a working copy)\n")

1138

1139

return r

1139

return r

1140

1141

def push(ui, repo, dest="default-push", force=False, ssh=None, remotecmd=None):

1141

def push(ui, repo, dest="default-push", force=False, ssh=None, remotecmd=None):

1142

"""push changes to the specified destination"""

1142

"""push changes to the specified destination"""

1143

dest = ui.expandpath(dest)

1143

dest = ui.expandpath(dest)

1144

ui.status('pushing to %s\n' % (dest))

1144

ui.status('pushing to %s\n' % (dest))

1145

1146

if ssh:

1146

if ssh:

1147

ui.setconfig("ui", "ssh", ssh)

1147

ui.setconfig("ui", "ssh", ssh)

1148

if remotecmd:

1148

if remotecmd:

1149

ui.setconfig("ui", "remotecmd", remotecmd)

1149

ui.setconfig("ui", "remotecmd", remotecmd)

1150

1151

other = hg.repository(ui, dest)

1151

other = hg.repository(ui, dest)

1152

r = repo.push(other, force)

1152

r = repo.push(other, force)

1153

return r

1153

return r

1154

1155

def rawcommit(ui, repo, *flist, **rc):

1155

def rawcommit(ui, repo, *flist, **rc):

1156

"raw commit interface"

1156

"raw commit interface"

1157

if rc['text']:

1157

if rc['text']:

1158

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

1158

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

1159

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

1159

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

1160

message = rc['message'] or rc['text']

1160

message = rc['message'] or rc['text']

1161

if not message and rc['logfile']:

1161

if not message and rc['logfile']:

1162

try:

1162

try:

1163

message = open(rc['logfile']).read()

1163

message = open(rc['logfile']).read()

1164

except IOError:

1164

except IOError:

1165

pass

1165

pass

1166

if not message and not rc['logfile']:

1166

if not message and not rc['logfile']:

1167

ui.warn("abort: missing commit message\n")

1167

ui.warn("abort: missing commit message\n")

1168

return 1

1168

return 1

1169

1170

files = relpath(repo, list(flist))

1170

files = relpath(repo, list(flist))

1171

if rc['files']:

1171

if rc['files']:

1172

files += open(rc['files']).read().splitlines()

1172

files += open(rc['files']).read().splitlines()

1173

1174

rc['parent'] = map(repo.lookup, rc['parent'])

1174

rc['parent'] = map(repo.lookup, rc['parent'])

1175

1176

repo.rawcommit(files, message, rc['user'], rc['date'], *rc['parent'])

1176

repo.rawcommit(files, message, rc['user'], rc['date'], *rc['parent'])

1177

1178

def recover(ui, repo):

1178

def recover(ui, repo):

1179

"""roll back an interrupted transaction"""

1179

"""roll back an interrupted transaction"""

1180

repo.recover()

1180

repo.recover()

1181

1182

def remove(ui, repo, file1, *files):

1182

def remove(ui, repo, file1, *files):

1183

"""remove the specified files on the next commit"""

1183

"""remove the specified files on the next commit"""

1184

repo.remove(relpath(repo, (file1,) + files))

1184

repo.remove(relpath(repo, (file1,) + files))

1185

1186

def revert(ui, repo, *names, **opts):

1186

def revert(ui, repo, *names, **opts):

1187

"""revert modified files or dirs back to their unmodified states"""

1187

"""revert modified files or dirs back to their unmodified states"""

1188

node = opts['rev'] and repo.lookup(opts['rev']) or \

1188

node = opts['rev'] and repo.lookup(opts['rev']) or \

1189

repo.dirstate.parents()[0]

1189

repo.dirstate.parents()[0]

1190

root = os.path.realpath(repo.root)

1190

root = os.path.realpath(repo.root)

1191

1192

def trimpath(p):

1192

def trimpath(p):

1193

p = os.path.realpath(p)

1193

p = os.path.realpath(p)

1194

if p.startswith(root):

1194

if p.startswith(root):

1195

rest = p[len(root):]

1195

rest = p[len(root):]

1196

if not rest:

1196

if not rest:

1197

return rest

1197

return rest

1198

if p.startswith(os.sep):

1198

if p.startswith(os.sep):

1199

return rest[1:]

1199

return rest[1:]

1200

return p

1200

return p

1201

1202

relnames = map(trimpath, names or [os.getcwd()])

1202

relnames = map(trimpath, names or [os.getcwd()])

1203

chosen = {}

1203

chosen = {}

1204

1205

def choose(name):

1205

def choose(name):

1206

def body(name):

1206

def body(name):

1207

for r in relnames:

1207

for r in relnames:

1208

if not name.startswith(r):

1208

if not name.startswith(r):

1209

continue

1209

continue

1210

rest = name[len(r):]

1210

rest = name[len(r):]

1211

if not rest:

1211

if not rest:

1212

return r, True

1212

return r, True

1213

depth = rest.count(os.sep)

1213

depth = rest.count(os.sep)

1214

if not r:

1214

if not r:

1215

if depth == 0 or not opts['nonrecursive']:

1215

if depth == 0 or not opts['nonrecursive']:

1216

return r, True

1216

return r, True

1217

elif rest[0] == os.sep:

1217

elif rest[0] == os.sep:

1218

if depth == 1 or not opts['nonrecursive']:

1218

if depth == 1 or not opts['nonrecursive']:

1219

return r, True

1219

return r, True

1220

return None, False

1220

return None, False

1221

relname, ret = body(name)

1221

relname, ret = body(name)

1222

if ret:

1222

if ret:

1223

chosen[relname] = 1

1223

chosen[relname] = 1

1224

return ret

1224

return ret

1225

1226

r = repo.update(node, False, True, choose, False)

1226

r = repo.update(node, False, True, choose, False)

1227

for n in relnames:

1227

for n in relnames:

1228

if n not in chosen:

1228

if n not in chosen:

1229

ui.warn('error: no matches for %s\n' % n)

1229

ui.warn('error: no matches for %s\n' % n)

1230

r = 1

1230

r = 1

1231

sys.stdout.flush()

1231

sys.stdout.flush()

1232

return r

1232

return r

1233

1234

def root(ui, repo):

1234

def root(ui, repo):

1235

"""print the root (top) of the current working dir"""

1235

"""print the root (top) of the current working dir"""

1236

ui.write(repo.root + "\n")

1236

ui.write(repo.root + "\n")

1237

1238

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

1238

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

1239

"""export the repository via HTTP"""

1239

"""export the repository via HTTP"""

1240

1241

if opts["stdio"]:

1241

if opts["stdio"]:

1242

fin, fout = sys.stdin, sys.stdout

1242

fin, fout = sys.stdin, sys.stdout

1243

sys.stdout = sys.stderr

1243

sys.stdout = sys.stderr

1244

1245

def getarg():

1245

def getarg():

1246

argline = fin.readline()[:-1]

1246

argline = fin.readline()[:-1]

1247

arg, l = argline.split()

1247

arg, l = argline.split()

1248

val = fin.read(int(l))

1248

val = fin.read(int(l))

1249

return arg, val

1249

return arg, val

1250

def respond(v):

1250

def respond(v):

1251

fout.write("%d\n" % len(v))

1251

fout.write("%d\n" % len(v))

1252

fout.write(v)

1252

fout.write(v)

1253

fout.flush()

1253

fout.flush()

1254

1255

lock = None

1255

lock = None

1256

1257

while 1:

1257

while 1:

1258

cmd = fin.readline()[:-1]

1258

cmd = fin.readline()[:-1]

1259

if cmd == '':

1259

if cmd == '':

1260

return

1260

return

1261

if cmd == "heads":

1261

if cmd == "heads":

1262

h = repo.heads()

1262

h = repo.heads()

1263

respond(" ".join(map(hg.hex, h)) + "\n")

1263

respond(" ".join(map(hg.hex, h)) + "\n")

1264

if cmd == "lock":

1264

if cmd == "lock":

1265

lock = repo.lock()

1265

lock = repo.lock()

1266

respond("")

1266

respond("")

1267

if cmd == "unlock":

1267

if cmd == "unlock":

1268

if lock:

1268

if lock:

1269

lock.release()

1269

lock.release()

1270

lock = None

1270

lock = None

1271

respond("")

1271

respond("")

1272

elif cmd == "branches":

1272

elif cmd == "branches":

1273

arg, nodes = getarg()

1273

arg, nodes = getarg()

1274

nodes = map(hg.bin, nodes.split(" "))

1274

nodes = map(hg.bin, nodes.split(" "))

1275

r = []

1275

r = []

1276

for b in repo.branches(nodes):

1276

for b in repo.branches(nodes):

1277

r.append(" ".join(map(hg.hex, b)) + "\n")

1277

r.append(" ".join(map(hg.hex, b)) + "\n")

1278

respond("".join(r))

1278

respond("".join(r))

1279

elif cmd == "between":

1279

elif cmd == "between":

1280

arg, pairs = getarg()

1280

arg, pairs = getarg()

1281

pairs = [map(hg.bin, p.split("-")) for p in pairs.split(" ")]

1281

pairs = [map(hg.bin, p.split("-")) for p in pairs.split(" ")]

1282

r = []

1282

r = []

1283

for b in repo.between(pairs):

1283

for b in repo.between(pairs):

1284

r.append(" ".join(map(hg.hex, b)) + "\n")

1284

r.append(" ".join(map(hg.hex, b)) + "\n")

1285

respond("".join(r))

1285

respond("".join(r))

1286

elif cmd == "changegroup":

1286

elif cmd == "changegroup":

1287

nodes = []

1287

nodes = []

1288

arg, roots = getarg()

1288

arg, roots = getarg()

1289

nodes = map(hg.bin, roots.split(" "))

1289

nodes = map(hg.bin, roots.split(" "))

1290

1291

cg = repo.changegroup(nodes)

1291

cg = repo.changegroup(nodes)

1292

while 1:

1292

while 1:

1293

d = cg.read(4096)

1293

d = cg.read(4096)

1294

if not d:

1294

if not d:

1295

break

1295

break

1296

fout.write(d)

1296

fout.write(d)

1297

1298

fout.flush()

1298

fout.flush()

1299

1300

elif cmd == "addchangegroup":

1300

elif cmd == "addchangegroup":

1301

if not lock:

1301

if not lock:

1302

respond("not locked")

1302

respond("not locked")

1303

continue

1303

continue

1304

respond("")

1304

respond("")

1305

1306

r = repo.addchangegroup(fin)

1306

r = repo.addchangegroup(fin)

1307

respond("")

1307

respond("")

1308

1309

optlist = "name templates style address port ipv6 accesslog errorlog"

1309

optlist = "name templates style address port ipv6 accesslog errorlog"

1310

for o in optlist.split():

1310

for o in optlist.split():

1311

if opts[o]:

1311

if opts[o]:

1312

ui.setconfig("web", o, opts[o])

1312

ui.setconfig("web", o, opts[o])

1313

1314

httpd = hgweb.create_server(repo)

1314

httpd = hgweb.create_server(repo)

1315

1316

if ui.verbose:

1316

if ui.verbose:

1317

addr, port = httpd.socket.getsockname()

1317

addr, port = httpd.socket.getsockname()

1318

if addr == '0.0.0.0':

1318

if addr == '0.0.0.0':

1319

addr = socket.gethostname()

1319

addr = socket.gethostname()

1320

else:

1320

else:

1321

try:

1321

try:

1322

addr = socket.gethostbyaddr(addr)[0]

1322

addr = socket.gethostbyaddr(addr)[0]

1323

except socket.error:

1323

except socket.error:

1324

pass

1324

pass

1325

if port != 80:

1325

if port != 80:

1326

ui.status('listening at http://%s:%d/\n' % (addr, port))

1326

ui.status('listening at http://%s:%d/\n' % (addr, port))

1327

else:

1327

else:

1328

ui.status('listening at http://%s/\n' % addr)

1328

ui.status('listening at http://%s/\n' % addr)

1329

httpd.serve_forever()

1329

httpd.serve_forever()

1330

1331

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

1331

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

1332

'''show changed files in the working directory

1332

'''show changed files in the working directory

1333

1334

M = modified

1334

M = modified

1335

A = added

1335

A = added

1336

R = removed

1336

R = removed

1337

? = not tracked

1337

? = not tracked

1338

'''

1338

'''

1339

1340

cwd = repo.getcwd()

1340

cwd = repo.getcwd()

1341

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

1341

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

1342

(c, a, d, u) = [[util.pathto(cwd, x) for x in n]

1342

(c, a, d, u) = [[util.pathto(cwd, x) for x in n]

1343

for n in repo.changes(files=files, match=matchfn)]

1343

for n in repo.changes(files=files, match=matchfn)]

1344

1345

changetypes = [('modified', 'M', c),

1345

changetypes = [('modified', 'M', c),

1346

('added', 'A', a),

1346

('added', 'A', a),

1347

('removed', 'R', d),

1347

('removed', 'R', d),

1348

('unknown', '?', u)]

1348

('unknown', '?', u)]

1349

1350

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

1350

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

1351

1352

for opt, char, changes in ([ct for ct in changetypes if opts[ct[0]]]

1352

for opt, char, changes in ([ct for ct in changetypes if opts[ct[0]]]

1353

or changetypes):

1353

or changetypes):

1354

if opts['strip']:

1354

if opts['strip']:

1355

format = "%%s%s" % end

1355

format = "%%s%s" % end

1356

else:

1356

else:

1357

format = "%s %%s%s" % (char, end);

1357

format = "%s %%s%s" % (char, end);

1358

1359

for f in changes:

1359

for f in changes:

1360

ui.write(format % f)

1360

ui.write(format % f)

1361

1362

def tag(ui, repo, name, rev=None, **opts):

1362

def tag(ui, repo, name, rev=None, **opts):

1363

"""add a tag for the current tip or a given revision"""

1363

"""add a tag for the current tip or a given revision"""

1364

if opts['text']:

1364

if opts['text']:

1365

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

1365

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

1366

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

1366

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

1367

if name == "tip":

1367

if name == "tip":

1368

ui.warn("abort: 'tip' is a reserved name!\n")

1368

ui.warn("abort: 'tip' is a reserved name!\n")

1369

return -1

1369

return -1

1370

if rev:

1370

if rev:

1371

r = hg.hex(repo.lookup(rev))

1371

r = hg.hex(repo.lookup(rev))

1372

else:

1372

else:

1373

r = hg.hex(repo.changelog.tip())

1373

r = hg.hex(repo.changelog.tip())

1374

1375

if name.find(revrangesep) >= 0:

1375

if name.find(revrangesep) >= 0:

1376

ui.warn("abort: '%s' cannot be used in a tag name\n" % revrangesep)

1376

ui.warn("abort: '%s' cannot be used in a tag name\n" % revrangesep)

1377

return -1

1377

return -1

1378

1379

if opts['local']:

1379

if opts['local']:

1380

repo.opener("localtags", "a").write("%s %s\n" % (r, name))

1380

repo.opener("localtags", "a").write("%s %s\n" % (r, name))

1381

return

1381

return

1382

1383

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

1383

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

1384

for x in (c, a, d, u):

1384

for x in (c, a, d, u):

1385

if ".hgtags" in x:

1385

if ".hgtags" in x:

1386

ui.warn("abort: working copy of .hgtags is changed!\n")

1386

ui.warn("abort: working copy of .hgtags is changed!\n")

1387

ui.status("(please commit .hgtags manually)\n")

1387

ui.status("(please commit .hgtags manually)\n")

1388

return -1

1388

return -1

1389

1390

repo.wfile(".hgtags", "ab").write("%s %s\n" % (r, name))

1390

repo.wfile(".hgtags", "ab").write("%s %s\n" % (r, name))

1391

if repo.dirstate.state(".hgtags") == '?':

1391

if repo.dirstate.state(".hgtags") == '?':

1392

repo.add([".hgtags"])

1392

repo.add([".hgtags"])

1393

1394

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

1394

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

1395

"Added tag %s for changeset %s" % (name, r))

1395

"Added tag %s for changeset %s" % (name, r))

1396

repo.commit([".hgtags"], message, opts['user'], opts['date'])

1396

repo.commit([".hgtags"], message, opts['user'], opts['date'])

1397

1398

def tags(ui, repo):

1398

def tags(ui, repo):

1399

"""list repository tags"""

1399

"""list repository tags"""

1400

1401

l = repo.tagslist()

1401

l = repo.tagslist()

1402

l.reverse()

1402

l.reverse()

1403

for t, n in l:

1403

for t, n in l:

1404

try:

1404

try:

1405

r = "%5d:%s" % (repo.changelog.rev(n), hg.hex(n))

1405

r = "%5d:%s" % (repo.changelog.rev(n), hg.hex(n))

1406

except KeyError:

1406

except KeyError:

1407

r = " ?:?"

1407

r = " ?:?"

1408

ui.write("%-30s %s\n" % (t, r))

1408

ui.write("%-30s %s\n" % (t, r))

1409

1410

def tip(ui, repo):

1410

def tip(ui, repo):

1411

"""show the tip revision"""

1411

"""show the tip revision"""

1412

n = repo.changelog.tip()

1412

n = repo.changelog.tip()

1413

show_changeset(ui, repo, changenode=n)

1413

show_changeset(ui, repo, changenode=n)

1414

1415

def undo(ui, repo):

1415

def undo(ui, repo):

1416

"""undo the last commit or pull

1416

"""undo the last commit or pull

1417

1418

Roll back the last pull or commit transaction on the

1418

Roll back the last pull or commit transaction on the

1419

repository, restoring the project to its earlier state.

1419

repository, restoring the project to its earlier state.

1420

1421

This command should be used with care. There is only one level of

1421

This command should be used with care. There is only one level of

1422

undo and there is no redo.

1422

undo and there is no redo.

1423

1424

This command is not intended for use on public repositories. Once

1424

This command is not intended for use on public repositories. Once

1425

a change is visible for pull by other users, undoing it locally is

1425

a change is visible for pull by other users, undoing it locally is

1426

ineffective.

1426

ineffective.

1427

"""

1427

"""

1428

repo.undo()

1428

repo.undo()

1429

1430

def update(ui, repo, node=None, merge=False, clean=False, branch=None):

1430

def update(ui, repo, node=None, merge=False, clean=False, branch=None):

1431

'''update or merge working directory

1431

'''update or merge working directory

1432

1433

If there are no outstanding changes in the working directory and

1433

If there are no outstanding changes in the working directory and

1434

there is a linear relationship between the current version and the

1434

there is a linear relationship between the current version and the

1435

requested version, the result is the requested version.

1435

requested version, the result is the requested version.

1436

1437

Otherwise the result is a merge between the contents of the

1437

Otherwise the result is a merge between the contents of the

1438

current working directory and the requested version. Files that

1438

current working directory and the requested version. Files that

1439

changed between either parent are marked as changed for the next

1439

changed between either parent are marked as changed for the next

1440

commit and a commit must be performed before any further updates

1440

commit and a commit must be performed before any further updates

1441

are allowed.

1441

are allowed.

1442

'''

1442

'''

1443

if branch:

1443

if branch:

1444

br = repo.branchlookup(branch=branch)

1444

br = repo.branchlookup(branch=branch)

1445

found = []

1445

found = []

1446

for x in br:

1446

for x in br:

1447

if branch in br[x]:

1447

if branch in br[x]:

1448

found.append(x)

1448

found.append(x)

1449

if len(found) > 1:

1449

if len(found) > 1:

1450

ui.warn("Found multiple heads for %s\n" % branch)

1450

ui.warn("Found multiple heads for %s\n" % branch)

1451

for x in found:

1451

for x in found:

1452

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

1452

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

1453

return 1

1453

return 1

1454

if len(found) == 1:

1454

if len(found) == 1:

1455

node = found[0]

1455

node = found[0]

1456

ui.warn("Using head %s for branch %s\n" % (hg.short(node), branch))

1456

ui.warn("Using head %s for branch %s\n" % (hg.short(node), branch))

1457

else:

1457

else:

1458

ui.warn("branch %s not found\n" % (branch))

1458

ui.warn("branch %s not found\n" % (branch))

1459

return 1

1459

return 1

1460

else:

1460

else:

1461

node = node and repo.lookup(node) or repo.changelog.tip()

1461

node = node and repo.lookup(node) or repo.changelog.tip()

1462

return repo.update(node, allow=merge, force=clean)

1462

return repo.update(node, allow=merge, force=clean)

1463

1464

def verify(ui, repo):

1464

def verify(ui, repo):

1465

"""verify the integrity of the repository"""

1465

"""verify the integrity of the repository"""

1466

return repo.verify()

1466

return repo.verify()

1467

1468

# Command options and aliases are listed here, alphabetically

1468

# Command options and aliases are listed here, alphabetically

1469

1470

table = {

1470

table = {

1471

"^add":

1471

"^add":

1472

(add,

1472

(add,

1473

[('I', 'include', [], 'include path in search'),

1473

[('I', 'include', [], 'include path in search'),

1474

('X', 'exclude', [], 'exclude path from search')],

1474

('X', 'exclude', [], 'exclude path from search')],

1475

"hg add [OPTION]... [FILE]..."),

1475

"hg add [OPTION]... [FILE]..."),

1476

"addremove":

1476

"addremove":

1477

(addremove,

1477

(addremove,

1478

[('I', 'include', [], 'include path in search'),

1478

[('I', 'include', [], 'include path in search'),

1479

('X', 'exclude', [], 'exclude path from search')],

1479

('X', 'exclude', [], 'exclude path from search')],

1480

"hg addremove [OPTION]... [FILE]..."),

1480

"hg addremove [OPTION]... [FILE]..."),

1481

"^annotate":

1481

"^annotate":

1482

(annotate,

1482

(annotate,

1483

[('r', 'rev', '', 'revision'),

1483

[('r', 'rev', '', 'revision'),

1484

('a', 'text', None, 'treat all files as text'),

1484

('a', 'text', None, 'treat all files as text'),

1485

('u', 'user', None, 'show user'),

1485

('u', 'user', None, 'show user'),

1486

('n', 'number', None, 'show revision number'),

1486

('n', 'number', None, 'show revision number'),

1487

('c', 'changeset', None, 'show changeset'),

1487

('c', 'changeset', None, 'show changeset'),

1488

('I', 'include', [], 'include path in search'),

1488

('I', 'include', [], 'include path in search'),

1489

('X', 'exclude', [], 'exclude path from search')],

1489

('X', 'exclude', [], 'exclude path from search')],

1490

'hg annotate [OPTION]... FILE...'),

1490

'hg annotate [OPTION]... FILE...'),

1491

"cat":

1491

"cat":

1492

(cat,

1492

(cat,

1493

[('o', 'output', "", 'output to file')],

1493

[('o', 'output', "", 'output to file')],

1494

'hg cat [-o OUTFILE] FILE [REV]'),

1494

'hg cat [-o OUTFILE] FILE [REV]'),

1495

"^clone":

1495

"^clone":

1496

(clone,

1496

(clone,

1497

[('U', 'noupdate', None, 'skip update after cloning'),

1497

[('U', 'noupdate', None, 'skip update after cloning'),

1498

('e', 'ssh', "", 'ssh command'),

1498

('e', 'ssh', "", 'ssh command'),

1499

('', 'remotecmd', "", 'remote hg command')],

1499

('', 'remotecmd', "", 'remote hg command')],

1500

'hg clone [OPTION]... SOURCE [DEST]'),

1500

'hg clone [OPTION]... SOURCE [DEST]'),

1501

"^commit|ci":

1501

"^commit|ci":

1502

(commit,

1502

(commit,

1503

[('A', 'addremove', None, 'run add/remove during commit'),

1503

[('A', 'addremove', None, 'run add/remove during commit'),

1504

('I', 'include', [], 'include path in search'),

1504

('I', 'include', [], 'include path in search'),

1505

('X', 'exclude', [], 'exclude path from search'),

1505

('X', 'exclude', [], 'exclude path from search'),

1506

('m', 'message', "", 'commit message'),

1506

('m', 'message', "", 'commit message'),

1507

('t', 'text', "", 'commit message (deprecated: use -m)'),

1507

('t', 'text', "", 'commit message (deprecated: use -m)'),

1508

('l', 'logfile', "", 'commit message file'),

1508

('l', 'logfile', "", 'commit message file'),

1509

('d', 'date', "", 'date code'),

1509

('d', 'date', "", 'date code'),

1510

('u', 'user', "", 'user')],

1510

('u', 'user', "", 'user')],

1511

'hg commit [OPTION]... [FILE]...'),

1511

'hg commit [OPTION]... [FILE]...'),

1512

"copy": (copy, [], 'hg copy SOURCE DEST'),

1512

"copy": (copy, [], 'hg copy SOURCE DEST'),

1513

"debugcheckstate": (debugcheckstate, [], 'debugcheckstate'),

1513

"debugcheckstate": (debugcheckstate, [], 'debugcheckstate'),

1514

"debugconfig": (debugconfig, [], 'debugconfig'),

1514

"debugconfig": (debugconfig, [], 'debugconfig'),

1515

"debugstate": (debugstate, [], 'debugstate'),

1515

"debugstate": (debugstate, [], 'debugstate'),

1516

"debugdata": (debugdata, [], 'debugdata FILE REV'),

1516

"debugdata": (debugdata, [], 'debugdata FILE REV'),

1517

"debugindex": (debugindex, [], 'debugindex FILE'),

1517

"debugindex": (debugindex, [], 'debugindex FILE'),

1518

"debugindexdot": (debugindexdot, [], 'debugindexdot FILE'),

1518

"debugindexdot": (debugindexdot, [], 'debugindexdot FILE'),

1519

"debugwalk":

1519

"debugwalk":

1520

(debugwalk,

1520

(debugwalk,

1521

[('I', 'include', [], 'include path in search'),

1521

[('I', 'include', [], 'include path in search'),

1522

('X', 'exclude', [], 'exclude path from search')],

1522

('X', 'exclude', [], 'exclude path from search')],

1523

'debugwalk [OPTION]... [FILE]...'),

1523

'debugwalk [OPTION]... [FILE]...'),

1524

"^diff":

1524

"^diff":

1525

(diff,

1525

(diff,

1526

[('r', 'rev', [], 'revision'),

1526

[('r', 'rev', [], 'revision'),

1527

('a', 'text', None, 'treat all files as text'),

1527

('a', 'text', None, 'treat all files as text'),

1528

('I', 'include', [], 'include path in search'),

1528

('I', 'include', [], 'include path in search'),

1529

('X', 'exclude', [], 'exclude path from search')],

1529

('X', 'exclude', [], 'exclude path from search')],

1530

'hg diff [-a] [-I] [-X] [-r REV1 [-r REV2]] [FILE]...'),

1530

'hg diff [-a] [-I] [-X] [-r REV1 [-r REV2]] [FILE]...'),

1531

"^export":

1531

"^export":

1532

(export,

1532

(export,

1533

[('o', 'output', "", 'output to file'),

1533

[('o', 'output', "", 'output to file'),

1534

('a', 'text', None, 'treat all files as text')],

1534

('a', 'text', None, 'treat all files as text')],

1535

"hg export [-a] [-o OUTFILE] REV..."),

1535

"hg export [-a] [-o OUTFILE] REV..."),

1536

"forget":

1536

"forget":

1537

(forget,

1537

(forget,

1538

[('I', 'include', [], 'include path in search'),

1538

[('I', 'include', [], 'include path in search'),

1539

('X', 'exclude', [], 'exclude path from search')],

1539

('X', 'exclude', [], 'exclude path from search')],

1540

"hg forget [OPTION]... FILE..."),

1540

"hg forget [OPTION]... FILE..."),

1541

"grep":

1541

"grep":

1542

(grep,

1542

(grep,

1543

[('0', 'print0', None, 'terminate file names with NUL'),

1543

[('0', 'print0', None, 'terminate file names with NUL'),

1544

('I', 'include', [], 'include path in search'),

1544

('I', 'include', [], 'include path in search'),

1545

('X', 'exclude', [], 'include path in search'),

1545

('X', 'exclude', [], 'include path in search'),

1546

('Z', 'null', None, 'terminate file names with NUL'),

1546

('Z', 'null', None, 'terminate file names with NUL'),

1547

('a', 'all-revs', '', 'search all revs'),

1547

('a', 'all-revs', '', 'search all revs'),

1548

('e', 'regexp', '', 'pattern to search for'),

1548

('e', 'regexp', '', 'pattern to search for'),

1549

('f', 'full-path', None, 'print complete paths'),

1549

('f', 'full-path', None, 'print complete paths'),

1550

('i', 'ignore-case', None, 'ignore case when matching'),

1550

('i', 'ignore-case', None, 'ignore case when matching'),

1551

('l', 'files-with-matches', None, 'print names of files with matches'),

1551

('l', 'files-with-matches', None, 'print names of files with matches'),

1552

('n', 'line-number', '', 'print line numbers'),

1552

('n', 'line-number', '', 'print line numbers'),

1553

('r', 'rev', [], 'search in revision rev'),

1553

('r', 'rev', [], 'search in revision rev'),

1554

('s', 'no-messages', None, 'do not print error messages'),

1554

('s', 'no-messages', None, 'do not print error messages'),

1555

('v', 'invert-match', None, 'select non-matching lines')],

1555

('v', 'invert-match', None, 'select non-matching lines')],

1556

"hg grep [OPTION]... [PATTERN] [FILE]..."),

1556

"hg grep [OPTION]... [PATTERN] [FILE]..."),

1557

"heads":

1557

"heads":

1558

(heads,

1558

(heads,

1559

[('b', 'branches', None, 'find branch info')],

1559

[('b', 'branches', None, 'find branch info')],

1560

'hg heads [-b]'),

1560

'hg heads [-b]'),

1561

"help": (help_, [], 'hg help [COMMAND]'),

1561

"help": (help_, [], 'hg help [COMMAND]'),

1562

"identify|id": (identify, [], 'hg identify'),

1562

"identify|id": (identify, [], 'hg identify'),

1563

"import|patch":

1563

"import|patch":

1564

(import_,

1564

(import_,

1565

[('p', 'strip', 1, 'path strip'),

1565

[('p', 'strip', 1, 'path strip'),

1566

('f', 'force', None, 'skip check for outstanding changes'),

1566

('f', 'force', None, 'skip check for outstanding changes'),

1567

('b', 'base', "", 'base path')],

1567

('b', 'base', "", 'base path')],

1568

"hg import [-f] [-p NUM] [-b BASE] PATCH..."),

1568

"hg import [-f] [-p NUM] [-b BASE] PATCH..."),

1569

"incoming|in": (incoming, [], 'hg incoming [SOURCE]'),

1569

"incoming|in": (incoming, [], 'hg incoming [SOURCE]'),

1570

"^init": (init, [], 'hg init [DEST]'),

1570

"^init": (init, [], 'hg init [DEST]'),

1571

"locate":

1571

"locate":

1572

(locate,

1572

(locate,

1573

[('r', 'rev', '', 'revision'),

1573

[('r', 'rev', '', 'revision'),

1574

('0', 'print0', None, 'end records with NUL'),

1574

('0', 'print0', None, 'end records with NUL'),

1575

('f', 'fullpath', None, 'print complete paths'),

1575

('f', 'fullpath', None, 'print complete paths'),

1576

('I', 'include', [], 'include path in search'),

1576

('I', 'include', [], 'include path in search'),

1577

('X', 'exclude', [], 'exclude path from search')],

1577

('X', 'exclude', [], 'exclude path from search')],

1578

'hg locate [OPTION]... [PATTERN]...'),

1578

'hg locate [OPTION]... [PATTERN]...'),

1579

"^log|history":

1579

"^log|history":

1580

(log,

1580

(log,

1581

[('I', 'include', [], 'include path in search'),

1581

[('I', 'include', [], 'include path in search'),

1582

('X', 'exclude', [], 'exclude path from search'),

1582

('X', 'exclude', [], 'exclude path from search'),

1583

('r', 'rev', [], 'revision'),

1583

('r', 'rev', [], 'revision'),

1584

('p', 'patch', None, 'show patch')],

1584

('p', 'patch', None, 'show patch')],

1585

'hg log [-I] [-X] [-r REV]... [-p] [FILE]'),

1585

'hg log [-I] [-X] [-r REV]... [-p] [FILE]'),

1586

"manifest": (manifest, [], 'hg manifest [REV]'),

1586

"manifest": (manifest, [], 'hg manifest [REV]'),

1587

"outgoing|out": (outgoing, [], 'hg outgoing [DEST]'),

1587

"outgoing|out": (outgoing, [], 'hg outgoing [DEST]'),

1588

"parents": (parents, [], 'hg parents [REV]'),

1588

"parents": (parents, [], 'hg parents [REV]'),

1589

"paths": (paths, [], 'hg paths [NAME]'),

1589

"paths": (paths, [], 'hg paths [NAME]'),

1590

"^pull":

1590

"^pull":

1591

(pull,

1591

(pull,

1592

[('u', 'update', None, 'update working directory'),

1592

[('u', 'update', None, 'update working directory'),

1593

('e', 'ssh', "", 'ssh command'),

1593

('e', 'ssh', "", 'ssh command'),

1594

('', 'remotecmd', "", 'remote hg command')],

1594

('', 'remotecmd', "", 'remote hg command')],

1595

'hg pull [-u] [-e FILE] [--remotecmd FILE] [SOURCE]'),

1595

'hg pull [-u] [-e FILE] [--remotecmd FILE] [SOURCE]'),

1596

"^push":

1596

"^push":

1597

(push,

1597

(push,

1598

[('f', 'force', None, 'force push'),

1598

[('f', 'force', None, 'force push'),

1599

('e', 'ssh', "", 'ssh command'),

1599

('e', 'ssh', "", 'ssh command'),

1600

('', 'remotecmd', "", 'remote hg command')],

1600

('', 'remotecmd', "", 'remote hg command')],

1601

'hg push [-f] [-e FILE] [--remotecmd FILE] [DEST]'),

1601

'hg push [-f] [-e FILE] [--remotecmd FILE] [DEST]'),

1602

"rawcommit":

1602

"rawcommit":

1603

(rawcommit,

1603

(rawcommit,

1604

[('p', 'parent', [], 'parent'),

1604

[('p', 'parent', [], 'parent'),

1605

('d', 'date', "", 'date code'),

1605

('d', 'date', "", 'date code'),

1606

('u', 'user', "", 'user'),

1606

('u', 'user', "", 'user'),

1607

('F', 'files', "", 'file list'),

1607

('F', 'files', "", 'file list'),

1608

('m', 'message', "", 'commit message'),

1608

('m', 'message', "", 'commit message'),

1609

('t', 'text', "", 'commit message (deprecated: use -m)'),

1609

('t', 'text', "", 'commit message (deprecated: use -m)'),

1610

('l', 'logfile', "", 'commit message file')],

1610

('l', 'logfile', "", 'commit message file')],

1611

'hg rawcommit [OPTION]... [FILE]...'),

1611

'hg rawcommit [OPTION]... [FILE]...'),

1612

"recover": (recover, [], "hg recover"),

1612

"recover": (recover, [], "hg recover"),

1613

"^remove|rm": (remove, [], "hg remove FILE..."),

1613

"^remove|rm": (remove, [], "hg remove FILE..."),

1614

"^revert":

1614

"^revert":

1615

(revert,

1615

(revert,

1616

[("n", "nonrecursive", None, "don't recurse into subdirs"),

1616

[("n", "nonrecursive", None, "don't recurse into subdirs"),

1617

("r", "rev", "", "revision")],

1617

("r", "rev", "", "revision")],

1618

"hg revert [-n] [-r REV] [NAME]..."),

1618

"hg revert [-n] [-r REV] [NAME]..."),

1619

"root": (root, [], "hg root"),

1619

"root": (root, [], "hg root"),

1620

"^serve":

1620

"^serve":

1621

(serve,

1621

(serve,

1622

[('A', 'accesslog', '', 'access log file'),

1622

[('A', 'accesslog', '', 'access log file'),

1623

('E', 'errorlog', '', 'error log file'),

1623

('E', 'errorlog', '', 'error log file'),

1624

('p', 'port', 0, 'listen port'),

1624

('p', 'port', 0, 'listen port'),

1625

('a', 'address', '', 'interface address'),

1625

('a', 'address', '', 'interface address'),

1626

('n', 'name', "", 'repository name'),

1626

('n', 'name', "", 'repository name'),

1627

('', 'stdio', None, 'for remote clients'),

1627

('', 'stdio', None, 'for remote clients'),

1628

('t', 'templates', "", 'template directory'),

1628

('t', 'templates', "", 'template directory'),

1629

('', 'style', "", 'template style'),

1629

('', 'style', "", 'template style'),

1630

('6', 'ipv6', None, 'use IPv6 in addition to IPv4')],

1630

('6', 'ipv6', None, 'use IPv6 in addition to IPv4')],

1631

"hg serve [OPTION]..."),

1631

"hg serve [OPTION]..."),

1632

"^status":

1632

"^status":

1633

(status,

1633

(status,

1634

[('m', 'modified', None, 'show only modified files'),

1634

[('m', 'modified', None, 'show only modified files'),

1635

('a', 'added', None, 'show only added files'),

1635

('a', 'added', None, 'show only added files'),

1636

('r', 'removed', None, 'show only removed files'),

1636

('r', 'removed', None, 'show only removed files'),

1637

('u', 'unknown', None, 'show only unknown (not tracked) files'),

1637

('u', 'unknown', None, 'show only unknown (not tracked) files'),

1638

('p', 'strip', None, 'strip status prefix'),

1638

('p', 'strip', None, 'strip status prefix'),

1639

('0', 'print0', None, 'end records with NUL'),

1639

('0', 'print0', None, 'end records with NUL'),

1640

('I', 'include', [], 'include path in search'),

1640

('I', 'include', [], 'include path in search'),

1641

('X', 'exclude', [], 'exclude path from search')],

1641

('X', 'exclude', [], 'exclude path from search')],

1642

"hg status [OPTION]... [FILE]..."),

1642

"hg status [OPTION]... [FILE]..."),

1643

"tag":

1643

"tag":

1644

(tag,

1644

(tag,

1645

[('l', 'local', None, 'make the tag local'),

1645

[('l', 'local', None, 'make the tag local'),

1646

('m', 'message', "", 'commit message'),

1646

('m', 'message', "", 'commit message'),

1647

('t', 'text', "", 'commit message (deprecated: use -m)'),

1647

('t', 'text', "", 'commit message (deprecated: use -m)'),

1648

('d', 'date', "", 'date code'),

1648

('d', 'date', "", 'date code'),

1649

('u', 'user', "", 'user')],

1649

('u', 'user', "", 'user')],

1650

'hg tag [OPTION]... NAME [REV]'),

1650

'hg tag [OPTION]... NAME [REV]'),

1651

"tags": (tags, [], 'hg tags'),

1651

"tags": (tags, [], 'hg tags'),

1652

"tip": (tip, [], 'hg tip'),

1652

"tip": (tip, [], 'hg tip'),

1653

"undo": (undo, [], 'hg undo'),

1653

"undo": (undo, [], 'hg undo'),

1654

"^update|up|checkout|co":

1654

"^update|up|checkout|co":

1655

(update,

1655

(update,

1656

[('b', 'branch', "", 'checkout the head of a specific branch'),

1656

[('b', 'branch', "", 'checkout the head of a specific branch'),

1657

('m', 'merge', None, 'allow merging of conflicts'),

1657

('m', 'merge', None, 'allow merging of conflicts'),

1658

('C', 'clean', None, 'overwrite locally modified files')],

1658

('C', 'clean', None, 'overwrite locally modified files')],

1659

'hg update [-b TAG] [-m] [-C] [REV]'),

1659

'hg update [-b TAG] [-m] [-C] [REV]'),

1660

"verify": (verify, [], 'hg verify'),

1660

"verify": (verify, [], 'hg verify'),

1661

"version": (show_version, [], 'hg version'),

1661

"version": (show_version, [], 'hg version'),

1662

}

1662

}

1663

1664

globalopts = [

1664

globalopts = [

1665

('R', 'repository', "", 'repository root directory'),

1665

('R', 'repository', "", 'repository root directory'),

1666

('', 'cwd', '', 'change working directory'),

1666

('', 'cwd', '', 'change working directory'),

1667

('y', 'noninteractive', None, 'run non-interactively'),

1667

('y', 'noninteractive', None, 'run non-interactively'),

1668

('q', 'quiet', None, 'quiet mode'),

1668

('q', 'quiet', None, 'quiet mode'),

1669

('v', 'verbose', None, 'verbose mode'),

1669

('v', 'verbose', None, 'verbose mode'),

1670

('', 'debug', None, 'debug mode'),

1670

('', 'debug', None, 'debug mode'),

1671

('', 'traceback', None, 'print traceback on exception'),

1671

('', 'traceback', None, 'print traceback on exception'),

1672

('', 'time', None, 'time how long the command takes'),

1672

('', 'time', None, 'time how long the command takes'),

1673

('', 'profile', None, 'profile'),

1673

('', 'profile', None, 'profile'),

1674

('', 'version', None, 'output version information and exit'),

1674

('', 'version', None, 'output version information and exit'),

1675

('h', 'help', None, 'display help and exit'),

1675

('h', 'help', None, 'display help and exit'),

1676

]

1676

]

1677

1678

norepo = ("clone init version help debugconfig debugdata"

1678

norepo = ("clone init version help debugconfig debugdata"

1679

" debugindex debugindexdot paths")

1679

" debugindex debugindexdot paths")

1680

1681

def find(cmd):

1681

def find(cmd):

1682

for e in table.keys():

1682

for e in table.keys():

1683

if re.match("(%s)$" % e, cmd):

1683

if re.match("(%s)$" % e, cmd):

1684

return e, table[e]

1684

return e, table[e]

1685

1686

raise UnknownCommand(cmd)

1686

raise UnknownCommand(cmd)

1687

1688

class SignalInterrupt(Exception):

1688

class SignalInterrupt(Exception):

1689

"""Exception raised on SIGTERM and SIGHUP."""

1689

"""Exception raised on SIGTERM and SIGHUP."""

1690

1691

def catchterm(*args):

1691

def catchterm(*args):

1692

raise SignalInterrupt

1692

raise SignalInterrupt

1693

1694

def run():

1694

def run():

1695

sys.exit(dispatch(sys.argv[1:]))

1695

sys.exit(dispatch(sys.argv[1:]))

1696

1697

class ParseError(Exception):

1697

class ParseError(Exception):

1698

"""Exception raised on errors in parsing the command line."""

1698

"""Exception raised on errors in parsing the command line."""

1699

1700

def parse(args):

1700

def parse(args):

1701

options = {}

1701

options = {}

1702

cmdoptions = {}

1702

cmdoptions = {}

1703

1704

try:

1704

try:

1705

args = fancyopts.fancyopts(args, globalopts, options)

1705

args = fancyopts.fancyopts(args, globalopts, options)

1706

except fancyopts.getopt.GetoptError, inst:

1706

except fancyopts.getopt.GetoptError, inst:

1707

raise ParseError(None, inst)

1707

raise ParseError(None, inst)

1708

1709

if args:

1709

if args:

1710

cmd, args = args[0], args[1:]

1710

cmd, args = args[0], args[1:]

1711

i = find(cmd)[1]

1711

i = find(cmd)[1]

1712

c = list(i[1])

1712

c = list(i[1])

1713

else:

1713

else:

1714

cmd = None

1714

cmd = None

1715

c = []

1715

c = []

1716

1717

# combine global options into local

1717

# combine global options into local

1718

for o in globalopts:

1718

for o in globalopts:

1719

c.append((o[0], o[1], options[o[1]], o[3]))

1719

c.append((o[0], o[1], options[o[1]], o[3]))

1720

1721

try:

1721

try:

1722

args = fancyopts.fancyopts(args, c, cmdoptions)

1722

args = fancyopts.fancyopts(args, c, cmdoptions)

1723

except fancyopts.getopt.GetoptError, inst:

1723

except fancyopts.getopt.GetoptError, inst:

1724

raise ParseError(cmd, inst)

1724

raise ParseError(cmd, inst)

1725

1726

# separate global options back out

1726

# separate global options back out

1727

for o in globalopts:

1727

for o in globalopts:

1728

n = o[1]

1728

n = o[1]

1729

options[n] = cmdoptions[n]

1729

options[n] = cmdoptions[n]

1730

del cmdoptions[n]

1730

del cmdoptions[n]

1731

1732

return (cmd, cmd and i[0] or None, args, options, cmdoptions)

1732

return (cmd, cmd and i[0] or None, args, options, cmdoptions)

1733

1734

def dispatch(args):

1734

def dispatch(args):

1735

signal.signal(signal.SIGTERM, catchterm)

1735

signal.signal(signal.SIGTERM, catchterm)

1736

try:

1736

try:

1737

signal.signal(signal.SIGHUP, catchterm)

1737

signal.signal(signal.SIGHUP, catchterm)

1738

except AttributeError:

1738

except AttributeError:

1739

pass

1739

pass

1740

1741

u = ui.ui()

1741

u = ui.ui()

1742

external = []

1742

external = []

1743

for x in u.extensions():

1743

for x in u.extensions():

1744

if x[1]:

1744

if x[1]:

1745

mod = imp.load_source(x[0], x[1])

1745

mod = imp.load_source(x[0], x[1])

1746

else:

1746

else:

1747

def importh(name):

1747

def importh(name):

1748

mod = __import__(name)

1748

mod = __import__(name)

1749

components = name.split('.')

1749

components = name.split('.')

1750

for comp in components[1:]:

1750

for comp in components[1:]:

1751

mod = getattr(mod, comp)

1751

mod = getattr(mod, comp)

1752

return mod

1752

return mod

1753

mod = importh(x[0])

1753

mod = importh(x[0])

1754

external.append(mod)

1754

external.append(mod)

1755

for x in external:

1755

for x in external:

1756

for t in x.cmdtable:

1756

for t in x.cmdtable:

1757

if t in table:

1757

if t in table:

1758

u.warn("module %s override %s\n" % (x.__name__, t))

1758

u.warn("module %s override %s\n" % (x.__name__, t))

1759

table.update(x.cmdtable)

1759

table.update(x.cmdtable)

1760

1761

try:

1761

try:

1762

cmd, func, args, options, cmdoptions = parse(args)

1762

cmd, func, args, options, cmdoptions = parse(args)

1763

except ParseError, inst:

1763

except ParseError, inst:

1764

if inst.args[0]:

1764

if inst.args[0]:

1765

u.warn("hg %s: %s\n" % (inst.args[0], inst.args[1]))

1765

u.warn("hg %s: %s\n" % (inst.args[0], inst.args[1]))

1766

help_(u, inst.args[0])

1766

help_(u, inst.args[0])

1767

else:

1767

else:

1768

u.warn("hg: %s\n" % inst.args[1])

1768

u.warn("hg: %s\n" % inst.args[1])

1769

help_(u, 'shortlist')

1769

help_(u, 'shortlist')

1770

sys.exit(-1)

1770

sys.exit(-1)

1771

except UnknownCommand, inst:

1771

except UnknownCommand, inst:

1772

u.warn("hg: unknown command '%s'\n" % inst.args[0])

1772

u.warn("hg: unknown command '%s'\n" % inst.args[0])

1773

help_(u, 'shortlist')

1773

help_(u, 'shortlist')

1774

sys.exit(1)

1774

sys.exit(1)

1775

1776

if options["time"]:

1776

if options["time"]:

1777

def get_times():

1777

def get_times():

1778

t = os.times()

1778

t = os.times()

1779

if t[4] == 0.0: # Windows leaves this as zero, so use time.clock()

1779

if t[4] == 0.0: # Windows leaves this as zero, so use time.clock()

1780

t = (t[0], t[1], t[2], t[3], time.clock())

1780

t = (t[0], t[1], t[2], t[3], time.clock())

1781

return t

1781

return t

1782

s = get_times()

1782

s = get_times()

1783

def print_time():

1783

def print_time():

1784

t = get_times()

1784

t = get_times()

1785

u.warn("Time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n" %

1785

u.warn("Time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n" %

1786

(t[4]-s[4], t[0]-s[0], t[2]-s[2], t[1]-s[1], t[3]-s[3]))

1786

(t[4]-s[4], t[0]-s[0], t[2]-s[2], t[1]-s[1], t[3]-s[3]))

1787

atexit.register(print_time)

1787

atexit.register(print_time)

1788

1789

u.updateopts(options["verbose"], options["debug"], options["quiet"],

1789

u.updateopts(options["verbose"], options["debug"], options["quiet"],

1790

not options["noninteractive"])

1790

not options["noninteractive"])

1791

1792

try:

1792

try:

1793

try:

1793

try:

1794

if options['help']:

1794

if options['help']:

1795

help_(u, cmd, options['version'])

1795

help_(u, cmd, options['version'])

1796

sys.exit(0)

1796

sys.exit(0)

1797

elif options['version']:

1797

elif options['version']:

1798

show_version(u)

1798

show_version(u)

1799

sys.exit(0)

1799

sys.exit(0)

1800

elif not cmd:

1800

elif not cmd:

1801

help_(u, 'shortlist')

1801

help_(u, 'shortlist')

1802

sys.exit(0)

1802

sys.exit(0)

1803

1804

if options['cwd']:

1804

if options['cwd']:

1805

try:

1805

try:

1806

os.chdir(options['cwd'])

1806

os.chdir(options['cwd'])

1807

except OSError, inst:

1807

except OSError, inst:

1808

u.warn('abort: %s: %s\n' % (options['cwd'], inst.strerror))

1808

u.warn('abort: %s: %s\n' % (options['cwd'], inst.strerror))

1809

sys.exit(1)

1809

sys.exit(1)

1810

1811

if cmd not in norepo.split():

1811

if cmd not in norepo.split():

1812

path = options["repository"] or ""

1812

path = options["repository"] or ""

1813

repo = hg.repository(ui=u, path=path)

1813

repo = hg.repository(ui=u, path=path)

1814

for x in external:

1814

for x in external:

1815

x.reposetup(u, repo)

1815

x.reposetup(u, repo)

1816

d = lambda: func(u, repo, *args, **cmdoptions)

1816

d = lambda: func(u, repo, *args, **cmdoptions)

1817

else:

1817

else:

1818

d = lambda: func(u, *args, **cmdoptions)

1818

d = lambda: func(u, *args, **cmdoptions)

1819

1820

if options['profile']:

1820

if options['profile']:

1821

import hotshot, hotshot.stats

1821

import hotshot, hotshot.stats

1822

prof = hotshot.Profile("hg.prof")

1822

prof = hotshot.Profile("hg.prof")

1823

r = prof.runcall(d)

1823

r = prof.runcall(d)

1824

prof.close()

1824

prof.close()

1825

stats = hotshot.stats.load("hg.prof")

1825

stats = hotshot.stats.load("hg.prof")

1826

stats.strip_dirs()

1826

stats.strip_dirs()

1827

stats.sort_stats('time', 'calls')

1827

stats.sort_stats('time', 'calls')

1828

stats.print_stats(40)

1828

stats.print_stats(40)

1829

return r

1829

return r

1830

else:

1830

else:

1831

return d()

1831

return d()

1832

except:

1832

except:

1833

if options['traceback']:

1833

if options['traceback']:

1834

traceback.print_exc()

1834

traceback.print_exc()

1835

raise

1835

raise

1836

except hg.RepoError, inst:

1836

except hg.RepoError, inst:

1837

u.warn("abort: ", inst, "!\n")

1837

u.warn("abort: ", inst, "!\n")

1838

except SignalInterrupt:

1838

except SignalInterrupt:

1839

u.warn("killed!\n")

1839

u.warn("killed!\n")

1840

except KeyboardInterrupt:

1840

except KeyboardInterrupt:

1841

try:

1841

try:

1842

u.warn("interrupted!\n")

1842

u.warn("interrupted!\n")

1843

except IOError, inst:

1843

except IOError, inst:

1844

if inst.errno == errno.EPIPE:

1844

if inst.errno == errno.EPIPE:

1845

if u.debugflag:

1845

if u.debugflag:

1846

u.warn("\nbroken pipe\n")

1846

u.warn("\nbroken pipe\n")

1847

else:

1847

else:

1848

raise

1848

raise

1849

except IOError, inst:

1849

except IOError, inst:

1850

if hasattr(inst, "code"):

1850

if hasattr(inst, "code"):

1851

u.warn("abort: %s\n" % inst)

1851

u.warn("abort: %s\n" % inst)

1852

elif hasattr(inst, "reason"):

1852

elif hasattr(inst, "reason"):

1853

u.warn("abort: error: %s\n" % inst.reason[1])

1853

u.warn("abort: error: %s\n" % inst.reason[1])

1854

elif hasattr(inst, "args") and inst[0] == errno.EPIPE:

1854

elif hasattr(inst, "args") and inst[0] == errno.EPIPE:

1855

if u.debugflag:

1855

if u.debugflag:

1856

u.warn("broken pipe\n")

1856

u.warn("broken pipe\n")

1857

else:

1857

else:

1858

raise

1858

raise

1859

except OSError, inst:

1859

except OSError, inst:

1860

if hasattr(inst, "filename"):

1860

if hasattr(inst, "filename"):

1861

u.warn("abort: %s: %s\n" % (inst.strerror, inst.filename))

1861

u.warn("abort: %s: %s\n" % (inst.strerror, inst.filename))

1862

else:

1862

else:

1863

u.warn("abort: %s\n" % inst.strerror)

1863

u.warn("abort: %s\n" % inst.strerror)

1864

except util.Abort, inst:

1864

except util.Abort, inst:

1865

u.warn('abort: ', inst.args[0] % inst.args[1:], '\n')

1865

u.warn('abort: ', inst.args[0] % inst.args[1:], '\n')

1866

sys.exit(1)

1866

sys.exit(1)

1867

except TypeError, inst:

1867

except TypeError, inst:

1868

# was this an argument error?

1868

# was this an argument error?

1869

tb = traceback.extract_tb(sys.exc_info()[2])

1869

tb = traceback.extract_tb(sys.exc_info()[2])

1870

if len(tb) > 2: # no

1870

if len(tb) > 2: # no

1871

raise

1871

raise

1872

u.debug(inst, "\n")

1872

u.debug(inst, "\n")

1873

u.warn("%s: invalid arguments\n" % cmd)

1873

u.warn("%s: invalid arguments\n" % cmd)

1874

help_(u, cmd)

1874

help_(u, cmd)

1875

except UnknownCommand, inst:

1875

except UnknownCommand, inst:

1876

u.warn("hg: unknown command '%s'\n" % inst.args[0])

1876

u.warn("hg: unknown command '%s'\n" % inst.args[0])

1877

help_(u, 'shortlist')

1877

help_(u, 'shortlist')

1878

1879

sys.exit(-1)

1879

sys.exit(-1)

	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
             demandload(globals(), "os re sys signal shutil imp")
             demandload(globals(), "fancyopts ui hg util lock")
             demandload(globals(), "fnmatch hgweb mdiff random signal time traceback")
             demandload(globals(), "errno socket version struct atexit sets")
             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'),
                                     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):
                 # This code most commonly needs 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.  Walk forwards through a window of revisions,
                 # yielding them in the desired order, and walk the windows
                 # themselves backwards.
                 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 = {}
                 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, repo.changelog.read(repo.lookup(str(j)))[3]
                     for rev, changefiles in changerevgen():
                         matches = filter(matchfn, changefiles)
                         if matches:
                             fncache[rev] = matches
                             wanted[rev] = 1
                 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)
                         if not fns:
                             fns = repo.changelog.read(repo.lookup(str(rev)))[3]
                             fns = filter(matchfn, fns)
                         yield 'add', rev, fns
                     for rev in nrevs:
                         yield 'iter', rev, None
             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 not (0 <= 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
                 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):
                             yield str(rev)
                     else:
                         yield str(fix(spec, None))
             def make_filename(repo, r, pat, node=None,
                               total=None, seqno=None, revwidth=None):
                 node_expander = {
                     'H': lambda: hg.hex(node),
                     'R': lambda: str(r.rev(node)),
                     'h': lambda: hg.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)))
                     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'):
                 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),
                             mode)
             def dodiff(fp, ui, repo, node1, node2, files=None, match=util.always,
                        changes=None, text=False):
                 def date(c):
                     return time.asctime(time.gmtime(float(c[2].split(' ')[0])))
                 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 = date(change)
                     def read(f):
                         return repo.file(f).read(mmap2[f])
                 else:
                     date2 = time.asctime()
                     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 hg.hex or hg.short
                     r = [hexfunc(node) for node in [node1, node2] if node]
                 change = repo.changelog.read(node1)
                 mmap = repo.manifest.read(change[0])
                 date1 = date(change)
                 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 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, hg.short(changenode)))
                     return
                 changes = log.read(changenode)
                 t, tz = changes[2].split(' ')
                 # a conversion tool was sticking non-integer offsets into repos
                 try:
                     tz = int(tz)
                 except ValueError:
                     tz = 0
                 date = time.asctime(time.localtime(float(t))) + " %+05d" % (int(tz)/-36)
                 parents = [(log.rev(p), ui.verbose and hg.hex(p) or hg.short(p))
                            for p in log.parents(changenode)
                            if ui.debugflag or p != hg.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, hg.hex(changenode)))
                 else:
                     ui.write("changeset:   %d:%s\n" % (rev, hg.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]),
                                                   hg.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:
                         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 not exact:
                             ui.status('adding ', rel, '\n')
                     if repo.dirstate.state(abs) != 'r' and not os.path.exists(rel):
                         remove.append(abs)
                         if not exact:
                             ui.status('removing ', rel, '\n')
                 repo.add(add)
                 repo.remove(remove)
             def annotate(ui, repo, *pats, **opts):
                 """show changeset information per file line"""
                 def getnode(rev):
                     return hg.short(repo.changelog.node(rev))
                 def getname(rev):
                     try:
                         return bcache[rev]
                     except KeyError:
                         cl = repo.changelog.read(repo.changelog.node(rev))
                         name = cl[1]
                         f = name.find('@')
                         if f >= 0:
                             name = name[:f]
                         f = name.find('<')
                         if f >= 0:
                             name = name[f+1:]
                         bcache[rev] = name
                         return name
                 if not pats:
                     raise util.Abort('at least one file name or pattern required')
                 bcache = {}
                 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 cat(ui, repo, file1, rev=None, **opts):
                 """output the latest or given revision of a file"""
                 r = repo.file(relpath(repo, [file1])[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, [file1])[0]]
                     except hg.RepoError, KeyError:
                         n = r.lookup(rev)
                 else:
                     n = r.tip()
                 fp = make_file(repo, r, opts['output'], node=n)
                 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):
                     ui.warn("abort: destination '%s' already exists\n" % dest)
                     return 1
                 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'])
                 d = Dircleanup(dest)
                 source = ui.expandpath(source)
                 abspath = source
                 other = hg.repository(ui, source)
                 if other.dev() != -1:
                     abspath = os.path.abspath(source)
                     copyfile = (os.stat(dest).st_dev == other.dev()
                                 and getattr(os, 'link', None) or shutil.copy2)
                     if copyfile is not shutil.copy2:
                         ui.note("cloning by hardlink\n")
                     # we use a lock here because because we're not nicely ordered
                     l = lock.lock(os.path.join(source, ".hg", "lock"))
                     util.copytree(os.path.join(source, ".hg"), os.path.join(dest, ".hg"),
                                   copyfile)
                     try:
                         os.unlink(os.path.join(dest, ".hg", "dirstate"))
                     except OSError:
                         pass
                     repo = hg.repository(ui, dest)
                 else:
                     repo = hg.repository(ui, dest, create=1)
                     repo.pull(other)
                 f = repo.opener("hgrc", "w")
                 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 not message and logfile:
                     try:
                         if logfile == '-':
                             message = sys.stdin.read()
                         else:
                             message = open(logfile).read()
                     except IOError, why:
                         ui.warn("Can't read commit message %s: %s\n" % (logfile, why))
                 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 = []
                 repo.commit(files, message, opts['user'], opts['date'], match)
             def copy(ui, repo, source, dest):
                 """mark a file as copied or renamed for the next commit"""
                 return repo.copy(*relpath(repo, (source, dest)))
             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 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_))
             def debugdata(ui, file_, rev):
                 """dump the contents of an data file revision"""
-                r = hg.revlog(hg.opener(""), file_[:-2] + ".i", file_)
+                r = hg.revlog(file, file_[:-2] + ".i", file_)
                 ui.write(r.revision(r.lookup(rev)))
             def debugindex(ui, file_):
                 """dump the contents of an index file"""
-                r = hg.revlog(hg.opener(""), file_, "")
+                r = hg.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],
                         hg.short(e[6]), hg.short(e[4]), hg.short(e[5])))
             def debugindexdot(ui, file_):
                 """dump an index DAG as a .dot file"""
-                r = hg.revlog(hg.opener(""), file_, "")
+                r = hg.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] != hg.nullid:
                         ui.write("\t%d -> %d\n" % (r.rev(e[5]), i))
                 ui.write("}\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\n' % (
                     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:
                     ui.write(fmt % (src, abs, rel, exact and 'exact' or ''))
             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")
                 files = []
                 match = util.always
                 if pats:
                     roots, match, results = makewalk(repo, pats, opts)
                     for src, abs, rel, exact in results:
                         files.append(abs)
                 dodiff(sys.stdout, ui, repo, node1, node2, files, match=match,
                        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" % hg.hex(node))
                 fp.write("# Parent  %s\n" % hg.hex(prev))
                 if other != hg.nullid:
                     fp.write("# Parent  %s\n" % hg.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 not exact:
                             ui.status('forgetting ', rel, '\n')
                 repo.forget(forget)
             def grep(ui, repo, pattern=None, *pats, **opts):
                 """search for a pattern in specified files and revisions"""
                 if pattern is None:
                     pattern = opts['regexp']
                 if not pattern:
                     raise util.Abort('no pattern to search for')
                 reflags = 0
                 if opts['ignore_case']:
                     reflags |= re.I
                 regexp = re.compile(pattern, reflags)
                 sep, end = ':', '\n'
                 if opts['null'] or opts['print0']:
                     sep = end = '\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 = {}
                 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))
                     for l in diff:
                         if incrementing:
                             change = ((l in prevstates) and '-') or '+'
                             r = rev
                         else:
                             change = ((l in states) and '-') or '+'
                             r = prev[fn]
                         ui.write('%s:%s:%s:%s%s\n' % (fn, r, l.linenum, change, l.line))
                 fstate = {}
                 for st, rev, fns in walkchangerevs(ui, repo, repo.getcwd(), pats, opts):
                     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:
                             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 incrementing or fstate[fn]:
                                 display(fn, rev, m, fstate[fn])
                             fstate[fn] = m
                             prev[fn] = rev
                 if not incrementing:
                     fstate = fstate.items()
                     fstate.sort()
                     for fn, state in fstate:
                         display(fn, rev, {}, state)
             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 != hg.nullid]
                 if not parents:
                     ui.write("unknown\n")
                     return
                 hexfunc = ui.verbose and hg.hex or hg.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:
                         ui.warn("abort: outstanding uncommitted changes!\n")
                         return 1
                 d = opts["base"]
                 strip = opts["strip"]
                 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 line.startswith("--- ") or line.startswith("diff -r"):
                             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)
                     f = os.popen("patch -p%d < '%s'" % (strip, pf))
                     files = []
                     for l in f.read().splitlines():
                         l.rstrip('\r\n');
                         ui.status("%s\n" % l)
                         if l.startswith('patching file '):
                             pf = l[14:]
                             if pf not in files:
                                 files.append(pf)
                     patcherr = f.close()
                     if patcherr:
                         raise util.Abort("patch failed")
                     if len(files) > 0:
                         addremove(ui, repo, *files)
                     repo.commit(files, message, user)
             def incoming(ui, repo, source="default"):
                 """show new changesets found in source"""
                 source = ui.expandpath(source)
                 other = hg.repository(ui, source)
                 if not other.local():
                     ui.warn("abort: incoming doesn't work for remote"
                             + " repositories yet, sorry!\n")
                     return 1
                 o = repo.findincoming(other)
                 if not o:
                     return
                 o = other.newer(o)
                 o.reverse()
                 for n in o:
                     show_changeset(ui, other, changenode=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 __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']]
                 for st, rev, fns in walkchangerevs(ui, repo, (pats and cwd) or '', pats,
                                                    opts):
                     if st == 'window':
                         du = dui(ui)
                     elif st == 'add':
                         du.bump(rev)
                         show_changeset(du, repo, rev)
                         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" % (hg.hex(m[f]), mf[f] and "755" or "644", f))
             def outgoing(ui, repo, dest="default-push"):
                 """show changesets not found in destination"""
                 dest = ui.expandpath(dest)
                 other = hg.repository(ui, dest)
                 o = repo.findoutgoing(other)
                 o = repo.newer(o)
                 o.reverse()
                 for n in o:
                     show_changeset(ui, repo, changenode=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 != hg.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']:
                     ui.warn("abort: missing commit message\n")
                     return 1
                 files = relpath(repo, list(flist))
                 if rc['files']:
                     files += open(rc['files']).read().splitlines()
                 rc['parent'] = map(repo.lookup, rc['parent'])
                 repo.rawcommit(files, message, rc['user'], rc['date'], *rc['parent'])
             def recover(ui, repo):
                 """roll back an interrupted transaction"""
                 repo.recover()
             def remove(ui, repo, file1, *files):
                 """remove the specified files on the next commit"""
                 repo.remove(relpath(repo, (file1,) + files))
             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(hg.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(hg.bin, nodes.split(" "))
                             r = []
                             for b in repo.branches(nodes):
                                 r.append(" ".join(map(hg.hex, b)) + "\n")
                             respond("".join(r))
                         elif cmd == "between":
                             arg, pairs = getarg()
                             pairs = [map(hg.bin, p.split("-")) for p in pairs.split(" ")]
                             r = []
                             for b in repo.between(pairs):
                                 r.append(" ".join(map(hg.hex, b)) + "\n")
                             respond("".join(r))
                         elif cmd == "changegroup":
                             nodes = []
                             arg, roots = getarg()
                             nodes = map(hg.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])
                 httpd = hgweb.create_server(repo)
                 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['strip']:
                         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":
                     ui.warn("abort: 'tip' is a reserved name!\n")
                     return -1
                 if rev:
                     r = hg.hex(repo.lookup(rev))
                 else:
                     r = hg.hex(repo.changelog.tip())
                 if name.find(revrangesep) >= 0:
                     ui.warn("abort: '%s' cannot be used in a tag name\n" % revrangesep)
                     return -1
                 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:
                         ui.warn("abort: working copy of .hgtags is changed!\n")
                         ui.status("(please commit .hgtags manually)\n")
                         return -1
                 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))
                 repo.commit([".hgtags"], message, opts['user'], opts['date'])
             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), hg.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 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" % (hg.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...'),
                 "cat":
                     (cat,
                      [('o', 'output', "", 'output to file')],
                      'hg cat [-o OUTFILE] FILE [REV]'),
                 "^clone":
                     (clone,
                      [('U', 'noupdate', None, 'skip update after cloning'),
                       ('e', 'ssh', "", 'ssh command'),
                       ('', '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": (copy, [], 'hg copy SOURCE DEST'),
                 "debugcheckstate": (debugcheckstate, [], 'debugcheckstate'),
                 "debugconfig": (debugconfig, [], 'debugconfig'),
                 "debugstate": (debugstate, [], 'debugstate'),
                 "debugdata": (debugdata, [], 'debugdata FILE REV'),
                 "debugindex": (debugindex, [], 'debugindex FILE'),
                 "debugindexdot": (debugindexdot, [], 'debugindexdot FILE'),
                 "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, 'terminate file names with NUL'),
                       ('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'include path in search'),
                       ('Z', 'null', None, 'terminate file names with NUL'),
                       ('a', 'all-revs', '', 'search all revs'),
                       ('e', 'regexp', '', 'pattern to search for'),
                       ('f', 'full-path', None, 'print complete paths'),
                       ('i', 'ignore-case', None, 'ignore case when matching'),
                       ('l', 'files-with-matches', None, 'print names of files with matches'),
                       ('n', 'line-number', '', 'print line numbers'),
                       ('r', 'rev', [], 'search in revision rev'),
                       ('s', 'no-messages', None, 'do not print error messages'),
                       ('v', 'invert-match', None, 'select non-matching lines')],
                      "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, [], 'hg incoming [SOURCE]'),
                 "^init": (init, [], 'hg init [DEST]'),
                 "locate":
                     (locate,
                      [('r', 'rev', '', 'revision'),
                       ('0', 'print0', None, 'end records 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'),
                       ('r', 'rev', [], 'revision'),
                       ('p', 'patch', None, 'show patch')],
                      'hg log [-I] [-X] [-r REV]... [-p] [FILE]'),
                 "manifest": (manifest, [], 'hg manifest [REV]'),
                 "outgoing|out": (outgoing, [], 'hg outgoing [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, [], "hg remove FILE..."),
                 "^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'),
                       ('p', 'strip', None, 'strip status prefix'),
                       ('0', 'print0', None, 'end records 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'),
                 "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'),
                 ('', '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 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]:
                         mod = imp.load_source(x[0], x[1])
                     else:
                         def importh(name):
                             mod = __import__(name)
                             components = name.split('.')
                             for comp in components[1:]:
                                 mod = getattr(mod, comp)
                             return mod
                         mod = importh(x[0])
                     external.append(mod)
                 for x in external:
                     for t in x.cmdtable:
                         if t in table:
                             u.warn("module %s override %s\n" % (x.__name__, t))
                     table.update(x.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"])
                 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:
                                 u.warn('abort: %s: %s\n' % (options['cwd'], inst.strerror))
                                 sys.exit(1)
                         if cmd not in norepo.split():
                             path = options["repository"] or ""
                             repo = hg.repository(ui=u, path=path)
                             for x in external:
                                 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:
                         if options['traceback']:
                             traceback.print_exc()
                         raise
                 except hg.RepoError, 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")
                     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')
                 sys.exit(-1)

             # hg.py - repository classes 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.
             import os
             import util
             from node import *
             from revlog import *
             from repo import *
             from demandload import *
             demandload(globals(), "localrepo httprepo sshrepo")
-            # used to avoid circular references so destructors work
-            def opener(base):
-                p = base
-                def o(path, mode="r"):
-                    if p.startswith("http://"):
-                        f = os.path.join(p, urllib.quote(path))
-                        return httprangereader.httprangereader(f)
-                    f = os.path.join(p, path)
-                    mode += "b" # for that other OS
-                    if mode[0] != "r":
-                        try:
-                            s = os.stat(f)
-                        except OSError:
-                            d = os.path.dirname(f)
-                            if not os.path.isdir(d):
-                                os.makedirs(d)
-                        else:
-                            if s.st_nlink > 1:
-                                file(f + ".tmp", "wb").write(file(f, "rb").read())
-                                util.rename(f+".tmp", f)
-                    return file(f, mode)
-                return o
             def repository(ui, path=None, create=0):
                 if path:
                     if path.startswith("http://"):
                         return httprepo.httprepository(ui, path)
                     if path.startswith("https://"):
                         return httprepo.httpsrepository(ui, path)
                     if path.startswith("hg://"):
                         return httprepo.httprepository(
                             ui, path.replace("hg://", "http://"))
                     if path.startswith("old-http://"):
                         return localrepo.localrepository(
-                            ui, opener, path.replace("old-http://", "http://"))
+                            ui, util.opener, path.replace("old-http://", "http://"))
                     if path.startswith("ssh://"):
                         return sshrepo.sshrepository(ui, path)
-                return localrepo.localrepository(ui, opener, path, create)
+                return localrepo.localrepository(ui, util.opener, path, create)

             """
             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 demandload import *
             demandload(globals(), "re")
             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=''):
                 """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:
                 're:<regex>'
                 'glob:<shellglob>'
                 'path:<explicit path>'
                 'relpath:<relative path>'
                 '<relative path>'
                 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):
                     for prefix in 're:', 'glob:', 'path:', 'relpath:':
                         if name.startswith(prefix): return name.split(':', 1)
                     for c in name:
                         if c in _globchars: return 'glob', name
                     return 'relpath', name
                 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 == 'relpath':
                         return head + re.escape(name) + tail
                     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
                         root.append(p)
                     return '/'.join(root)
                 pats = []
                 files = []
                 roots = []
                 for kind, name in map(patkind, 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 copytree(src, dst, copyfile):
                 """Copy a directory tree, files are copied using 'copyfile'."""
                 names = os.listdir(src)
                 os.mkdir(dst)
                 for name in names:
                     srcname = os.path.join(src, name)
                     dstname = os.path.join(dst, name)
                     if os.path.isdir(srcname):
                         copytree(srcname, dstname, copyfile)
                     elif os.path.isfile(srcname):
                         copyfile(srcname, dstname)
                     else:
                         pass
+            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.
+                todo: separate remote file access into a separate function
+                """
+                p = base
+                def o(path, mode="r"):
+                    if p.startswith("http://"):
+                        f = os.path.join(p, urllib.quote(path))
+                        return httprangereader.httprangereader(f)
+                    f = os.path.join(p, path)
+                    mode += "b" # for that other OS
+                    if mode[0] != "r":
+                        try:
+                            s = os.stat(f)
+                        except OSError:
+                            d = os.path.dirname(f)
+                            if not os.path.isdir(d):
+                                os.makedirs(d)
+                        else:
+                            if s.st_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()
             # Platform specific variants
             if os.name == 'nt':
                 nulldev = 'NUL:'
                 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'
                 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.name == 'nt': # os.WIFxx is not supported on windows
                         return "aborted with error." , -1
                     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")