upstream/mercurial-mirror Commit - r1285:1546c2aa

1

# commands.py - command processing for mercurial

1

# commands.py - command processing for mercurial

2

#

2

#

3

4

#

4

#

5

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

5

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

6

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

6

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

7

8

from demandload import demandload

8

from demandload import demandload

9

from node import *

9

from node import *

10

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

10

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

11

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

11

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

12

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

12

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

13

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

13

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

14

15

class UnknownCommand(Exception):

15

class UnknownCommand(Exception):

16

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

16

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

17

18

def filterfiles(filters, files):

18

def filterfiles(filters, files):

19

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

19

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

20

21

for t in filters:

21

for t in filters:

22

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

22

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

23

t += "/"

23

t += "/"

24

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

24

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

25

return l

25

return l

26

27

def relpath(repo, args):

27

def relpath(repo, args):

28

cwd = repo.getcwd()

28

cwd = repo.getcwd()

29

if cwd:

29

if cwd:

30

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

30

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

31

return args

31

return args

32

33

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

33

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

34

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

34

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

35

opts.get('exclude'), head)

35

opts.get('exclude'), head)

36

37

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

37

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

38

cwd = repo.getcwd()

38

cwd = repo.getcwd()

39

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

39

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

40

exact = dict(zip(files, files))

40

exact = dict(zip(files, files))

41

def walk():

41

def walk():

42

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

42

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

43

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

43

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

44

return files, matchfn, walk()

44

return files, matchfn, walk()

45

46

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

46

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

47

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

47

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

48

for r in results:

48

for r in results:

49

yield r

49

yield r

50

51

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

51

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

52

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

52

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

53

54

Callers most commonly need to iterate backwards over the history

54

Callers most commonly need to iterate backwards over the history

55

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

55

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

56

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

56

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

57

58

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

58

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

59

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

59

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

60

order (usually backwards) to display it.

60

order (usually backwards) to display it.

61

62

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

62

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

63

getchange function returns the changelog entry for a numeric

63

getchange function returns the changelog entry for a numeric

64

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

64

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

65

the following forms:

65

the following forms:

66

67

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

67

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

68

positive if walking forwards through revs, last rev in the

68

positive if walking forwards through revs, last rev in the

69

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

69

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

70

71

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

71

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

72

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

72

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

73

possible display

73

possible display

74

75

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

75

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

76

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

76

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

77

cwd = repo.getcwd()

77

cwd = repo.getcwd()

78

if not pats and cwd:

78

if not pats and cwd:

79

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

79

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

80

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

80

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

81

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

81

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

82

pats, opts)

82

pats, opts)

83

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

83

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

84

wanted = {}

84

wanted = {}

85

slowpath = anypats

85

slowpath = anypats

86

window = 300

86

window = 300

87

fncache = {}

87

fncache = {}

88

89

chcache = {}

89

chcache = {}

90

def getchange(rev):

90

def getchange(rev):

91

ch = chcache.get(rev)

91

ch = chcache.get(rev)

92

if ch is None:

92

if ch is None:

93

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

93

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

94

return ch

94

return ch

95

96

if not slowpath and not files:

96

if not slowpath and not files:

97

# No files, no patterns. Display all revs.

97

# No files, no patterns. Display all revs.

98

wanted = dict(zip(revs, revs))

98

wanted = dict(zip(revs, revs))

99

if not slowpath:

99

if not slowpath:

100

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

100

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

101

def filerevgen(filelog):

101

def filerevgen(filelog):

102

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

102

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

103

revs = []

103

revs = []

104

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

104

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

105

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

105

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

106

revs.reverse()

106

revs.reverse()

107

for rev in revs:

107

for rev in revs:

108

yield rev

108

yield rev

109

110

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

110

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

111

for file in files:

111

for file in files:

112

filelog = repo.file(file)

112

filelog = repo.file(file)

113

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

113

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

114

# try to find matching entries on the slow path.

114

# try to find matching entries on the slow path.

115

if filelog.count() == 0:

115

if filelog.count() == 0:

116

slowpath = True

116

slowpath = True

117

break

117

break

118

for rev in filerevgen(filelog):

118

for rev in filerevgen(filelog):

119

if rev <= maxrev:

119

if rev <= maxrev:

120

if rev < minrev:

120

if rev < minrev:

121

break

121

break

122

fncache.setdefault(rev, [])

122

fncache.setdefault(rev, [])

123

fncache[rev].append(file)

123

fncache[rev].append(file)

124

wanted[rev] = 1

124

wanted[rev] = 1

125

if slowpath:

125

if slowpath:

126

# The slow path checks files modified in every changeset.

126

# The slow path checks files modified in every changeset.

127

def changerevgen():

127

def changerevgen():

128

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

128

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

129

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

129

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

130

yield j, getchange(j)[3]

130

yield j, getchange(j)[3]

131

132

for rev, changefiles in changerevgen():

132

for rev, changefiles in changerevgen():

133

matches = filter(matchfn, changefiles)

133

matches = filter(matchfn, changefiles)

134

if matches:

134

if matches:

135

fncache[rev] = matches

135

fncache[rev] = matches

136

wanted[rev] = 1

136

wanted[rev] = 1

137

138

def iterate():

138

def iterate():

139

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

139

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

140

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

140

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

141

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

141

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

142

if rev in wanted]

142

if rev in wanted]

143

srevs = list(nrevs)

143

srevs = list(nrevs)

144

srevs.sort()

144

srevs.sort()

145

for rev in srevs:

145

for rev in srevs:

146

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

146

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

147

yield 'add', rev, fns

147

yield 'add', rev, fns

148

for rev in nrevs:

148

for rev in nrevs:

149

yield 'iter', rev, None

149

yield 'iter', rev, None

150

return iterate(), getchange

150

return iterate(), getchange

151

152

revrangesep = ':'

152

revrangesep = ':'

153

154

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

154

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

155

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

155

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

156

if revlog is None:

156

if revlog is None:

157

revlog = repo.changelog

157

revlog = repo.changelog

158

revcount = revlog.count()

158

revcount = revlog.count()

159

def fix(val, defval):

159

def fix(val, defval):

160

if not val:

160

if not val:

161

return defval

161

return defval

162

try:

162

try:

163

num = int(val)

163

num = int(val)

164

if str(num) != val:

164

if str(num) != val:

165

raise ValueError

165

raise ValueError

166

if num < 0: num += revcount

166

if num < 0: num += revcount

167

if num < 0: num = 0

167

if num < 0: num = 0

168

elif num >= revcount:

168

elif num >= revcount:

169

raise ValueError

169

raise ValueError

170

except ValueError:

170

except ValueError:

171

try:

171

try:

172

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

172

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

173

except KeyError:

173

except KeyError:

174

try:

174

try:

175

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

175

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

176

except KeyError:

176

except KeyError:

177

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

177

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

178

return num

178

return num

179

seen = {}

179

seen = {}

180

for spec in revs:

180

for spec in revs:

181

if spec.find(revrangesep) >= 0:

181

if spec.find(revrangesep) >= 0:

182

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

182

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

183

start = fix(start, 0)

183

start = fix(start, 0)

184

end = fix(end, revcount - 1)

184

end = fix(end, revcount - 1)

185

step = start > end and -1 or 1

185

step = start > end and -1 or 1

186

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

186

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

187

if rev in seen: continue

187

if rev in seen: continue

188

seen[rev] = 1

188

seen[rev] = 1

189

yield str(rev)

189

yield str(rev)

190

else:

190

else:

191

rev = fix(spec, None)

191

rev = fix(spec, None)

192

if rev in seen: continue

192

if rev in seen: continue

193

seen[rev] = 1

193

seen[rev] = 1

194

yield str(rev)

194

yield str(rev)

195

196

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

196

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

197

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

197

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

198

node_expander = {

198

node_expander = {

199

'H': lambda: hex(node),

199

'H': lambda: hex(node),

200

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

200

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

201

'h': lambda: short(node),

201

'h': lambda: short(node),

202

}

202

}

203

expander = {

203

expander = {

204

'%': lambda: '%',

204

'%': lambda: '%',

205

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

205

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

206

}

206

}

207

208

try:

208

try:

209

if node:

209

if node:

210

expander.update(node_expander)

210

expander.update(node_expander)

211

if node and revwidth is not None:

211

if node and revwidth is not None:

212

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

212

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

213

if total is not None:

213

if total is not None:

214

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

214

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

215

if seqno is not None:

215

if seqno is not None:

216

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

216

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

217

if total is not None and seqno is not None:

217

if total is not None and seqno is not None:

218

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

218

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

219

if pathname is not None:

219

if pathname is not None:

220

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

220

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

221

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

221

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

222

expander['p'] = lambda: pathname

222

expander['p'] = lambda: pathname

223

224

newname = []

224

newname = []

225

patlen = len(pat)

225

patlen = len(pat)

226

i = 0

226

i = 0

227

while i < patlen:

227

while i < patlen:

228

c = pat[i]

228

c = pat[i]

229

if c == '%':

229

if c == '%':

230

i += 1

230

i += 1

231

c = pat[i]

231

c = pat[i]

232

c = expander[c]()

232

c = expander[c]()

233

newname.append(c)

233

newname.append(c)

234

i += 1

234

i += 1

235

return ''.join(newname)

235

return ''.join(newname)

236

except KeyError, inst:

236

except KeyError, inst:

237

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

237

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

238

inst.args[0])

238

inst.args[0])

239

240

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

240

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

241

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

241

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

242

if not pat or pat == '-':

242

if not pat or pat == '-':

243

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

243

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

244

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

244

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

245

return pat

245

return pat

246

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

246

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

247

return pat

247

return pat

248

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

248

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

249

pathname),

249

pathname),

250

mode)

250

mode)

251

252

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

252

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

253

changes=None, text=False):

253

changes=None, text=False):

254

def date(c):

254

def date(c):

255

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

255

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

256

257

if not changes:

257

if not changes:

258

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

258

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

259

else:

259

else:

260

(c, a, d, u) = changes

260

(c, a, d, u) = changes

261

if files:

261

if files:

262

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

262

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

263

264

if not c and not a and not d:

264

if not c and not a and not d:

265

return

265

return

266

267

if node2:

267

if node2:

268

change = repo.changelog.read(node2)

268

change = repo.changelog.read(node2)

269

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

269

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

270

date2 = date(change)

270

date2 = date(change)

271

def read(f):

271

def read(f):

272

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

272

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

273

else:

273

else:

274

date2 = time.asctime()

274

date2 = time.asctime()

275

if not node1:

275

if not node1:

276

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

276

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

277

def read(f):

277

def read(f):

278

return repo.wfile(f).read()

278

return repo.wfile(f).read()

279

280

if ui.quiet:

280

if ui.quiet:

281

r = None

281

r = None

282

else:

282

else:

283

hexfunc = ui.verbose and hex or short

283

hexfunc = ui.verbose and hex or short

284

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

284

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

285

286

change = repo.changelog.read(node1)

286

change = repo.changelog.read(node1)

287

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

287

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

288

date1 = date(change)

288

date1 = date(change)

289

290

for f in c:

290

for f in c:

291

to = None

291

to = None

292

if f in mmap:

292

if f in mmap:

293

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

293

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

294

tn = read(f)

294

tn = read(f)

295

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

295

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

296

for f in a:

296

for f in a:

297

to = None

297

to = None

298

tn = read(f)

298

tn = read(f)

299

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

299

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

300

for f in d:

300

for f in d:

301

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

301

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

302

tn = None

302

tn = None

303

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

303

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

304

305

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

305

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

306

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

306

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

307

user = revcache.get(rev)

307

user = revcache.get(rev)

308

if user is None:

308

if user is None:

309

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

309

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

310

return user

310

return user

311

312

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

312

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

313

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

313

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

314

log = repo.changelog

314

log = repo.changelog

315

if changenode is None:

315

if changenode is None:

316

changenode = log.node(rev)

316

changenode = log.node(rev)

317

elif not rev:

317

elif not rev:

318

rev = log.rev(changenode)

318

rev = log.rev(changenode)

319

320

if ui.quiet:

320

if ui.quiet:

321

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

321

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

322

return

322

return

323

324

changes = log.read(changenode)

324

changes = log.read(changenode)

325

326

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

326

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

327

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

327

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

328

try:

328

try:

329

tz = int(tz)

329

tz = int(tz)

330

except ValueError:

330

except ValueError:

331

tz = 0

331

tz = 0

332

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

332

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

333

334

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

334

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

335

for p in log.parents(changenode)

335

for p in log.parents(changenode)

336

if ui.debugflag or p != nullid]

336

if ui.debugflag or p != nullid]

337

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

337

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

338

parents = []

338

parents = []

339

340

if ui.verbose:

340

if ui.verbose:

341

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

341

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

342

else:

342

else:

343

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

343

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

344

345

for tag in repo.nodetags(changenode):

345

for tag in repo.nodetags(changenode):

346

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

346

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

347

for parent in parents:

347

for parent in parents:

348

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

348

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

349

350

if brinfo and changenode in brinfo:

350

if brinfo and changenode in brinfo:

351

br = brinfo[changenode]

351

br = brinfo[changenode]

352

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

352

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

353

354

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

354

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

355

hex(changes[0])))

355

hex(changes[0])))

356

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

356

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

357

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

357

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

358

359

if ui.debugflag:

359

if ui.debugflag:

360

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

360

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

361

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

361

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

362

if value:

362

if value:

363

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

363

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

364

else:

364

else:

365

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

365

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

366

367

description = changes[4].strip()

367

description = changes[4].strip()

368

if description:

368

if description:

369

if ui.verbose:

369

if ui.verbose:

370

ui.status("description:\n")

370

ui.status("description:\n")

371

ui.status(description)

371

ui.status(description)

372

ui.status("\n\n")

372

ui.status("\n\n")

373

else:

373

else:

374

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

374

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

375

ui.status("\n")

375

ui.status("\n")

376

377

def show_version(ui):

377

def show_version(ui):

378

"""output version and copyright information"""

378

"""output version and copyright information"""

379

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

379

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

380

% version.get_version())

380

% version.get_version())

381

ui.status(

381

ui.status(

382

383

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

383

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

384

"There is NO\nwarranty; "

384

"There is NO\nwarranty; "

385

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

385

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

386

)

386

)

387

388

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

388

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

389

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

389

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

390

option_lists = []

390

option_lists = []

391

if cmd and cmd != 'shortlist':

391

if cmd and cmd != 'shortlist':

392

if with_version:

392

if with_version:

393

show_version(ui)

393

show_version(ui)

394

ui.write('\n')

394

ui.write('\n')

395

key, i = find(cmd)

395

key, i = find(cmd)

396

# synopsis

396

# synopsis

397

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

397

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

398

399

# description

399

# description

400

doc = i[0].__doc__

400

doc = i[0].__doc__

401

if ui.quiet:

401

if ui.quiet:

402

doc = doc.splitlines(0)[0]

402

doc = doc.splitlines(0)[0]

403

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

403

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

404

405

if not ui.quiet:

405

if not ui.quiet:

406

# aliases

406

# aliases

407

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

407

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

408

if aliases:

408

if aliases:

409

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

409

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

410

411

# options

411

# options

412

if i[1]:

412

if i[1]:

413

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

413

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

414

415

else:

415

else:

416

# program name

416

# program name

417

if ui.verbose or with_version:

417

if ui.verbose or with_version:

418

show_version(ui)

418

show_version(ui)

419

else:

419

else:

420

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

420

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

421

ui.status('\n')

421

ui.status('\n')

422

423

# list of commands

423

# list of commands

424

if cmd == "shortlist":

424

if cmd == "shortlist":

425

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

425

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

426

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

426

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

427

elif ui.verbose:

427

elif ui.verbose:

428

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

428

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

429

else:

429

else:

430

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

430

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

431

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

431

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

432

433

h = {}

433

h = {}

434

cmds = {}

434

cmds = {}

435

for c, e in table.items():

435

for c, e in table.items():

436

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

436

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

437

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

437

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

438

continue

438

continue

439

f = f.lstrip("^")

439

f = f.lstrip("^")

440

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

440

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

441

continue

441

continue

442

d = ""

442

d = ""

443

if e[0].__doc__:

443

if e[0].__doc__:

444

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

444

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

445

h[f] = d

445

h[f] = d

446

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

446

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

447

448

fns = h.keys()

448

fns = h.keys()

449

fns.sort()

449

fns.sort()

450

m = max(map(len, fns))

450

m = max(map(len, fns))

451

for f in fns:

451

for f in fns:

452

if ui.verbose:

452

if ui.verbose:

453

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

453

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

454

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

454

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

455

else:

455

else:

456

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

456

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

457

458

# global options

458

# global options

459

if ui.verbose:

459

if ui.verbose:

460

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

460

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

461

462

# list all option lists

462

# list all option lists

463

opt_output = []

463

opt_output = []

464

for title, options in option_lists:

464

for title, options in option_lists:

465

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

465

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

466

for shortopt, longopt, default, desc in options:

466

for shortopt, longopt, default, desc in options:

467

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

467

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

468

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

468

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

469

"%s%s" % (desc,

469

"%s%s" % (desc,

470

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

470

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

471

or "")))

471

or "")))

472

473

if opt_output:

473

if opt_output:

474

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

474

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

475

for first, second in opt_output:

475

for first, second in opt_output:

476

if second:

476

if second:

477

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

477

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

478

else:

478

else:

479

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

479

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

480

481

# Commands start here, listed alphabetically

481

# Commands start here, listed alphabetically

482

483

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

483

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

484

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

484

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

485

names = []

485

names = []

486

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

486

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

487

if exact:

487

if exact:

488

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

488

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

489

names.append(abs)

489

names.append(abs)

490

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

490

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

491

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

491

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

492

names.append(abs)

492

names.append(abs)

493

repo.add(names)

493

repo.add(names)

494

495

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

495

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

496

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

496

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

497

add, remove = [], []

497

add, remove = [], []

498

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

498

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

499

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

499

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

500

add.append(abs)

500

add.append(abs)

501

if ui.verbose or not exact:

501

if ui.verbose or not exact:

502

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

502

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

503

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

503

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

504

remove.append(abs)

504

remove.append(abs)

505

if ui.verbose or not exact:

505

if ui.verbose or not exact:

506

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

506

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

507

repo.add(add)

507

repo.add(add)

508

repo.remove(remove)

508

repo.remove(remove)

509

510

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

510

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

511

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

511

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

512

def getnode(rev):

512

def getnode(rev):

513

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

513

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

514

515

ucache = {}

515

ucache = {}

516

def getname(rev):

516

def getname(rev):

517

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

517

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

518

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

518

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

519

520

if not pats:

520

if not pats:

521

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

521

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

522

523

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

523

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

524

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

524

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

525

opts['number'] = 1

525

opts['number'] = 1

526

527

if opts['rev']:

527

if opts['rev']:

528

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

528

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

529

else:

529

else:

530

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

530

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

531

change = repo.changelog.read(node)

531

change = repo.changelog.read(node)

532

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

532

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

533

534

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

534

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

535

if abs not in mmap:

535

if abs not in mmap:

536

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

536

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

537

continue

537

continue

538

539

f = repo.file(abs)

539

f = repo.file(abs)

540

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

540

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

541

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

541

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

542

continue

542

continue

543

544

lines = f.annotate(mmap[abs])

544

lines = f.annotate(mmap[abs])

545

pieces = []

545

pieces = []

546

547

for o, f in opmap:

547

for o, f in opmap:

548

if opts[o]:

548

if opts[o]:

549

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

549

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

550

if l:

550

if l:

551

m = max(map(len, l))

551

m = max(map(len, l))

552

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

552

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

553

554

if pieces:

554

if pieces:

555

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

555

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

556

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

556

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

557

558

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

558

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

559

"""create a changegroup file"""

559

"""create a changegroup file"""

560

f = open(fname, "wb")

560

f = open(fname, "wb")

561

dest = ui.expandpath(dest)

561

dest = ui.expandpath(dest)

562

other = hg.repository(ui, dest)

562

other = hg.repository(ui, dest)

563

o = repo.findoutgoing(other)

563

o = repo.findoutgoing(other)

564

cg = repo.changegroup(o)

564

cg = repo.changegroup(o)

565

566

try:

566

try:

567

f.write("HG10")

567

f.write("HG10")

568

z = bz2.BZ2Compressor(9)

568

z = bz2.BZ2Compressor(9)

569

while 1:

569

while 1:

570

chunk = cg.read(4096)

570

chunk = cg.read(4096)

571

if not chunk:

571

if not chunk:

572

break

572

break

573

f.write(z.compress(chunk))

573

f.write(z.compress(chunk))

574

f.write(z.flush())

574

f.write(z.flush())

575

except:

575

except:

576

os.unlink(fname)

576

os.unlink(fname)

577

578

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

578

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

579

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

579

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

580

mf = {}

580

mf = {}

581

if opts['rev']:

581

if opts['rev']:

582

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

582

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

583

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

583

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

584

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

584

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

585

r = repo.file(abs)

585

r = repo.file(abs)

586

if opts['rev']:

586

if opts['rev']:

587

try:

587

try:

588

n = mf[abs]

588

n = mf[abs]

589

except (hg.RepoError, KeyError):

589

except (hg.RepoError, KeyError):

590

try:

590

try:

591

n = r.lookup(rev)

591

n = r.lookup(rev)

592

except KeyError, inst:

592

except KeyError, inst:

593

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

593

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

594

else:

594

else:

595

n = r.tip()

595

n = r.tip()

596

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

596

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

597

fp.write(r.read(n))

597

fp.write(r.read(n))

598

599

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

599

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

600

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

600

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

601

if dest is None:

601

if dest is None:

602

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

602

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

603

604

if os.path.exists(dest):

604

if os.path.exists(dest):

605

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

605

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

606

607

dest = os.path.realpath(dest)

607

dest = os.path.realpath(dest)

608

609

class Dircleanup:

609

class Dircleanup:

610

def __init__(self, dir_):

610

def __init__(self, dir_):

611

self.rmtree = shutil.rmtree

611

self.rmtree = shutil.rmtree

612

self.dir_ = dir_

612

self.dir_ = dir_

613

os.mkdir(dir_)

613

os.mkdir(dir_)

614

def close(self):

614

def close(self):

615

self.dir_ = None

615

self.dir_ = None

616

def __del__(self):

616

def __del__(self):

617

if self.dir_:

617

if self.dir_:

618

self.rmtree(self.dir_, True)

618

self.rmtree(self.dir_, True)

619

620

if opts['ssh']:

620

if opts['ssh']:

621

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

621

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

622

if opts['remotecmd']:

622

if opts['remotecmd']:

623

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

623

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

624

625

d = Dircleanup(dest)

625

d = Dircleanup(dest)

626

if not os.path.exists(source):

626

if not os.path.exists(source):

627

source = ui.expandpath(source)

627

source = ui.expandpath(source)

628

abspath = source

628

abspath = source

629

other = hg.repository(ui, source)

629

other = hg.repository(ui, source)

630

631

copy = False

631

copy = False

632

if not opts['pull'] and other.dev() != -1:

632

if not opts['pull'] and other.dev() != -1:

633

abspath = os.path.abspath(source)

633

abspath = os.path.abspath(source)

634

copy = True

634

copy = True

635

636

if copy:

636

if copy:

637

try:

637

try:

638

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

638

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

639

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

639

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

640

# not pointed to by changesets, thus causing verify to

640

# not pointed to by changesets, thus causing verify to

641

# fail

641

# fail

642

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

642

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

643

except OSError:

643

except OSError:

644

copy = False

644

copy = False

645

646

if copy:

646

if copy:

647

# we lock here to avoid premature writing to the target

647

# we lock here to avoid premature writing to the target

648

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

648

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

649

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

649

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

650

651

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

651

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

652

for f in files.split():

652

for f in files.split():

653

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

653

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

654

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

654

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

655

util.copyfiles(src, dst)

655

util.copyfiles(src, dst)

656

657

repo = hg.repository(ui, dest)

657

repo = hg.repository(ui, dest)

658

659

else:

659

else:

660

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

660

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

661

repo.pull(other)

661

repo.pull(other)

662

663

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

663

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

664

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

664

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

665

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

665

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

666

667

if not opts['noupdate']:

667

if not opts['noupdate']:

668

update(ui, repo)

668

update(ui, repo)

669

670

d.close()

670

d.close()

671

672

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

672

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

673

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

673

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

674

if opts['text']:

674

if opts['text']:

675

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

675

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

676

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

676

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

677

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

677

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

678

logfile = opts['logfile']

678

logfile = opts['logfile']

679

if not message and logfile:

679

if not message and logfile:

680

try:

680

try:

681

if logfile == '-':

681

if logfile == '-':

682

message = sys.stdin.read()

682

message = sys.stdin.read()

683

else:

683

else:

684

message = open(logfile).read()

684

message = open(logfile).read()

685

except IOError, why:

685

except IOError, why:

686

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

686

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

687

688

if opts['addremove']:

688

if opts['addremove']:

689

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

689

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

690

cwd = repo.getcwd()

690

cwd = repo.getcwd()

691

if not pats and cwd:

691

if not pats and cwd:

692

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

692

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

693

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

693

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

694

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

694

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

695

pats, opts)

695

pats, opts)

696

if pats:

696

if pats:

697

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

697

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

698

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

698

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

699

else:

699

else:

700

files = []

700

files = []

701

try:

701

try:

702

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

702

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

703

except ValueError, inst:

703

except ValueError, inst:

704

raise util.Abort(str(inst))

704

raise util.Abort(str(inst))

705

706

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

706

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

707

if not pats:

707

if not pats:

708

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

708

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

709

elif len(pats) == 1:

709

elif len(pats) == 1:

710

raise util.Abort('no destination specified')

710

raise util.Abort('no destination specified')

711

pats = list(pats)

711

pats = list(pats)

712

dest = pats.pop()

712

dest = pats.pop()

713

sources = []

713

sources = []

714

715

def okaytocopy(abs, rel, exact):

715

def okaytocopy(abs, rel, exact):

716

reasons = {'?': 'is not managed',

716

reasons = {'?': 'is not managed',

717

'a': 'has been marked for add'}

717

'a': 'has been marked for add'}

718

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

718

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

719

if reason:

719

if reason:

720

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

720

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

721

else:

721

else:

722

return True

722

return True

723

724

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

724

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

725

if okaytocopy(abs, rel, exact):

725

if okaytocopy(abs, rel, exact):

726

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

726

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

727

if not sources:

727

if not sources:

728

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

728

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

729

730

cwd = repo.getcwd()

730

cwd = repo.getcwd()

731

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

731

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

732

reldest = util.pathto(cwd, absdest)

732

reldest = util.pathto(cwd, absdest)

733

if os.path.exists(reldest):

733

if os.path.exists(reldest):

734

destisfile = not os.path.isdir(reldest)

734

destisfile = not os.path.isdir(reldest)

735

else:

735

else:

736

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

736

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

737

738

if destisfile:

738

if destisfile:

739

if opts['parents']:

739

if opts['parents']:

740

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

740

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

741

elif len(sources) > 1:

741

elif len(sources) > 1:

742

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

742

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

743

'directory')

743

'directory')

744

errs, copied = 0, []

744

errs, copied = 0, []

745

for abs, rel, exact in sources:

745

for abs, rel, exact in sources:

746

if opts['parents']:

746

if opts['parents']:

747

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

747

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

748

elif destisfile:

748

elif destisfile:

749

mydest = reldest

749

mydest = reldest

750

else:

750

else:

751

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

751

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

752

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

752

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

753

myreldest = util.pathto(cwd, myabsdest)

753

myreldest = util.pathto(cwd, myabsdest)

754

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

754

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

755

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

755

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

756

continue

756

continue

757

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

757

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

758

if not opts['after']:

758

if not opts['after']:

759

try:

759

try:

760

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

760

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

761

elif not destisfile: os.mkdir(mydestdir)

761

elif not destisfile: os.mkdir(mydestdir)

762

except OSError, inst:

762

except OSError, inst:

763

if inst.errno != errno.EEXIST: raise

763

if inst.errno != errno.EEXIST: raise

764

if ui.verbose or not exact:

764

if ui.verbose or not exact:

765

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

765

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

766

if not opts['after']:

766

if not opts['after']:

767

try:

767

try:

768

shutil.copyfile(rel, myreldest)

768

shutil.copyfile(rel, myreldest)

769

n = repo.manifest.tip()

769

n = repo.manifest.tip()

770

mf = repo.manifest.readflags(n)

770

mf = repo.manifest.readflags(n)

771

util.set_exec(myreldest, util.is_exec(rel, mf[abs]))

771

util.set_exec(myreldest, util.is_exec(rel, mf[abs]))

772

except shutil.Error, inst:

772

except shutil.Error, inst:

773

raise util.Abort(str(inst))

773

raise util.Abort(str(inst))

774

except IOError, inst:

774

except IOError, inst:

775

if inst.errno == errno.ENOENT:

775

if inst.errno == errno.ENOENT:

776

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

776

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

777

else:

777

else:

778

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

778

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

779

errs += 1

779

errs += 1

780

continue

780

continue

781

repo.copy(abs, myabsdest)

781

repo.copy(abs, myabsdest)

782

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

782

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

783

if errs:

783

if errs:

784

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

784

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

785

return errs, copied

785

return errs, copied

786

787

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

787

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

788

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

788

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

789

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

789

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

790

return errs

790

return errs

791

792

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

792

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

793

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

793

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

794

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

794

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

795

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

795

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

796

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

796

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

797

798

def debugcheckstate(ui, repo):

798

def debugcheckstate(ui, repo):

799

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

799

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

800

parent1, parent2 = repo.dirstate.parents()

800

parent1, parent2 = repo.dirstate.parents()

801

repo.dirstate.read()

801

repo.dirstate.read()

802

dc = repo.dirstate.map

802

dc = repo.dirstate.map

803

keys = dc.keys()

803

keys = dc.keys()

804

keys.sort()

804

keys.sort()

805

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

805

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

806

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

806

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

807

m1 = repo.manifest.read(m1n)

807

m1 = repo.manifest.read(m1n)

808

m2 = repo.manifest.read(m2n)

808

m2 = repo.manifest.read(m2n)

809

errors = 0

809

errors = 0

810

for f in dc:

810

for f in dc:

811

state = repo.dirstate.state(f)

811

state = repo.dirstate.state(f)

812

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

812

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

813

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

813

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

814

errors += 1

814

errors += 1

815

if state in "a" and f in m1:

815

if state in "a" and f in m1:

816

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

816

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

817

errors += 1

817

errors += 1

818

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

818

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

819

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

819

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

820

(f, state))

820

(f, state))

821

errors += 1

821

errors += 1

822

for f in m1:

822

for f in m1:

823

state = repo.dirstate.state(f)

823

state = repo.dirstate.state(f)

824

if state not in "nrm":

824

if state not in "nrm":

825

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

825

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

826

errors += 1

826

errors += 1

827

if errors:

827

if errors:

828

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

828

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

829

830

def debugconfig(ui):

830

def debugconfig(ui):

831

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

831

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

832

try:

832

try:

833

repo = hg.repository(ui)

833

repo = hg.repository(ui)

834

except hg.RepoError:

834

except hg.RepoError:

835

pass

835

pass

836

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

836

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

837

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

837

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

838

839

def debugstate(ui, repo):

839

def debugstate(ui, repo):

840

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

840

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

841

repo.dirstate.read()

841

repo.dirstate.read()

842

dc = repo.dirstate.map

842

dc = repo.dirstate.map

843

keys = dc.keys()

843

keys = dc.keys()

844

keys.sort()

844

keys.sort()

845

for file_ in keys:

845

for file_ in keys:

846

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

846

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

847

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

847

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

848

time.strftime("%x %X",

848

time.strftime("%x %X",

849

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

849

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

850

for f in repo.dirstate.copies:

850

for f in repo.dirstate.copies:

851

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

851

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

852

853

def debugdata(ui, file_, rev):

853

def debugdata(ui, file_, rev):

854

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

854

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

855

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

855

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

856

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

856

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

857

858

def debugindex(ui, file_):

858

def debugindex(ui, file_):

859

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

859

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

860

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

860

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

861

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

861

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

862

" nodeid p1 p2\n")

862

" nodeid p1 p2\n")

863

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

863

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

864

e = r.index[i]

864

e = r.index[i]

865

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

865

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

866

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

866

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

867

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

867

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

868

869

def debugindexdot(ui, file_):

869

def debugindexdot(ui, file_):

870

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

870

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

871

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

871

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

872

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

872

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

873

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

873

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

874

e = r.index[i]

874

e = r.index[i]

875

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

875

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

876

if e[5] != nullid:

876

if e[5] != nullid:

877

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

877

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

878

ui.write("}\n")

878

ui.write("}\n")

879

880

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

880

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

881

"""dump rename information"""

881

"""dump rename information"""

882

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

882

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

883

if rev:

883

if rev:

884

try:

884

try:

885

# assume all revision numbers are for changesets

885

# assume all revision numbers are for changesets

886

n = repo.lookup(rev)

886

n = repo.lookup(rev)

887

change = repo.changelog.read(n)

887

change = repo.changelog.read(n)

888

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

888

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

889

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

889

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

890

except hg.RepoError, KeyError:

890

except hg.RepoError, KeyError:

891

n = r.lookup(rev)

891

n = r.lookup(rev)

892

else:

892

else:

893

n = r.tip()

893

n = r.tip()

894

m = r.renamed(n)

894

m = r.renamed(n)

895

if m:

895

if m:

896

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

896

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

897

else:

897

else:

898

ui.write("not renamed\n")

898

ui.write("not renamed\n")

899

900

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

900

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

901

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

901

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

902

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

902

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

903

if not items:

903

if not items:

904

return

904

return

905

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

905

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

906

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

906

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

907

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

907

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

908

for src, abs, rel, exact in items:

908

for src, abs, rel, exact in items:

909

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

909

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

910

911

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

911

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

912

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

912

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

913

node1, node2 = None, None

913

node1, node2 = None, None

914

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

914

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

915

916

if len(revs) > 0:

916

if len(revs) > 0:

917

node1 = revs[0]

917

node1 = revs[0]

918

if len(revs) > 1:

918

if len(revs) > 1:

919

node2 = revs[1]

919

node2 = revs[1]

920

if len(revs) > 2:

920

if len(revs) > 2:

921

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

921

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

922

923

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

923

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

924

925

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

925

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

926

text=opts['text'])

926

text=opts['text'])

927

928

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

928

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

929

node = repo.lookup(changeset)

929

node = repo.lookup(changeset)

930

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

930

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

931

change = repo.changelog.read(node)

931

change = repo.changelog.read(node)

932

933

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

933

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

934

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

934

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

935

revwidth=revwidth)

935

revwidth=revwidth)

936

if fp != sys.stdout:

936

if fp != sys.stdout:

937

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

937

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

938

939

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

939

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

940

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

940

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

941

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

941

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

942

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

942

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

943

if other != nullid:

943

if other != nullid:

944

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

944

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

945

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

945

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

946

fp.write("\n\n")

946

fp.write("\n\n")

947

948

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

948

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

949

if fp != sys.stdout:

949

if fp != sys.stdout:

950

fp.close()

950

fp.close()

951

952

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

952

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

953

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

953

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

954

if not changesets:

954

if not changesets:

955

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

955

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

956

seqno = 0

956

seqno = 0

957

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

957

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

958

total = len(revs)

958

total = len(revs)

959

revwidth = max(map(len, revs))

959

revwidth = max(map(len, revs))

960

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

960

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

961

for cset in revs:

961

for cset in revs:

962

seqno += 1

962

seqno += 1

963

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

963

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

964

965

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

965

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

966

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

966

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

967

forget = []

967

forget = []

968

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

968

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

969

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

969

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

970

forget.append(abs)

970

forget.append(abs)

971

if ui.verbose or not exact:

971

if ui.verbose or not exact:

972

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

972

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

973

repo.forget(forget)

973

repo.forget(forget)

974

975

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

975

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

976

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

976

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

977

reflags = 0

977

reflags = 0

978

if opts['ignore_case']:

978

if opts['ignore_case']:

979

reflags |= re.I

979

reflags |= re.I

980

regexp = re.compile(pattern, reflags)

980

regexp = re.compile(pattern, reflags)

981

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

981

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

982

if opts['print0']:

982

if opts['print0']:

983

sep = eol = '\0'

983

sep = eol = '\0'

984

985

fcache = {}

985

fcache = {}

986

def getfile(fn):

986

def getfile(fn):

987

if fn not in fcache:

987

if fn not in fcache:

988

fcache[fn] = repo.file(fn)

988

fcache[fn] = repo.file(fn)

989

return fcache[fn]

989

return fcache[fn]

990

991

def matchlines(body):

991

def matchlines(body):

992

begin = 0

992

begin = 0

993

linenum = 0

993

linenum = 0

994

while True:

994

while True:

995

match = regexp.search(body, begin)

995

match = regexp.search(body, begin)

996

if not match:

996

if not match:

997

break

997

break

998

mstart, mend = match.span()

998

mstart, mend = match.span()

999

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

999

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

1000

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

1000

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

1001

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

1001

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

1002

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

1002

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

1003

begin = lend + 1

1003

begin = lend + 1

1004

1005

class linestate:

1005

class linestate:

1006

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

1006

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

1007

self.line = line

1007

self.line = line

1008

self.linenum = linenum

1008

self.linenum = linenum

1009

self.colstart = colstart

1009

self.colstart = colstart

1010

self.colend = colend

1010

self.colend = colend

1011

def __eq__(self, other):

1011

def __eq__(self, other):

1012

return self.line == other.line

1012

return self.line == other.line

1013

def __hash__(self):

1013

def __hash__(self):

1014

return hash(self.line)

1014

return hash(self.line)

1015

1016

matches = {}

1016

matches = {}

1017

def grepbody(fn, rev, body):

1017

def grepbody(fn, rev, body):

1018

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

1018

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

1019

m = matches[rev][fn]

1019

m = matches[rev][fn]

1020

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

1020

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

1021

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

1021

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

1022

m[s] = s

1022

m[s] = s

1023

1024

prev = {}

1024

prev = {}

1025

ucache = {}

1025

ucache = {}

1026

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

1026

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

1027

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

1027

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

1028

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

1028

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

1029

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

1029

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

1030

filerevmatches = {}

1030

filerevmatches = {}

1031

for l in diff:

1031

for l in diff:

1032

if incrementing or not opts['all']:

1032

if incrementing or not opts['all']:

1033

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

1033

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

1034

r = rev

1034

r = rev

1035

else:

1035

else:

1036

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

1036

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

1037

r = prev[fn]

1037

r = prev[fn]

1038

cols = [fn, str(rev)]

1038

cols = [fn, str(rev)]

1039

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

1039

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

1040

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

1040

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

1041

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

1041

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

1042

ucache))

1042

ucache))

1043

if opts['files_with_matches']:

1043

if opts['files_with_matches']:

1044

c = (fn, rev)

1044

c = (fn, rev)

1045

if c in filerevmatches: continue

1045

if c in filerevmatches: continue

1046

filerevmatches[c] = 1

1046

filerevmatches[c] = 1

1047

else:

1047

else:

1048

cols.append(l.line)

1048

cols.append(l.line)

1049

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

1049

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

1050

counts[change] += 1

1050

counts[change] += 1

1051

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

1051

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

1052

1053

fstate = {}

1053

fstate = {}

1054

skip = {}

1054

skip = {}

1055

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

1055

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

1056

count = 0

1056

count = 0

1057

for st, rev, fns in changeiter:

1057

for st, rev, fns in changeiter:

1058

if st == 'window':

1058

if st == 'window':

1059

incrementing = rev

1059

incrementing = rev

1060

matches.clear()

1060

matches.clear()

1061

elif st == 'add':

1061

elif st == 'add':

1062

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

1062

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

1063

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

1063

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

1064

matches[rev] = {}

1064

matches[rev] = {}

1065

for fn in fns:

1065

for fn in fns:

1066

if fn in skip: continue

1066

if fn in skip: continue

1067

fstate.setdefault(fn, {})

1067

fstate.setdefault(fn, {})

1068

try:

1068

try:

1069

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

1069

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

1070

except KeyError:

1070

except KeyError:

1071

pass

1071

pass

1072

elif st == 'iter':

1072

elif st == 'iter':

1073

states = matches[rev].items()

1073

states = matches[rev].items()

1074

states.sort()

1074

states.sort()

1075

for fn, m in states:

1075

for fn, m in states:

1076

if fn in skip: continue

1076

if fn in skip: continue

1077

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

1077

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

1078

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

1078

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

1079

count += pos + neg

1079

count += pos + neg

1080

if pos and not opts['all']:

1080

if pos and not opts['all']:

1081

skip[fn] = True

1081

skip[fn] = True

1082

fstate[fn] = m

1082

fstate[fn] = m

1083

prev[fn] = rev

1083

prev[fn] = rev

1084

1085

if not incrementing:

1085

if not incrementing:

1086

fstate = fstate.items()

1086

fstate = fstate.items()

1087

fstate.sort()

1087

fstate.sort()

1088

for fn, state in fstate:

1088

for fn, state in fstate:

1089

if fn in skip: continue

1089

if fn in skip: continue

1090

display(fn, rev, {}, state)

1090

display(fn, rev, {}, state)

1091

return (count == 0 and 1) or 0

1091

return (count == 0 and 1) or 0

1092

1093

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

1093

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

1094

"""show current repository heads"""

1094

"""show current repository heads"""

1095

heads = repo.changelog.heads()

1095

heads = repo.changelog.heads()

1096

br = None

1096

br = None

1097

if opts['branches']:

1097

if opts['branches']:

1098

br = repo.branchlookup(heads)

1098

br = repo.branchlookup(heads)

1099

for n in repo.changelog.heads():

1099

for n in repo.changelog.heads():

1100

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

1100

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

1101

1102

def identify(ui, repo):

1102

def identify(ui, repo):

1103

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

1103

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

1104

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

1104

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

1105

if not parents:

1105

if not parents:

1106

ui.write("unknown\n")

1106

ui.write("unknown\n")

1107

return

1107

return

1108

1109

hexfunc = ui.verbose and hex or short

1109

hexfunc = ui.verbose and hex or short

1110

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

1110

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

1111

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

1111

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

1112

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

1112

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

1113

1114

if not ui.quiet:

1114

if not ui.quiet:

1115

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

1115

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

1116

parenttags = ['/'.join(tags)

1116

parenttags = ['/'.join(tags)

1117

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

1117

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

1118

# tags for multiple parents separated by ' + '

1118

# tags for multiple parents separated by ' + '

1119

if parenttags:

1119

if parenttags:

1120

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

1120

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

1121

1122

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

1122

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

1123

1124

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

1124

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

1125

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

1125

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

1126

patches = (patch1,) + patches

1126

patches = (patch1,) + patches

1127

1128

if not opts['force']:

1128

if not opts['force']:

1129

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

1129

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

1130

if c or a or d:

1130

if c or a or d:

1131

raise util.Abort("outstanding uncommitted changes")

1131

raise util.Abort("outstanding uncommitted changes")

1132

1133

d = opts["base"]

1133

d = opts["base"]

1134

strip = opts["strip"]

1134

strip = opts["strip"]

1135

1136

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

1136

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

1137

diffre = re.compile(r'(?:diff -|--- .*\s+\w+ \w+ +\d+ \d+:\d+:\d+ \d+)')

1137

diffre = re.compile(r'(?:diff -|--- .*\s+\w+ \w+ +\d+ \d+:\d+:\d+ \d+)')

1138

1139

for patch in patches:

1139

for patch in patches:

1140

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

1140

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

1141

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

1141

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

1142

1143

message = []

1143

message = []

1144

user = None

1144

user = None

1145

hgpatch = False

1145

hgpatch = False

1146

for line in file(pf):

1146

for line in file(pf):

1147

line = line.rstrip()

1147

line = line.rstrip()

1148

if (not message and not hgpatch and

1148

if (not message and not hgpatch and

1149

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

1149

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

1150

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

1150

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

1151

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

1151

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

1152

'mail header: ' + line)

1152

'mail header: ' + line)

1153

if diffre.match(line):

1153

if diffre.match(line):

1154

break

1154

break

1155

elif hgpatch:

1155

elif hgpatch:

1156

# parse values when importing the result of an hg export

1156

# parse values when importing the result of an hg export

1157

if line.startswith("# User "):

1157

if line.startswith("# User "):

1158

user = line[7:]

1158

user = line[7:]

1159

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

1159

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

1160

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

1160

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

1161

message.append(line)

1161

message.append(line)

1162

hgpatch = False

1162

hgpatch = False

1163

elif line == '# HG changeset patch':

1163

elif line == '# HG changeset patch':

1164

hgpatch = True

1164

hgpatch = True

1165

message = [] # We may have collected garbage

1165

message = [] # We may have collected garbage

1166

else:

1166

else:

1167

message.append(line)

1167

message.append(line)

1168

1169

# make sure message isn't empty

1169

# make sure message isn't empty

1170

if not message:

1170

if not message:

1171

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

1171

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

1172

else:

1172

else:

1173

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

1173

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

1174

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

1174

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

1175

1176

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

1176

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

1177

files = []

1178

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

1179

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

1180

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

1181

if l.startswith('patching file '):

1182

pf = l[14:]

1183

if pf not in files:

1184

files.append(pf)

1185

patcherr = f.close()

1186

if patcherr:

1187

raise util.Abort("patch failed")

1188

1177

1189

if len(files) > 0:

1178

if len(files) > 0:

1190

addremove(ui, repo, *files)

1179

addremove(ui, repo, *files)

1191

repo.commit(files, message, user)

1180

repo.commit(files, message, user)

1192

1181

1193

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

1182

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

1194

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

1183

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

1195

source = ui.expandpath(source)

1184

source = ui.expandpath(source)

1196

other = hg.repository(ui, source)

1185

other = hg.repository(ui, source)

1197

if not other.local():

1186

if not other.local():

1198

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

1187

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

1199

o = repo.findincoming(other)

1188

o = repo.findincoming(other)

1200

if not o:

1189

if not o:

1201

return

1190

return

1202

o = other.newer(o)

1191

o = other.newer(o)

1203

o.reverse()

1192

o.reverse()

1204

for n in o:

1193

for n in o:

1205

show_changeset(ui, other, changenode=n)

1194

show_changeset(ui, other, changenode=n)

1206

if opts['patch']:

1195

if opts['patch']:

1207

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

1196

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

1208

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

1197

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

1209

ui.write("\n")

1198

ui.write("\n")

1210

1199

1211

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

1200

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

1212

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

1201

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

1213

if not os.path.exists(dest):

1202

if not os.path.exists(dest):

1214

os.mkdir(dest)

1203

os.mkdir(dest)

1215

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

1204

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

1216

1205

1217

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

1206

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

1218

"""locate files matching specific patterns"""

1207

"""locate files matching specific patterns"""

1219

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

1208

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

1220

1209

1221

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

1210

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

1222

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

1211

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

1223

continue

1212

continue

1224

if opts['fullpath']:

1213

if opts['fullpath']:

1225

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

1214

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

1226

else:

1215

else:

1227

ui.write(rel, end)

1216

ui.write(rel, end)

1228

1217

1229

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

1218

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

1230

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

1219

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

1231

class dui:

1220

class dui:

1232

# Implement and delegate some ui protocol. Save hunks of

1221

# Implement and delegate some ui protocol. Save hunks of

1233

# output for later display in the desired order.

1222

# output for later display in the desired order.

1234

def __init__(self, ui):

1223

def __init__(self, ui):

1235

self.ui = ui

1224

self.ui = ui

1236

self.hunk = {}

1225

self.hunk = {}

1237

def bump(self, rev):

1226

def bump(self, rev):

1238

self.rev = rev

1227

self.rev = rev

1239

self.hunk[rev] = []

1228

self.hunk[rev] = []

1240

def note(self, *args):

1229

def note(self, *args):

1241

if self.verbose:

1230

if self.verbose:

1242

self.write(*args)

1231

self.write(*args)

1243

def status(self, *args):

1232

def status(self, *args):

1244

if not self.quiet:

1233

if not self.quiet:

1245

self.write(*args)

1234

self.write(*args)

1246

def write(self, *args):

1235

def write(self, *args):

1247

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

1236

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

1248

def __getattr__(self, key):

1237

def __getattr__(self, key):

1249

return getattr(self.ui, key)

1238

return getattr(self.ui, key)

1250

cwd = repo.getcwd()

1239

cwd = repo.getcwd()

1251

if not pats and cwd:

1240

if not pats and cwd:

1252

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

1241

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

1253

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

1242

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

1254

changeiter, getchange = walkchangerevs(ui, repo, (pats and cwd) or '',

1243

changeiter, getchange = walkchangerevs(ui, repo, (pats and cwd) or '',

1255

pats, opts)

1244

pats, opts)

1256

for st, rev, fns in changeiter:

1245

for st, rev, fns in changeiter:

1257

if st == 'window':

1246

if st == 'window':

1258

du = dui(ui)

1247

du = dui(ui)

1259

elif st == 'add':

1248

elif st == 'add':

1260

du.bump(rev)

1249

du.bump(rev)

1261

br = None

1250

br = None

1262

if opts['branch']:

1251

if opts['branch']:

1263

br = repo.branchlookup([repo.changelog.node(rev)])

1252

br = repo.branchlookup([repo.changelog.node(rev)])

1264

show_changeset(du, repo, rev, brinfo=br)

1253

show_changeset(du, repo, rev, brinfo=br)

1265

if opts['patch']:

1254

if opts['patch']:

1266

changenode = repo.changelog.node(rev)

1255

changenode = repo.changelog.node(rev)

1267

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

1256

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

1268

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

1257

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

1269

du.write("\n\n")

1258

du.write("\n\n")

1270

elif st == 'iter':

1259

elif st == 'iter':

1271

for args in du.hunk[rev]:

1260

for args in du.hunk[rev]:

1272

ui.write(*args)

1261

ui.write(*args)

1273

1262

1274

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

1263

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

1275

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

1264

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

1276

if rev:

1265

if rev:

1277

try:

1266

try:

1278

# assume all revision numbers are for changesets

1267

# assume all revision numbers are for changesets

1279

n = repo.lookup(rev)

1268

n = repo.lookup(rev)

1280

change = repo.changelog.read(n)

1269

change = repo.changelog.read(n)

1281

n = change[0]

1270

n = change[0]

1282

except hg.RepoError:

1271

except hg.RepoError:

1283

n = repo.manifest.lookup(rev)

1272

n = repo.manifest.lookup(rev)

1284

else:

1273

else:

1285

n = repo.manifest.tip()

1274

n = repo.manifest.tip()

1286

m = repo.manifest.read(n)

1275

m = repo.manifest.read(n)

1287

mf = repo.manifest.readflags(n)

1276

mf = repo.manifest.readflags(n)

1288

files = m.keys()

1277

files = m.keys()

1289

files.sort()

1278

files.sort()

1290

1279

1291

for f in files:

1280

for f in files:

1292

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

1281

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

1293

1282

1294

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

1283

def outgoing(ui, repo, dest="default-push", **opts):

1295

"""show changesets not found in destination"""

1284

"""show changesets not found in destination"""

1296

dest = ui.expandpath(dest)

1285

dest = ui.expandpath(dest)

1297

other = hg.repository(ui, dest)

1286

other = hg.repository(ui, dest)

1298

o = repo.findoutgoing(other)

1287

o = repo.findoutgoing(other)

1299

o = repo.newer(o)

1288

o = repo.newer(o)

1300

o.reverse()

1289

o.reverse()

1301

for n in o:

1290

for n in o:

1302

show_changeset(ui, repo, changenode=n)

1291

show_changeset(ui, repo, changenode=n)

1303

if opts['patch']:

1292

if opts['patch']:

1304

prev = repo.changelog.parents(n)[0]

1293

prev = repo.changelog.parents(n)[0]

1305

dodiff(ui, ui, repo, prev, n)

1294

dodiff(ui, ui, repo, prev, n)

1306

ui.write("\n")

1295

ui.write("\n")

1307

1296

1308

def parents(ui, repo, rev=None):

1297

def parents(ui, repo, rev=None):

1309

"""show the parents of the working dir or revision"""

1298

"""show the parents of the working dir or revision"""

1310

if rev:

1299

if rev:

1311

p = repo.changelog.parents(repo.lookup(rev))

1300

p = repo.changelog.parents(repo.lookup(rev))

1312

else:

1301

else:

1313

p = repo.dirstate.parents()

1302

p = repo.dirstate.parents()

1314

1303

1315

for n in p:

1304

for n in p:

1316

if n != nullid:

1305

if n != nullid:

1317

show_changeset(ui, repo, changenode=n)

1306

show_changeset(ui, repo, changenode=n)

1318

1307

1319

def paths(ui, search=None):

1308

def paths(ui, search=None):

1320

"""show definition of symbolic path names"""

1309

"""show definition of symbolic path names"""

1321

try:

1310

try:

1322

repo = hg.repository(ui=ui)

1311

repo = hg.repository(ui=ui)

1323

except hg.RepoError:

1312

except hg.RepoError:

1324

pass

1313

pass

1325

1314

1326

if search:

1315

if search:

1327

for name, path in ui.configitems("paths"):

1316

for name, path in ui.configitems("paths"):

1328

if name == search:

1317

if name == search:

1329

ui.write("%s\n" % path)

1318

ui.write("%s\n" % path)

1330

return

1319

return

1331

ui.warn("not found!\n")

1320

ui.warn("not found!\n")

1332

return 1

1321

return 1

1333

else:

1322

else:

1334

for name, path in ui.configitems("paths"):

1323

for name, path in ui.configitems("paths"):

1335

ui.write("%s = %s\n" % (name, path))

1324

ui.write("%s = %s\n" % (name, path))

1336

1325

1337

def pull(ui, repo, source="default", **opts):

1326

def pull(ui, repo, source="default", **opts):

1338

"""pull changes from the specified source"""

1327

"""pull changes from the specified source"""

1339

source = ui.expandpath(source)

1328

source = ui.expandpath(source)

1340

ui.status('pulling from %s\n' % (source))

1329

ui.status('pulling from %s\n' % (source))

1341

1330

1342

if opts['ssh']:

1331

if opts['ssh']:

1343

ui.setconfig("ui", "ssh", opts['ssh'])

1332

ui.setconfig("ui", "ssh", opts['ssh'])

1344

if opts['remotecmd']:

1333

if opts['remotecmd']:

1345

ui.setconfig("ui", "remotecmd", opts['remotecmd'])

1334

ui.setconfig("ui", "remotecmd", opts['remotecmd'])

1346

1335

1347

other = hg.repository(ui, source)

1336

other = hg.repository(ui, source)

1348

r = repo.pull(other)

1337

r = repo.pull(other)

1349

if not r:

1338

if not r:

1350

if opts['update']:

1339

if opts['update']:

1351

return update(ui, repo)

1340

return update(ui, repo)

1352

else:

1341

else:

1353

ui.status("(run 'hg update' to get a working copy)\n")

1342

ui.status("(run 'hg update' to get a working copy)\n")

1354

1343

1355

return r

1344

return r

1356

1345

1357

def push(ui, repo, dest="default-push", force=False, ssh=None, remotecmd=None):

1346

def push(ui, repo, dest="default-push", force=False, ssh=None, remotecmd=None):

1358

"""push changes to the specified destination"""

1347

"""push changes to the specified destination"""

1359

dest = ui.expandpath(dest)

1348

dest = ui.expandpath(dest)

1360

ui.status('pushing to %s\n' % (dest))

1349

ui.status('pushing to %s\n' % (dest))

1361

1350

1362

if ssh:

1351

if ssh:

1363

ui.setconfig("ui", "ssh", ssh)

1352

ui.setconfig("ui", "ssh", ssh)

1364

if remotecmd:

1353

if remotecmd:

1365

ui.setconfig("ui", "remotecmd", remotecmd)

1354

ui.setconfig("ui", "remotecmd", remotecmd)

1366

1355

1367

other = hg.repository(ui, dest)

1356

other = hg.repository(ui, dest)

1368

r = repo.push(other, force)

1357

r = repo.push(other, force)

1369

return r

1358

return r

1370

1359

1371

def rawcommit(ui, repo, *flist, **rc):

1360

def rawcommit(ui, repo, *flist, **rc):

1372

"raw commit interface"

1361

"raw commit interface"

1373

if rc['text']:

1362

if rc['text']:

1374

ui.warn("Warning: -t and --text is deprecated,"

1363

ui.warn("Warning: -t and --text is deprecated,"

1375

" please use -m or --message instead.\n")

1364

" please use -m or --message instead.\n")

1376

message = rc['message'] or rc['text']

1365

message = rc['message'] or rc['text']

1377

if not message and rc['logfile']:

1366

if not message and rc['logfile']:

1378

try:

1367

try:

1379

message = open(rc['logfile']).read()

1368

message = open(rc['logfile']).read()

1380

except IOError:

1369

except IOError:

1381

pass

1370

pass

1382

if not message and not rc['logfile']:

1371

if not message and not rc['logfile']:

1383

raise util.Abort("missing commit message")

1372

raise util.Abort("missing commit message")

1384

1373

1385

files = relpath(repo, list(flist))

1374

files = relpath(repo, list(flist))

1386

if rc['files']:

1375

if rc['files']:

1387

files += open(rc['files']).read().splitlines()

1376

files += open(rc['files']).read().splitlines()

1388

1377

1389

rc['parent'] = map(repo.lookup, rc['parent'])

1378

rc['parent'] = map(repo.lookup, rc['parent'])

1390

1379

1391

try:

1380

try:

1392

repo.rawcommit(files, message, rc['user'], rc['date'], *rc['parent'])

1381

repo.rawcommit(files, message, rc['user'], rc['date'], *rc['parent'])

1393

except ValueError, inst:

1382

except ValueError, inst:

1394

raise util.Abort(str(inst))

1383

raise util.Abort(str(inst))

1395

1384

1396

def recover(ui, repo):

1385

def recover(ui, repo):

1397

"""roll back an interrupted transaction"""

1386

"""roll back an interrupted transaction"""

1398

repo.recover()

1387

repo.recover()

1399

1388

1400

def remove(ui, repo, pat, *pats, **opts):

1389

def remove(ui, repo, pat, *pats, **opts):

1401

"""remove the specified files on the next commit"""

1390

"""remove the specified files on the next commit"""

1402

names = []

1391

names = []

1403

def okaytoremove(abs, rel, exact):

1392

def okaytoremove(abs, rel, exact):

1404

c, a, d, u = repo.changes(files = [abs])

1393

c, a, d, u = repo.changes(files = [abs])

1405

reason = None

1394

reason = None

1406

if c: reason = 'is modified'

1395

if c: reason = 'is modified'

1407

elif a: reason = 'has been marked for add'

1396

elif a: reason = 'has been marked for add'

1408

elif u: reason = 'is not managed'

1397

elif u: reason = 'is not managed'

1409

if reason:

1398

if reason:

1410

if exact: ui.warn('not removing %s: file %s\n' % (rel, reason))

1399

if exact: ui.warn('not removing %s: file %s\n' % (rel, reason))

1411

else:

1400

else:

1412

return True

1401

return True

1413

for src, abs, rel, exact in walk(repo, (pat,) + pats, opts):

1402

for src, abs, rel, exact in walk(repo, (pat,) + pats, opts):

1414

if okaytoremove(abs, rel, exact):

1403

if okaytoremove(abs, rel, exact):

1415

if ui.verbose or not exact: ui.status('removing %s\n' % rel)

1404

if ui.verbose or not exact: ui.status('removing %s\n' % rel)

1416

names.append(abs)

1405

names.append(abs)

1417

for name in names:

1406

for name in names:

1418

try:

1407

try:

1419

os.unlink(name)

1408

os.unlink(name)

1420

except OSError, inst:

1409

except OSError, inst:

1421

if inst.errno != errno.ENOENT: raise

1410

if inst.errno != errno.ENOENT: raise

1422

repo.remove(names)

1411

repo.remove(names)

1423

1412

1424

def rename(ui, repo, *pats, **opts):

1413

def rename(ui, repo, *pats, **opts):

1425

"""rename files; equivalent of copy + remove"""

1414

"""rename files; equivalent of copy + remove"""

1426

errs, copied = docopy(ui, repo, pats, opts)

1415

errs, copied = docopy(ui, repo, pats, opts)

1427

names = []

1416

names = []

1428

for abs, rel, exact in copied:

1417

for abs, rel, exact in copied:

1429

if ui.verbose or not exact: ui.status('removing %s\n' % rel)

1418

if ui.verbose or not exact: ui.status('removing %s\n' % rel)

1430

try:

1419

try:

1431

os.unlink(rel)

1420

os.unlink(rel)

1432

except OSError, inst:

1421

except OSError, inst:

1433

if inst.errno != errno.ENOENT: raise

1422

if inst.errno != errno.ENOENT: raise

1434

names.append(abs)

1423

names.append(abs)

1435

repo.remove(names)

1424

repo.remove(names)

1436

return errs

1425

return errs

1437

1426

1438

def revert(ui, repo, *names, **opts):

1427

def revert(ui, repo, *names, **opts):

1439

"""revert modified files or dirs back to their unmodified states"""

1428

"""revert modified files or dirs back to their unmodified states"""

1440

node = opts['rev'] and repo.lookup(opts['rev']) or \

1429

node = opts['rev'] and repo.lookup(opts['rev']) or \

1441

repo.dirstate.parents()[0]

1430

repo.dirstate.parents()[0]

1442

root = os.path.realpath(repo.root)

1431

root = os.path.realpath(repo.root)

1443

1432

1444

def trimpath(p):

1433

def trimpath(p):

1445

p = os.path.realpath(p)

1434

p = os.path.realpath(p)

1446

if p.startswith(root):

1435

if p.startswith(root):

1447

rest = p[len(root):]

1436

rest = p[len(root):]

1448

if not rest:

1437

if not rest:

1449

return rest

1438

return rest

1450

if p.startswith(os.sep):

1439

if p.startswith(os.sep):

1451

return rest[1:]

1440

return rest[1:]

1452

return p

1441

return p

1453

1442

1454

relnames = map(trimpath, names or [os.getcwd()])

1443

relnames = map(trimpath, names or [os.getcwd()])

1455

chosen = {}

1444

chosen = {}

1456

1445

1457

def choose(name):

1446

def choose(name):

1458

def body(name):

1447

def body(name):

1459

for r in relnames:

1448

for r in relnames:

1460

if not name.startswith(r):

1449

if not name.startswith(r):

1461

continue

1450

continue

1462

rest = name[len(r):]

1451

rest = name[len(r):]

1463

if not rest:

1452

if not rest:

1464

return r, True

1453

return r, True

1465

depth = rest.count(os.sep)

1454

depth = rest.count(os.sep)

1466

if not r:

1455

if not r:

1467

if depth == 0 or not opts['nonrecursive']:

1456

if depth == 0 or not opts['nonrecursive']:

1468

return r, True

1457

return r, True

1469

elif rest[0] == os.sep:

1458

elif rest[0] == os.sep:

1470

if depth == 1 or not opts['nonrecursive']:

1459

if depth == 1 or not opts['nonrecursive']:

1471

return r, True

1460

return r, True

1472

return None, False

1461

return None, False

1473

relname, ret = body(name)

1462

relname, ret = body(name)

1474

if ret:

1463

if ret:

1475

chosen[relname] = 1

1464

chosen[relname] = 1

1476

return ret

1465

return ret

1477

1466

1478

r = repo.update(node, False, True, choose, False)

1467

r = repo.update(node, False, True, choose, False)

1479

for n in relnames:

1468

for n in relnames:

1480

if n not in chosen:

1469

if n not in chosen:

1481

ui.warn('error: no matches for %s\n' % n)

1470

ui.warn('error: no matches for %s\n' % n)

1482

r = 1

1471

r = 1

1483

sys.stdout.flush()

1472

sys.stdout.flush()

1484

return r

1473

return r

1485

1474

1486

def root(ui, repo):

1475

def root(ui, repo):

1487

"""print the root (top) of the current working dir"""

1476

"""print the root (top) of the current working dir"""

1488

ui.write(repo.root + "\n")

1477

ui.write(repo.root + "\n")

1489

1478

1490

def serve(ui, repo, **opts):

1479

def serve(ui, repo, **opts):

1491

"""export the repository via HTTP"""

1480

"""export the repository via HTTP"""

1492

1481

1493

if opts["stdio"]:

1482

if opts["stdio"]:

1494

fin, fout = sys.stdin, sys.stdout

1483

fin, fout = sys.stdin, sys.stdout

1495

sys.stdout = sys.stderr

1484

sys.stdout = sys.stderr

1496

1485

1497

def getarg():

1486

def getarg():

1498

argline = fin.readline()[:-1]

1487

argline = fin.readline()[:-1]

1499

arg, l = argline.split()

1488

arg, l = argline.split()

1500

val = fin.read(int(l))

1489

val = fin.read(int(l))

1501

return arg, val

1490

return arg, val

1502

def respond(v):

1491

def respond(v):

1503

fout.write("%d\n" % len(v))

1492

fout.write("%d\n" % len(v))

1504

fout.write(v)

1493

fout.write(v)

1505

fout.flush()

1494

fout.flush()

1506

1495

1507

lock = None

1496

lock = None

1508

1497

1509

while 1:

1498

while 1:

1510

cmd = fin.readline()[:-1]

1499

cmd = fin.readline()[:-1]

1511

if cmd == '':

1500

if cmd == '':

1512

return

1501

return

1513

if cmd == "heads":

1502

if cmd == "heads":

1514

h = repo.heads()

1503

h = repo.heads()

1515

respond(" ".join(map(hex, h)) + "\n")

1504

respond(" ".join(map(hex, h)) + "\n")

1516

if cmd == "lock":

1505

if cmd == "lock":

1517

lock = repo.lock()

1506

lock = repo.lock()

1518

respond("")

1507

respond("")

1519

if cmd == "unlock":

1508

if cmd == "unlock":

1520

if lock:

1509

if lock:

1521

lock.release()

1510

lock.release()

1522

lock = None

1511

lock = None

1523

respond("")

1512

respond("")

1524

elif cmd == "branches":

1513

elif cmd == "branches":

1525

arg, nodes = getarg()

1514

arg, nodes = getarg()

1526

nodes = map(bin, nodes.split(" "))

1515

nodes = map(bin, nodes.split(" "))

1527

r = []

1516

r = []

1528

for b in repo.branches(nodes):

1517

for b in repo.branches(nodes):

1529

r.append(" ".join(map(hex, b)) + "\n")

1518

r.append(" ".join(map(hex, b)) + "\n")

1530

respond("".join(r))

1519

respond("".join(r))

1531

elif cmd == "between":

1520

elif cmd == "between":

1532

arg, pairs = getarg()

1521

arg, pairs = getarg()

1533

pairs = [map(bin, p.split("-")) for p in pairs.split(" ")]

1522

pairs = [map(bin, p.split("-")) for p in pairs.split(" ")]

1534

r = []

1523

r = []

1535

for b in repo.between(pairs):

1524

for b in repo.between(pairs):

1536

r.append(" ".join(map(hex, b)) + "\n")

1525

r.append(" ".join(map(hex, b)) + "\n")

1537

respond("".join(r))

1526

respond("".join(r))

1538

elif cmd == "changegroup":

1527

elif cmd == "changegroup":

1539

nodes = []

1528

nodes = []

1540

arg, roots = getarg()

1529

arg, roots = getarg()

1541

nodes = map(bin, roots.split(" "))

1530

nodes = map(bin, roots.split(" "))

1542

1531

1543

cg = repo.changegroup(nodes)

1532

cg = repo.changegroup(nodes)

1544

while 1:

1533

while 1:

1545

d = cg.read(4096)

1534

d = cg.read(4096)

1546

if not d:

1535

if not d:

1547

break

1536

break

1548

fout.write(d)

1537

fout.write(d)

1549

1538

1550

fout.flush()

1539

fout.flush()

1551

1540

1552

elif cmd == "addchangegroup":

1541

elif cmd == "addchangegroup":

1553

if not lock:

1542

if not lock:

1554

respond("not locked")

1543

respond("not locked")

1555

continue

1544

continue

1556

respond("")

1545

respond("")

1557

1546

1558

r = repo.addchangegroup(fin)

1547

r = repo.addchangegroup(fin)

1559

respond("")

1548

respond("")

1560

1549

1561

optlist = "name templates style address port ipv6 accesslog errorlog"

1550

optlist = "name templates style address port ipv6 accesslog errorlog"

1562

for o in optlist.split():

1551

for o in optlist.split():

1563

if opts[o]:

1552

if opts[o]:

1564

ui.setconfig("web", o, opts[o])

1553

ui.setconfig("web", o, opts[o])

1565

1554

1566

try:

1555

try:

1567

httpd = hgweb.create_server(repo)

1556

httpd = hgweb.create_server(repo)

1568

except socket.error, inst:

1557

except socket.error, inst:

1569

raise util.Abort('cannot start server: ' + inst.args[1])

1558

raise util.Abort('cannot start server: ' + inst.args[1])

1570

1559

1571

if ui.verbose:

1560

if ui.verbose:

1572

addr, port = httpd.socket.getsockname()

1561

addr, port = httpd.socket.getsockname()

1573

if addr == '0.0.0.0':

1562

if addr == '0.0.0.0':

1574

addr = socket.gethostname()

1563

addr = socket.gethostname()

1575

else:

1564

else:

1576

try:

1565

try:

1577

addr = socket.gethostbyaddr(addr)[0]

1566

addr = socket.gethostbyaddr(addr)[0]

1578

except socket.error:

1567

except socket.error:

1579

pass

1568

pass

1580

if port != 80:

1569

if port != 80:

1581

ui.status('listening at http://%s:%d/\n' % (addr, port))

1570

ui.status('listening at http://%s:%d/\n' % (addr, port))

1582

else:

1571

else:

1583

ui.status('listening at http://%s/\n' % addr)

1572

ui.status('listening at http://%s/\n' % addr)

1584

httpd.serve_forever()

1573

httpd.serve_forever()

1585

1574

1586

def status(ui, repo, *pats, **opts):

1575

def status(ui, repo, *pats, **opts):

1587

'''show changed files in the working directory

1576

'''show changed files in the working directory

1588

1577

1589

M = modified

1578

M = modified

1590

A = added

1579

A = added

1591

R = removed

1580

R = removed

1592

? = not tracked

1581

? = not tracked

1593

'''

1582

'''

1594

1583

1595

cwd = repo.getcwd()

1584

cwd = repo.getcwd()

1596

files, matchfn, anypats = matchpats(repo, cwd, pats, opts)

1585

files, matchfn, anypats = matchpats(repo, cwd, pats, opts)

1597

(c, a, d, u) = [[util.pathto(cwd, x) for x in n]

1586

(c, a, d, u) = [[util.pathto(cwd, x) for x in n]

1598

for n in repo.changes(files=files, match=matchfn)]

1587

for n in repo.changes(files=files, match=matchfn)]

1599

1588

1600

changetypes = [('modified', 'M', c),

1589

changetypes = [('modified', 'M', c),

1601

('added', 'A', a),

1590

('added', 'A', a),

1602

('removed', 'R', d),

1591

('removed', 'R', d),

1603

('unknown', '?', u)]

1592

('unknown', '?', u)]

1604

1593

1605

end = opts['print0'] and '\0' or '\n'

1594

end = opts['print0'] and '\0' or '\n'

1606

1595

1607

for opt, char, changes in ([ct for ct in changetypes if opts[ct[0]]]

1596

for opt, char, changes in ([ct for ct in changetypes if opts[ct[0]]]

1608

or changetypes):

1597

or changetypes):

1609

if opts['no_status']:

1598

if opts['no_status']:

1610

format = "%%s%s" % end

1599

format = "%%s%s" % end

1611

else:

1600

else:

1612

format = "%s %%s%s" % (char, end);

1601

format = "%s %%s%s" % (char, end);

1613

1602

1614

for f in changes:

1603

for f in changes:

1615

ui.write(format % f)

1604

ui.write(format % f)

1616

1605

1617

def tag(ui, repo, name, rev=None, **opts):

1606

def tag(ui, repo, name, rev=None, **opts):

1618

"""add a tag for the current tip or a given revision"""

1607

"""add a tag for the current tip or a given revision"""

1619

if opts['text']:

1608

if opts['text']:

1620

ui.warn("Warning: -t and --text is deprecated,"

1609

ui.warn("Warning: -t and --text is deprecated,"

1621

" please use -m or --message instead.\n")

1610

" please use -m or --message instead.\n")

1622

if name == "tip":

1611

if name == "tip":

1623

raise util.Abort("the name 'tip' is reserved")

1612

raise util.Abort("the name 'tip' is reserved")

1624

if rev:

1613

if rev:

1625

r = hex(repo.lookup(rev))

1614

r = hex(repo.lookup(rev))

1626

else:

1615

else:

1627

r = hex(repo.changelog.tip())

1616

r = hex(repo.changelog.tip())

1628

1617

1629

if name.find(revrangesep) >= 0:

1618

if name.find(revrangesep) >= 0:

1630

raise util.Abort("'%s' cannot be used in a tag name" % revrangesep)

1619

raise util.Abort("'%s' cannot be used in a tag name" % revrangesep)

1631

1620

1632

if opts['local']:

1621

if opts['local']:

1633

repo.opener("localtags", "a").write("%s %s\n" % (r, name))

1622

repo.opener("localtags", "a").write("%s %s\n" % (r, name))

1634

return

1623

return

1635

1624

1636

(c, a, d, u) = repo.changes()

1625

(c, a, d, u) = repo.changes()

1637

for x in (c, a, d, u):

1626

for x in (c, a, d, u):

1638

if ".hgtags" in x:

1627

if ".hgtags" in x:

1639

raise util.Abort("working copy of .hgtags is changed "

1628

raise util.Abort("working copy of .hgtags is changed "

1640

"(please commit .hgtags manually)")

1629

"(please commit .hgtags manually)")

1641

1630

1642

repo.wfile(".hgtags", "ab").write("%s %s\n" % (r, name))

1631

repo.wfile(".hgtags", "ab").write("%s %s\n" % (r, name))

1643

if repo.dirstate.state(".hgtags") == '?':

1632

if repo.dirstate.state(".hgtags") == '?':

1644

repo.add([".hgtags"])

1633

repo.add([".hgtags"])

1645

1634

1646

message = (opts['message'] or opts['text'] or

1635

message = (opts['message'] or opts['text'] or

1647

"Added tag %s for changeset %s" % (name, r))

1636

"Added tag %s for changeset %s" % (name, r))

1648

try:

1637

try:

1649

repo.commit([".hgtags"], message, opts['user'], opts['date'])

1638

repo.commit([".hgtags"], message, opts['user'], opts['date'])

1650

except ValueError, inst:

1639

except ValueError, inst:

1651

raise util.Abort(str(inst))

1640

raise util.Abort(str(inst))

1652

1641

1653

def tags(ui, repo):

1642

def tags(ui, repo):

1654

"""list repository tags"""

1643

"""list repository tags"""

1655

1644

1656

l = repo.tagslist()

1645

l = repo.tagslist()

1657

l.reverse()

1646

l.reverse()

1658

for t, n in l:

1647

for t, n in l:

1659

try:

1648

try:

1660

r = "%5d:%s" % (repo.changelog.rev(n), hex(n))

1649

r = "%5d:%s" % (repo.changelog.rev(n), hex(n))

1661

except KeyError:

1650

except KeyError:

1662

r = " ?:?"

1651

r = " ?:?"

1663

ui.write("%-30s %s\n" % (t, r))

1652

ui.write("%-30s %s\n" % (t, r))

1664

1653

1665

def tip(ui, repo):

1654

def tip(ui, repo):

1666

"""show the tip revision"""

1655

"""show the tip revision"""

1667

n = repo.changelog.tip()

1656

n = repo.changelog.tip()

1668

show_changeset(ui, repo, changenode=n)

1657

show_changeset(ui, repo, changenode=n)

1669

1658

1670

def unbundle(ui, repo, fname):

1659

def unbundle(ui, repo, fname):

1671

"""apply a changegroup file"""

1660

"""apply a changegroup file"""

1672

f = urllib.urlopen(fname)

1661

f = urllib.urlopen(fname)

1673

1662

1674

if f.read(4) != "HG10":

1663

if f.read(4) != "HG10":

1675

raise util.Abort("%s: not a Mercurial bundle file" % fname)

1664

raise util.Abort("%s: not a Mercurial bundle file" % fname)

1676

1665

1677

class bzread:

1666

class bzread:

1678

def __init__(self, f):

1667

def __init__(self, f):

1679

self.zd = bz2.BZ2Decompressor()

1668

self.zd = bz2.BZ2Decompressor()

1680

self.f = f

1669

self.f = f

1681

self.buf = ""

1670

self.buf = ""

1682

def read(self, l):

1671

def read(self, l):

1683

while l > len(self.buf):

1672

while l > len(self.buf):

1684

r = self.f.read(4096)

1673

r = self.f.read(4096)

1685

if r:

1674

if r:

1686

self.buf += self.zd.decompress(r)

1675

self.buf += self.zd.decompress(r)

1687

else:

1676

else:

1688

break

1677

break

1689

d, self.buf = self.buf[:l], self.buf[l:]

1678

d, self.buf = self.buf[:l], self.buf[l:]

1690

return d

1679

return d

1691

1680

1692

repo.addchangegroup(bzread(f))

1681

repo.addchangegroup(bzread(f))

1693

1682

1694

def undo(ui, repo):

1683

def undo(ui, repo):

1695

"""undo the last commit or pull

1684

"""undo the last commit or pull

1696

1685

1697

Roll back the last pull or commit transaction on the

1686

Roll back the last pull or commit transaction on the

1698

repository, restoring the project to its earlier state.

1687

repository, restoring the project to its earlier state.

1699

1688

1700

This command should be used with care. There is only one level of

1689

This command should be used with care. There is only one level of

1701

undo and there is no redo.

1690

undo and there is no redo.

1702

1691

1703

This command is not intended for use on public repositories. Once

1692

This command is not intended for use on public repositories. Once

1704

a change is visible for pull by other users, undoing it locally is

1693

a change is visible for pull by other users, undoing it locally is

1705

ineffective.

1694

ineffective.

1706

"""

1695

"""

1707

repo.undo()

1696

repo.undo()

1708

1697

1709

def update(ui, repo, node=None, merge=False, clean=False, branch=None):

1698

def update(ui, repo, node=None, merge=False, clean=False, branch=None):

1710

'''update or merge working directory

1699

'''update or merge working directory

1711

1700

1712

If there are no outstanding changes in the working directory and

1701

If there are no outstanding changes in the working directory and

1713

there is a linear relationship between the current version and the

1702

there is a linear relationship between the current version and the

1714

requested version, the result is the requested version.

1703

requested version, the result is the requested version.

1715

1704

1716

Otherwise the result is a merge between the contents of the

1705

Otherwise the result is a merge between the contents of the

1717

current working directory and the requested version. Files that

1706

current working directory and the requested version. Files that

1718

changed between either parent are marked as changed for the next

1707

changed between either parent are marked as changed for the next

1719

commit and a commit must be performed before any further updates

1708

commit and a commit must be performed before any further updates

1720

are allowed.

1709

are allowed.

1721

'''

1710

'''

1722

if branch:

1711

if branch:

1723

br = repo.branchlookup(branch=branch)

1712

br = repo.branchlookup(branch=branch)

1724

found = []

1713

found = []

1725

for x in br:

1714

for x in br:

1726

if branch in br[x]:

1715

if branch in br[x]:

1727

found.append(x)

1716

found.append(x)

1728

if len(found) > 1:

1717

if len(found) > 1:

1729

ui.warn("Found multiple heads for %s\n" % branch)

1718

ui.warn("Found multiple heads for %s\n" % branch)

1730

for x in found:

1719

for x in found:

1731

show_changeset(ui, repo, changenode=x, brinfo=br)

1720

show_changeset(ui, repo, changenode=x, brinfo=br)

1732

return 1

1721

return 1

1733

if len(found) == 1:

1722

if len(found) == 1:

1734

node = found[0]

1723

node = found[0]

1735

ui.warn("Using head %s for branch %s\n" % (short(node), branch))

1724

ui.warn("Using head %s for branch %s\n" % (short(node), branch))

1736

else:

1725

else:

1737

ui.warn("branch %s not found\n" % (branch))

1726

ui.warn("branch %s not found\n" % (branch))

1738

return 1

1727

return 1

1739

else:

1728

else:

1740

node = node and repo.lookup(node) or repo.changelog.tip()

1729

node = node and repo.lookup(node) or repo.changelog.tip()

1741

return repo.update(node, allow=merge, force=clean)

1730

return repo.update(node, allow=merge, force=clean)

1742

1731

1743

def verify(ui, repo):

1732

def verify(ui, repo):

1744

"""verify the integrity of the repository"""

1733

"""verify the integrity of the repository"""

1745

return repo.verify()

1734

return repo.verify()

1746

1735

1747

# Command options and aliases are listed here, alphabetically

1736

# Command options and aliases are listed here, alphabetically

1748

1737

1749

table = {

1738

table = {

1750

"^add":

1739

"^add":

1751

(add,

1740

(add,

1752

[('I', 'include', [], 'include path in search'),

1741

[('I', 'include', [], 'include path in search'),

1753

('X', 'exclude', [], 'exclude path from search')],

1742

('X', 'exclude', [], 'exclude path from search')],

1754

"hg add [OPTION]... [FILE]..."),

1743

"hg add [OPTION]... [FILE]..."),

1755

"addremove":

1744

"addremove":

1756

(addremove,

1745

(addremove,

1757

[('I', 'include', [], 'include path in search'),

1746

[('I', 'include', [], 'include path in search'),

1758

('X', 'exclude', [], 'exclude path from search')],

1747

('X', 'exclude', [], 'exclude path from search')],

1759

"hg addremove [OPTION]... [FILE]..."),

1748

"hg addremove [OPTION]... [FILE]..."),

1760

"^annotate":

1749

"^annotate":

1761

(annotate,

1750

(annotate,

1762

[('r', 'rev', '', 'revision'),

1751

[('r', 'rev', '', 'revision'),

1763

('a', 'text', None, 'treat all files as text'),

1752

('a', 'text', None, 'treat all files as text'),

1764

('u', 'user', None, 'show user'),

1753

('u', 'user', None, 'show user'),

1765

('n', 'number', None, 'show revision number'),

1754

('n', 'number', None, 'show revision number'),

1766

('c', 'changeset', None, 'show changeset'),

1755

('c', 'changeset', None, 'show changeset'),

1767

('I', 'include', [], 'include path in search'),

1756

('I', 'include', [], 'include path in search'),

1768

('X', 'exclude', [], 'exclude path from search')],

1757

('X', 'exclude', [], 'exclude path from search')],

1769

'hg annotate [OPTION]... FILE...'),

1758

'hg annotate [OPTION]... FILE...'),

1770

"bundle":

1759

"bundle":

1771

(bundle,

1760

(bundle,

1772

[],

1761

[],

1773

'hg bundle FILE DEST'),

1762

'hg bundle FILE DEST'),

1774

"cat":

1763

"cat":

1775

(cat,

1764

(cat,

1776

[('I', 'include', [], 'include path in search'),

1765

[('I', 'include', [], 'include path in search'),

1777

('X', 'exclude', [], 'exclude path from search'),

1766

('X', 'exclude', [], 'exclude path from search'),

1778

('o', 'output', "", 'output to file'),

1767

('o', 'output', "", 'output to file'),

1779

('r', 'rev', '', 'revision')],

1768

('r', 'rev', '', 'revision')],

1780

'hg cat [OPTION]... FILE...'),

1769

'hg cat [OPTION]... FILE...'),

1781

"^clone":

1770

"^clone":

1782

(clone,

1771

(clone,

1783

[('U', 'noupdate', None, 'skip update after cloning'),

1772

[('U', 'noupdate', None, 'skip update after cloning'),

1784

('e', 'ssh', "", 'ssh command'),

1773

('e', 'ssh', "", 'ssh command'),

1785

('', 'pull', None, 'use pull protocol to copy metadata'),

1774

('', 'pull', None, 'use pull protocol to copy metadata'),

1786

('', 'remotecmd', "", 'remote hg command')],

1775

('', 'remotecmd', "", 'remote hg command')],

1787

'hg clone [OPTION]... SOURCE [DEST]'),

1776

'hg clone [OPTION]... SOURCE [DEST]'),

1788

"^commit|ci":

1777

"^commit|ci":

1789

(commit,

1778

(commit,

1790

[('A', 'addremove', None, 'run add/remove during commit'),

1779

[('A', 'addremove', None, 'run add/remove during commit'),

1791

('I', 'include', [], 'include path in search'),

1780

('I', 'include', [], 'include path in search'),

1792

('X', 'exclude', [], 'exclude path from search'),

1781

('X', 'exclude', [], 'exclude path from search'),

1793

('m', 'message', "", 'commit message'),

1782

('m', 'message', "", 'commit message'),

1794

('t', 'text', "", 'commit message (deprecated: use -m)'),

1783

('t', 'text', "", 'commit message (deprecated: use -m)'),

1795

('l', 'logfile', "", 'commit message file'),

1784

('l', 'logfile', "", 'commit message file'),

1796

('d', 'date', "", 'date code'),

1785

('d', 'date', "", 'date code'),

1797

('u', 'user', "", 'user')],

1786

('u', 'user', "", 'user')],

1798

'hg commit [OPTION]... [FILE]...'),

1787

'hg commit [OPTION]... [FILE]...'),

1799

"copy|cp": (copy,

1788

"copy|cp": (copy,

1800

[('I', 'include', [], 'include path in search'),

1789

[('I', 'include', [], 'include path in search'),

1801

('X', 'exclude', [], 'exclude path from search'),

1790

('X', 'exclude', [], 'exclude path from search'),

1802

('A', 'after', None, 'record a copy after it has happened'),

1791

('A', 'after', None, 'record a copy after it has happened'),

1803

('f', 'force', None, 'replace destination if it exists'),

1792

('f', 'force', None, 'replace destination if it exists'),

1804

('p', 'parents', None, 'append source path to dest')],

1793

('p', 'parents', None, 'append source path to dest')],

1805

'hg copy [OPTION]... [SOURCE]... DEST'),

1794

'hg copy [OPTION]... [SOURCE]... DEST'),

1806

"debugancestor": (debugancestor, [], 'debugancestor INDEX REV1 REV2'),

1795

"debugancestor": (debugancestor, [], 'debugancestor INDEX REV1 REV2'),

1807

"debugcheckstate": (debugcheckstate, [], 'debugcheckstate'),

1796

"debugcheckstate": (debugcheckstate, [], 'debugcheckstate'),

1808

"debugconfig": (debugconfig, [], 'debugconfig'),

1797

"debugconfig": (debugconfig, [], 'debugconfig'),

1809

"debugstate": (debugstate, [], 'debugstate'),

1798

"debugstate": (debugstate, [], 'debugstate'),

1810

"debugdata": (debugdata, [], 'debugdata FILE REV'),

1799

"debugdata": (debugdata, [], 'debugdata FILE REV'),

1811

"debugindex": (debugindex, [], 'debugindex FILE'),

1800

"debugindex": (debugindex, [], 'debugindex FILE'),

1812

"debugindexdot": (debugindexdot, [], 'debugindexdot FILE'),

1801

"debugindexdot": (debugindexdot, [], 'debugindexdot FILE'),

1813

"debugrename": (debugrename, [], 'debugrename FILE [REV]'),

1802

"debugrename": (debugrename, [], 'debugrename FILE [REV]'),

1814

"debugwalk":

1803

"debugwalk":

1815

(debugwalk,

1804

(debugwalk,

1816

[('I', 'include', [], 'include path in search'),

1805

[('I', 'include', [], 'include path in search'),

1817

('X', 'exclude', [], 'exclude path from search')],

1806

('X', 'exclude', [], 'exclude path from search')],

1818

'debugwalk [OPTION]... [FILE]...'),

1807

'debugwalk [OPTION]... [FILE]...'),

1819

"^diff":

1808

"^diff":

1820

(diff,

1809

(diff,

1821

[('r', 'rev', [], 'revision'),

1810

[('r', 'rev', [], 'revision'),

1822

('a', 'text', None, 'treat all files as text'),

1811

('a', 'text', None, 'treat all files as text'),

1823

('I', 'include', [], 'include path in search'),

1812

('I', 'include', [], 'include path in search'),

1824

('X', 'exclude', [], 'exclude path from search')],

1813

('X', 'exclude', [], 'exclude path from search')],

1825

'hg diff [-a] [-I] [-X] [-r REV1 [-r REV2]] [FILE]...'),

1814

'hg diff [-a] [-I] [-X] [-r REV1 [-r REV2]] [FILE]...'),

1826

"^export":

1815

"^export":

1827

(export,

1816

(export,

1828

[('o', 'output', "", 'output to file'),

1817

[('o', 'output', "", 'output to file'),

1829

('a', 'text', None, 'treat all files as text')],

1818

('a', 'text', None, 'treat all files as text')],

1830

"hg export [-a] [-o OUTFILE] REV..."),

1819

"hg export [-a] [-o OUTFILE] REV..."),

1831

"forget":

1820

"forget":

1832

(forget,

1821

(forget,

1833

[('I', 'include', [], 'include path in search'),

1822

[('I', 'include', [], 'include path in search'),

1834

('X', 'exclude', [], 'exclude path from search')],

1823

('X', 'exclude', [], 'exclude path from search')],

1835

"hg forget [OPTION]... FILE..."),

1824

"hg forget [OPTION]... FILE..."),

1836

"grep":

1825

"grep":

1837

(grep,

1826

(grep,

1838

[('0', 'print0', None, 'end fields with NUL'),

1827

[('0', 'print0', None, 'end fields with NUL'),

1839

('I', 'include', [], 'include path in search'),

1828

('I', 'include', [], 'include path in search'),

1840

('X', 'exclude', [], 'include path in search'),

1829

('X', 'exclude', [], 'include path in search'),

1841

('', 'all', None, 'print all revisions with matches'),

1830

('', 'all', None, 'print all revisions with matches'),

1842

('i', 'ignore-case', None, 'ignore case when matching'),

1831

('i', 'ignore-case', None, 'ignore case when matching'),

1843

('l', 'files-with-matches', None, 'print names of files and revs with matches'),

1832

('l', 'files-with-matches', None, 'print names of files and revs with matches'),

1844

('n', 'line-number', None, 'print line numbers'),

1833

('n', 'line-number', None, 'print line numbers'),

1845

('r', 'rev', [], 'search in revision rev'),

1834

('r', 'rev', [], 'search in revision rev'),

1846

('u', 'user', None, 'print user who made change')],

1835

('u', 'user', None, 'print user who made change')],

1847

"hg grep [OPTION]... PATTERN [FILE]..."),

1836

"hg grep [OPTION]... PATTERN [FILE]..."),

1848

"heads":

1837

"heads":

1849

(heads,

1838

(heads,

1850

[('b', 'branches', None, 'find branch info')],

1839

[('b', 'branches', None, 'find branch info')],

1851

'hg heads [-b]'),

1840

'hg heads [-b]'),

1852

"help": (help_, [], 'hg help [COMMAND]'),

1841

"help": (help_, [], 'hg help [COMMAND]'),

1853

"identify|id": (identify, [], 'hg identify'),

1842

"identify|id": (identify, [], 'hg identify'),

1854

"import|patch":

1843

"import|patch":

1855

(import_,

1844

(import_,

1856

[('p', 'strip', 1, 'path strip'),

1845

[('p', 'strip', 1, 'path strip'),

1857

('f', 'force', None, 'skip check for outstanding changes'),

1846

('f', 'force', None, 'skip check for outstanding changes'),

1858

('b', 'base', "", 'base path')],

1847

('b', 'base', "", 'base path')],

1859

"hg import [-f] [-p NUM] [-b BASE] PATCH..."),

1848

"hg import [-f] [-p NUM] [-b BASE] PATCH..."),

1860

"incoming|in": (incoming,

1849

"incoming|in": (incoming,

1861

[('p', 'patch', None, 'show patch')],

1850

[('p', 'patch', None, 'show patch')],

1862

'hg incoming [-p] [SOURCE]'),

1851

'hg incoming [-p] [SOURCE]'),

1863

"^init": (init, [], 'hg init [DEST]'),

1852

"^init": (init, [], 'hg init [DEST]'),

1864

"locate":

1853

"locate":

1865

(locate,

1854

(locate,

1866

[('r', 'rev', '', 'revision'),

1855

[('r', 'rev', '', 'revision'),

1867

('0', 'print0', None, 'end filenames with NUL'),

1856

('0', 'print0', None, 'end filenames with NUL'),

1868

('f', 'fullpath', None, 'print complete paths'),

1857

('f', 'fullpath', None, 'print complete paths'),

1869

('I', 'include', [], 'include path in search'),

1858

('I', 'include', [], 'include path in search'),

1870

('X', 'exclude', [], 'exclude path from search')],

1859

('X', 'exclude', [], 'exclude path from search')],

1871

'hg locate [OPTION]... [PATTERN]...'),

1860

'hg locate [OPTION]... [PATTERN]...'),

1872

"^log|history":

1861

"^log|history":

1873

(log,

1862

(log,

1874

[('I', 'include', [], 'include path in search'),

1863

[('I', 'include', [], 'include path in search'),

1875

('X', 'exclude', [], 'exclude path from search'),

1864

('X', 'exclude', [], 'exclude path from search'),

1876

('b', 'branch', None, 'show branches'),

1865

('b', 'branch', None, 'show branches'),

1877

('r', 'rev', [], 'revision'),

1866

('r', 'rev', [], 'revision'),

1878

('p', 'patch', None, 'show patch')],

1867

('p', 'patch', None, 'show patch')],

1879

'hg log [-I] [-X] [-r REV]... [-p] [FILE]'),

1868

'hg log [-I] [-X] [-r REV]... [-p] [FILE]'),

1880

"manifest": (manifest, [], 'hg manifest [REV]'),

1869

"manifest": (manifest, [], 'hg manifest [REV]'),

1881

"outgoing|out": (outgoing,

1870

"outgoing|out": (outgoing,

1882

[('p', 'patch', None, 'show patch')],

1871

[('p', 'patch', None, 'show patch')],

1883

'hg outgoing [-p] [DEST]'),

1872

'hg outgoing [-p] [DEST]'),

1884

"parents": (parents, [], 'hg parents [REV]'),

1873

"parents": (parents, [], 'hg parents [REV]'),

1885

"paths": (paths, [], 'hg paths [NAME]'),

1874

"paths": (paths, [], 'hg paths [NAME]'),

1886

"^pull":

1875

"^pull":

1887

(pull,

1876

(pull,

1888

[('u', 'update', None, 'update working directory'),

1877

[('u', 'update', None, 'update working directory'),

1889

('e', 'ssh', "", 'ssh command'),

1878

('e', 'ssh', "", 'ssh command'),

1890

('', 'remotecmd', "", 'remote hg command')],

1879

('', 'remotecmd', "", 'remote hg command')],

1891

'hg pull [-u] [-e FILE] [--remotecmd FILE] [SOURCE]'),

1880

'hg pull [-u] [-e FILE] [--remotecmd FILE] [SOURCE]'),

1892

"^push":

1881

"^push":

1893

(push,

1882

(push,

1894

[('f', 'force', None, 'force push'),

1883

[('f', 'force', None, 'force push'),

1895

('e', 'ssh', "", 'ssh command'),

1884

('e', 'ssh', "", 'ssh command'),

1896

('', 'remotecmd', "", 'remote hg command')],

1885

('', 'remotecmd', "", 'remote hg command')],

1897

'hg push [-f] [-e FILE] [--remotecmd FILE] [DEST]'),

1886

'hg push [-f] [-e FILE] [--remotecmd FILE] [DEST]'),

1898

"rawcommit":

1887

"rawcommit":

1899

(rawcommit,

1888

(rawcommit,

1900

[('p', 'parent', [], 'parent'),

1889

[('p', 'parent', [], 'parent'),

1901

('d', 'date', "", 'date code'),

1890

('d', 'date', "", 'date code'),

1902

('u', 'user', "", 'user'),

1891

('u', 'user', "", 'user'),

1903

('F', 'files', "", 'file list'),

1892

('F', 'files', "", 'file list'),

1904

('m', 'message', "", 'commit message'),

1893

('m', 'message', "", 'commit message'),

1905

('t', 'text', "", 'commit message (deprecated: use -m)'),

1894

('t', 'text', "", 'commit message (deprecated: use -m)'),

1906

('l', 'logfile', "", 'commit message file')],

1895

('l', 'logfile', "", 'commit message file')],

1907

'hg rawcommit [OPTION]... [FILE]...'),

1896

'hg rawcommit [OPTION]... [FILE]...'),

1908

"recover": (recover, [], "hg recover"),

1897

"recover": (recover, [], "hg recover"),

1909

"^remove|rm": (remove,

1898

"^remove|rm": (remove,

1910

[('I', 'include', [], 'include path in search'),

1899

[('I', 'include', [], 'include path in search'),

1911

('X', 'exclude', [], 'exclude path from search')],

1900

('X', 'exclude', [], 'exclude path from search')],

1912

"hg remove [OPTION]... FILE..."),

1901

"hg remove [OPTION]... FILE..."),

1913

"rename|mv": (rename,

1902

"rename|mv": (rename,

1914

[('I', 'include', [], 'include path in search'),

1903

[('I', 'include', [], 'include path in search'),

1915

('X', 'exclude', [], 'exclude path from search'),

1904

('X', 'exclude', [], 'exclude path from search'),

1916

('A', 'after', None, 'record a copy after it has happened'),

1905

('A', 'after', None, 'record a copy after it has happened'),

1917

('f', 'force', None, 'replace destination if it exists'),

1906

('f', 'force', None, 'replace destination if it exists'),

1918

('p', 'parents', None, 'append source path to dest')],

1907

('p', 'parents', None, 'append source path to dest')],

1919

'hg rename [OPTION]... [SOURCE]... DEST'),

1908

'hg rename [OPTION]... [SOURCE]... DEST'),

1920

"^revert":

1909

"^revert":

1921

(revert,

1910

(revert,

1922

[("n", "nonrecursive", None, "don't recurse into subdirs"),

1911

[("n", "nonrecursive", None, "don't recurse into subdirs"),

1923

("r", "rev", "", "revision")],

1912

("r", "rev", "", "revision")],

1924

"hg revert [-n] [-r REV] [NAME]..."),

1913

"hg revert [-n] [-r REV] [NAME]..."),

1925

"root": (root, [], "hg root"),

1914

"root": (root, [], "hg root"),

1926

"^serve":

1915

"^serve":

1927

(serve,

1916

(serve,

1928

[('A', 'accesslog', '', 'access log file'),

1917

[('A', 'accesslog', '', 'access log file'),

1929

('E', 'errorlog', '', 'error log file'),

1918

('E', 'errorlog', '', 'error log file'),

1930

('p', 'port', 0, 'listen port'),

1919

('p', 'port', 0, 'listen port'),

1931

('a', 'address', '', 'interface address'),

1920

('a', 'address', '', 'interface address'),

1932

('n', 'name', "", 'repository name'),

1921

('n', 'name', "", 'repository name'),

1933

('', 'stdio', None, 'for remote clients'),

1922

('', 'stdio', None, 'for remote clients'),

1934

('t', 'templates', "", 'template directory'),

1923

('t', 'templates', "", 'template directory'),

1935

('', 'style', "", 'template style'),

1924

('', 'style', "", 'template style'),

1936

('6', 'ipv6', None, 'use IPv6 in addition to IPv4')],

1925

('6', 'ipv6', None, 'use IPv6 in addition to IPv4')],

1937

"hg serve [OPTION]..."),

1926

"hg serve [OPTION]..."),

1938

"^status":

1927

"^status":

1939

(status,

1928

(status,

1940

[('m', 'modified', None, 'show only modified files'),

1929

[('m', 'modified', None, 'show only modified files'),

1941

('a', 'added', None, 'show only added files'),

1930

('a', 'added', None, 'show only added files'),

1942

('r', 'removed', None, 'show only removed files'),

1931

('r', 'removed', None, 'show only removed files'),

1943

('u', 'unknown', None, 'show only unknown (not tracked) files'),

1932

('u', 'unknown', None, 'show only unknown (not tracked) files'),

1944

('n', 'no-status', None, 'hide status prefix'),

1933

('n', 'no-status', None, 'hide status prefix'),

1945

('0', 'print0', None, 'end filenames with NUL'),

1934

('0', 'print0', None, 'end filenames with NUL'),

1946

('I', 'include', [], 'include path in search'),

1935

('I', 'include', [], 'include path in search'),

1947

('X', 'exclude', [], 'exclude path from search')],

1936

('X', 'exclude', [], 'exclude path from search')],

1948

"hg status [OPTION]... [FILE]..."),

1937

"hg status [OPTION]... [FILE]..."),

1949

"tag":

1938

"tag":

1950

(tag,

1939

(tag,

1951

[('l', 'local', None, 'make the tag local'),

1940

[('l', 'local', None, 'make the tag local'),

1952

('m', 'message', "", 'commit message'),

1941

('m', 'message', "", 'commit message'),

1953

('t', 'text', "", 'commit message (deprecated: use -m)'),

1942

('t', 'text', "", 'commit message (deprecated: use -m)'),

1954

('d', 'date', "", 'date code'),

1943

('d', 'date', "", 'date code'),

1955

('u', 'user', "", 'user')],

1944

('u', 'user', "", 'user')],

1956

'hg tag [OPTION]... NAME [REV]'),

1945

'hg tag [OPTION]... NAME [REV]'),

1957

"tags": (tags, [], 'hg tags'),

1946

"tags": (tags, [], 'hg tags'),

1958

"tip": (tip, [], 'hg tip'),

1947

"tip": (tip, [], 'hg tip'),

1959

"unbundle":

1948

"unbundle":

1960

(unbundle,

1949

(unbundle,

1961

[],

1950

[],

1962

'hg unbundle FILE'),

1951

'hg unbundle FILE'),

1963

"undo": (undo, [], 'hg undo'),

1952

"undo": (undo, [], 'hg undo'),

1964

"^update|up|checkout|co":

1953

"^update|up|checkout|co":

1965

(update,

1954

(update,

1966

[('b', 'branch', "", 'checkout the head of a specific branch'),

1955

[('b', 'branch', "", 'checkout the head of a specific branch'),

1967

('m', 'merge', None, 'allow merging of conflicts'),

1956

('m', 'merge', None, 'allow merging of conflicts'),

1968

('C', 'clean', None, 'overwrite locally modified files')],

1957

('C', 'clean', None, 'overwrite locally modified files')],

1969

'hg update [-b TAG] [-m] [-C] [REV]'),

1958

'hg update [-b TAG] [-m] [-C] [REV]'),

1970

"verify": (verify, [], 'hg verify'),

1959

"verify": (verify, [], 'hg verify'),

1971

"version": (show_version, [], 'hg version'),

1960

"version": (show_version, [], 'hg version'),

1972

}

1961

}

1973

1962

1974

globalopts = [

1963

globalopts = [

1975

('R', 'repository', "", 'repository root directory'),

1964

('R', 'repository', "", 'repository root directory'),

1976

('', 'cwd', '', 'change working directory'),

1965

('', 'cwd', '', 'change working directory'),

1977

('y', 'noninteractive', None, 'run non-interactively'),

1966

('y', 'noninteractive', None, 'run non-interactively'),

1978

('q', 'quiet', None, 'quiet mode'),

1967

('q', 'quiet', None, 'quiet mode'),

1979

('v', 'verbose', None, 'verbose mode'),

1968

('v', 'verbose', None, 'verbose mode'),

1980

('', 'debug', None, 'debug mode'),

1969

('', 'debug', None, 'debug mode'),

1981

('', 'debugger', None, 'start debugger'),

1970

('', 'debugger', None, 'start debugger'),

1982

('', 'traceback', None, 'print traceback on exception'),

1971

('', 'traceback', None, 'print traceback on exception'),

1983

('', 'time', None, 'time how long the command takes'),

1972

('', 'time', None, 'time how long the command takes'),

1984

('', 'profile', None, 'profile'),

1973

('', 'profile', None, 'profile'),

1985

('', 'version', None, 'output version information and exit'),

1974

('', 'version', None, 'output version information and exit'),

1986

('h', 'help', None, 'display help and exit'),

1975

('h', 'help', None, 'display help and exit'),

1987

]

1976

]

1988

1977

1989

norepo = ("clone init version help debugancestor debugconfig debugdata"

1978

norepo = ("clone init version help debugancestor debugconfig debugdata"

1990

" debugindex debugindexdot paths")

1979

" debugindex debugindexdot paths")

1991

1980

1992

def find(cmd):

1981

def find(cmd):

1993

for e in table.keys():

1982

for e in table.keys():

1994

if re.match("(%s)$" % e, cmd):

1983

if re.match("(%s)$" % e, cmd):

1995

return e, table[e]

1984

return e, table[e]

1996

1985

1997

raise UnknownCommand(cmd)

1986

raise UnknownCommand(cmd)

1998

1987

1999

class SignalInterrupt(Exception):

1988

class SignalInterrupt(Exception):

2000

"""Exception raised on SIGTERM and SIGHUP."""

1989

"""Exception raised on SIGTERM and SIGHUP."""

2001

1990

2002

def catchterm(*args):

1991

def catchterm(*args):

2003

raise SignalInterrupt

1992

raise SignalInterrupt

2004

1993

2005

def run():

1994

def run():

2006

sys.exit(dispatch(sys.argv[1:]))

1995

sys.exit(dispatch(sys.argv[1:]))

2007

1996

2008

class ParseError(Exception):

1997

class ParseError(Exception):

2009

"""Exception raised on errors in parsing the command line."""

1998

"""Exception raised on errors in parsing the command line."""

2010

1999

2011

def parse(args):

2000

def parse(args):

2012

options = {}

2001

options = {}

2013

cmdoptions = {}

2002

cmdoptions = {}

2014

2003

2015

try:

2004

try:

2016

args = fancyopts.fancyopts(args, globalopts, options)

2005

args = fancyopts.fancyopts(args, globalopts, options)

2017

except fancyopts.getopt.GetoptError, inst:

2006

except fancyopts.getopt.GetoptError, inst:

2018

raise ParseError(None, inst)

2007

raise ParseError(None, inst)

2019

2008

2020

if args:

2009

if args:

2021

cmd, args = args[0], args[1:]

2010

cmd, args = args[0], args[1:]

2022

i = find(cmd)[1]

2011

i = find(cmd)[1]

2023

c = list(i[1])

2012

c = list(i[1])

2024

else:

2013

else:

2025

cmd = None

2014

cmd = None

2026

c = []

2015

c = []

2027

2016

2028

# combine global options into local

2017

# combine global options into local

2029

for o in globalopts:

2018

for o in globalopts:

2030

c.append((o[0], o[1], options[o[1]], o[3]))

2019

c.append((o[0], o[1], options[o[1]], o[3]))

2031

2020

2032

try:

2021

try:

2033

args = fancyopts.fancyopts(args, c, cmdoptions)

2022

args = fancyopts.fancyopts(args, c, cmdoptions)

2034

except fancyopts.getopt.GetoptError, inst:

2023

except fancyopts.getopt.GetoptError, inst:

2035

raise ParseError(cmd, inst)

2024

raise ParseError(cmd, inst)

2036

2025

2037

# separate global options back out

2026

# separate global options back out

2038

for o in globalopts:

2027

for o in globalopts:

2039

n = o[1]

2028

n = o[1]

2040

options[n] = cmdoptions[n]

2029

options[n] = cmdoptions[n]

2041

del cmdoptions[n]

2030

del cmdoptions[n]

2042

2031

2043

return (cmd, cmd and i[0] or None, args, options, cmdoptions)

2032

return (cmd, cmd and i[0] or None, args, options, cmdoptions)

2044

2033

2045

def dispatch(args):

2034

def dispatch(args):

2046

signal.signal(signal.SIGTERM, catchterm)

2035

signal.signal(signal.SIGTERM, catchterm)

2047

try:

2036

try:

2048

signal.signal(signal.SIGHUP, catchterm)

2037

signal.signal(signal.SIGHUP, catchterm)

2049

except AttributeError:

2038

except AttributeError:

2050

pass

2039

pass

2051

2040

2052

u = ui.ui()

2041

u = ui.ui()

2053

external = []

2042

external = []

2054

for x in u.extensions():

2043

for x in u.extensions():

2055

if x[1]:

2044

if x[1]:

2056

mod = imp.load_source(x[0], x[1])

2045

mod = imp.load_source(x[0], x[1])

2057

else:

2046

else:

2058

def importh(name):

2047

def importh(name):

2059

mod = __import__(name)

2048

mod = __import__(name)

2060

components = name.split('.')

2049

components = name.split('.')

2061

for comp in components[1:]:

2050

for comp in components[1:]:

2062

mod = getattr(mod, comp)

2051

mod = getattr(mod, comp)

2063

return mod

2052

return mod

2064

mod = importh(x[0])

2053

mod = importh(x[0])

2065

external.append(mod)

2054

external.append(mod)

2066

for x in external:

2055

for x in external:

2067

for t in x.cmdtable:

2056

for t in x.cmdtable:

2068

if t in table:

2057

if t in table:

2069

u.warn("module %s override %s\n" % (x.__name__, t))

2058

u.warn("module %s override %s\n" % (x.__name__, t))

2070

table.update(x.cmdtable)

2059

table.update(x.cmdtable)

2071

2060

2072

try:

2061

try:

2073

cmd, func, args, options, cmdoptions = parse(args)

2062

cmd, func, args, options, cmdoptions = parse(args)

2074

except ParseError, inst:

2063

except ParseError, inst:

2075

if inst.args[0]:

2064

if inst.args[0]:

2076

u.warn("hg %s: %s\n" % (inst.args[0], inst.args[1]))

2065

u.warn("hg %s: %s\n" % (inst.args[0], inst.args[1]))

2077

help_(u, inst.args[0])

2066

help_(u, inst.args[0])

2078

else:

2067

else:

2079

u.warn("hg: %s\n" % inst.args[1])

2068

u.warn("hg: %s\n" % inst.args[1])

2080

help_(u, 'shortlist')

2069

help_(u, 'shortlist')

2081

sys.exit(-1)

2070

sys.exit(-1)

2082

except UnknownCommand, inst:

2071

except UnknownCommand, inst:

2083

u.warn("hg: unknown command '%s'\n" % inst.args[0])

2072

u.warn("hg: unknown command '%s'\n" % inst.args[0])

2084

help_(u, 'shortlist')

2073

help_(u, 'shortlist')

2085

sys.exit(1)

2074

sys.exit(1)

2086

2075

2087

if options["time"]:

2076

if options["time"]:

2088

def get_times():

2077

def get_times():

2089

t = os.times()

2078

t = os.times()

2090

if t[4] == 0.0: # Windows leaves this as zero, so use time.clock()

2079

if t[4] == 0.0: # Windows leaves this as zero, so use time.clock()

2091

t = (t[0], t[1], t[2], t[3], time.clock())

2080

t = (t[0], t[1], t[2], t[3], time.clock())

2092

return t

2081

return t

2093

s = get_times()

2082

s = get_times()

2094

def print_time():

2083

def print_time():

2095

t = get_times()

2084

t = get_times()

2096

u.warn("Time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n" %

2085

u.warn("Time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n" %

2097

(t[4]-s[4], t[0]-s[0], t[2]-s[2], t[1]-s[1], t[3]-s[3]))

2086

(t[4]-s[4], t[0]-s[0], t[2]-s[2], t[1]-s[1], t[3]-s[3]))

2098

atexit.register(print_time)

2087

atexit.register(print_time)

2099

2088

2100

u.updateopts(options["verbose"], options["debug"], options["quiet"],

2089

u.updateopts(options["verbose"], options["debug"], options["quiet"],

2101

not options["noninteractive"])

2090

not options["noninteractive"])

2102

2091

2103

# enter the debugger before command execution

2092

# enter the debugger before command execution

2104

if options['debugger']:

2093

if options['debugger']:

2105

pdb.set_trace()

2094

pdb.set_trace()

2106

2095

2107

try:

2096

try:

2108

try:

2097

try:

2109

if options['help']:

2098

if options['help']:

2110

help_(u, cmd, options['version'])

2099

help_(u, cmd, options['version'])

2111

sys.exit(0)

2100

sys.exit(0)

2112

elif options['version']:

2101

elif options['version']:

2113

show_version(u)

2102

show_version(u)

2114

sys.exit(0)

2103

sys.exit(0)

2115

elif not cmd:

2104

elif not cmd:

2116

help_(u, 'shortlist')

2105

help_(u, 'shortlist')

2117

sys.exit(0)

2106

sys.exit(0)

2118

2107

2119

if options['cwd']:

2108

if options['cwd']:

2120

try:

2109

try:

2121

os.chdir(options['cwd'])

2110

os.chdir(options['cwd'])

2122

except OSError, inst:

2111

except OSError, inst:

2123

raise util.Abort('%s: %s' %

2112

raise util.Abort('%s: %s' %

2124

(options['cwd'], inst.strerror))

2113

(options['cwd'], inst.strerror))

2125

2114

2126

if cmd not in norepo.split():

2115

if cmd not in norepo.split():

2127

path = options["repository"] or ""

2116

path = options["repository"] or ""

2128

repo = hg.repository(ui=u, path=path)

2117

repo = hg.repository(ui=u, path=path)

2129

for x in external:

2118

for x in external:

2130

x.reposetup(u, repo)

2119

x.reposetup(u, repo)

2131

d = lambda: func(u, repo, *args, **cmdoptions)

2120

d = lambda: func(u, repo, *args, **cmdoptions)

2132

else:

2121

else:

2133

d = lambda: func(u, *args, **cmdoptions)

2122

d = lambda: func(u, *args, **cmdoptions)

2134

2123

2135

if options['profile']:

2124

if options['profile']:

2136

import hotshot, hotshot.stats

2125

import hotshot, hotshot.stats

2137

prof = hotshot.Profile("hg.prof")

2126

prof = hotshot.Profile("hg.prof")

2138

r = prof.runcall(d)

2127

r = prof.runcall(d)

2139

prof.close()

2128

prof.close()

2140

stats = hotshot.stats.load("hg.prof")

2129

stats = hotshot.stats.load("hg.prof")

2141

stats.strip_dirs()

2130

stats.strip_dirs()

2142

stats.sort_stats('time', 'calls')

2131

stats.sort_stats('time', 'calls')

2143

stats.print_stats(40)

2132

stats.print_stats(40)

2144

return r

2133

return r

2145

else:

2134

else:

2146

return d()

2135

return d()

2147

except:

2136

except:

2148

# enter the debugger when we hit an exception

2137

# enter the debugger when we hit an exception

2149

if options['debugger']:

2138

if options['debugger']:

2150

pdb.post_mortem(sys.exc_info()[2])

2139

pdb.post_mortem(sys.exc_info()[2])

2151

if options['traceback']:

2140

if options['traceback']:

2152

traceback.print_exc()

2141

traceback.print_exc()

2153

raise

2142

raise

2154

except hg.RepoError, inst:

2143

except hg.RepoError, inst:

2155

u.warn("abort: ", inst, "!\n")

2144

u.warn("abort: ", inst, "!\n")

2156

except revlog.RevlogError, inst:

2145

except revlog.RevlogError, inst:

2157

u.warn("abort: ", inst, "!\n")

2146

u.warn("abort: ", inst, "!\n")

2158

except SignalInterrupt:

2147

except SignalInterrupt:

2159

u.warn("killed!\n")

2148

u.warn("killed!\n")

2160

except KeyboardInterrupt:

2149

except KeyboardInterrupt:

2161

try:

2150

try:

2162

u.warn("interrupted!\n")

2151

u.warn("interrupted!\n")

2163

except IOError, inst:

2152

except IOError, inst:

2164

if inst.errno == errno.EPIPE:

2153

if inst.errno == errno.EPIPE:

2165

if u.debugflag:

2154

if u.debugflag:

2166

u.warn("\nbroken pipe\n")

2155

u.warn("\nbroken pipe\n")

2167

else:

2156

else:

2168

raise

2157

raise

2169

except IOError, inst:

2158

except IOError, inst:

2170

if hasattr(inst, "code"):

2159

if hasattr(inst, "code"):

2171

u.warn("abort: %s\n" % inst)

2160

u.warn("abort: %s\n" % inst)

2172

elif hasattr(inst, "reason"):

2161

elif hasattr(inst, "reason"):

2173

u.warn("abort: error: %s\n" % inst.reason[1])

2162

u.warn("abort: error: %s\n" % inst.reason[1])

2174

elif hasattr(inst, "args") and inst[0] == errno.EPIPE:

2163

elif hasattr(inst, "args") and inst[0] == errno.EPIPE:

2175

if u.debugflag:

2164

if u.debugflag:

2176

u.warn("broken pipe\n")

2165

u.warn("broken pipe\n")

2177

else:

2166

else:

2178

raise

2167

raise

2179

except OSError, inst:

2168

except OSError, inst:

2180

if hasattr(inst, "filename"):

2169

if hasattr(inst, "filename"):

2181

u.warn("abort: %s: %s\n" % (inst.strerror, inst.filename))

2170

u.warn("abort: %s: %s\n" % (inst.strerror, inst.filename))

2182

else:

2171

else:

2183

u.warn("abort: %s\n" % inst.strerror)

2172

u.warn("abort: %s\n" % inst.strerror)

2184

except util.Abort, inst:

2173

except util.Abort, inst:

2185

u.warn('abort: ', inst.args[0] % inst.args[1:], '\n')

2174

u.warn('abort: ', inst.args[0] % inst.args[1:], '\n')

2186

sys.exit(1)

2175

sys.exit(1)

2187

except TypeError, inst:

2176

except TypeError, inst:

2188

# was this an argument error?

2177

# was this an argument error?

2189

tb = traceback.extract_tb(sys.exc_info()[2])

2178

tb = traceback.extract_tb(sys.exc_info()[2])

2190

if len(tb) > 2: # no

2179

if len(tb) > 2: # no

2191

raise

2180

raise

2192

u.debug(inst, "\n")

2181

u.debug(inst, "\n")

2193

u.warn("%s: invalid arguments\n" % cmd)

2182

u.warn("%s: invalid arguments\n" % cmd)

2194

help_(u, cmd)

2183

help_(u, cmd)

2195

except UnknownCommand, inst:

2184

except UnknownCommand, inst:

2196

u.warn("hg: unknown command '%s'\n" % inst.args[0])

2185

u.warn("hg: unknown command '%s'\n" % inst.args[0])

2197

help_(u, 'shortlist')

2186

help_(u, 'shortlist')

2198

except SystemExit:

2187

except SystemExit:

2199

# don't catch this in the catch-all below

2188

# don't catch this in the catch-all below

2200

raise

2189

raise

2201

except:

2190

except:

2202

u.warn("** unknown exception encountered, details follow\n")

2191

u.warn("** unknown exception encountered, details follow\n")

2203

u.warn("** report bug details to mercurial@selenic.com\n")

2192

u.warn("** report bug details to mercurial@selenic.com\n")

2204

raise

2193

raise

2205

2194

2206

sys.exit(-1)

2195

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
             from node import *
             demandload(globals(), "os re sys signal shutil imp urllib pdb")
             demandload(globals(), "fancyopts ui hg util lock revlog")
             demandload(globals(), "fnmatch hgweb mdiff random signal time traceback")
             demandload(globals(), "errno socket version struct atexit sets bz2")
             class UnknownCommand(Exception):
                 """Exception raised if command is not in the command table."""
             def filterfiles(filters, files):
                 l = [x for x in files if x in filters]
                 for t in filters:
                     if t and t[-1] != "/":
                         t += "/"
                     l += [x for x in files if x.startswith(t)]
                 return l
             def relpath(repo, args):
                 cwd = repo.getcwd()
                 if cwd:
                     return [util.normpath(os.path.join(cwd, x)) for x in args]
                 return args
             def matchpats(repo, cwd, pats=[], opts={}, head=''):
                 return util.matcher(repo.root, cwd, pats or ['.'], opts.get('include'),
                                     opts.get('exclude'), head)
             def makewalk(repo, pats, opts, head=''):
                 cwd = repo.getcwd()
                 files, matchfn, anypats = matchpats(repo, cwd, pats, opts, head)
                 exact = dict(zip(files, files))
                 def walk():
                     for src, fn in repo.walk(files=files, match=matchfn):
                         yield src, fn, util.pathto(cwd, fn), fn in exact
                 return files, matchfn, walk()
             def walk(repo, pats, opts, head=''):
                 files, matchfn, results = makewalk(repo, pats, opts, head)
                 for r in results:
                     yield r
             def walkchangerevs(ui, repo, cwd, pats, opts):
                 '''Iterate over files and the revs they changed in.
                 Callers most commonly need to iterate backwards over the history
                 it is interested in.  Doing so has awful (quadratic-looking)
                 performance, so we use iterators in a "windowed" way.
                 We walk a window of revisions in the desired order.  Within the
                 window, we first walk forwards to gather data, then in the desired
                 order (usually backwards) to display it.
                 This function returns an (iterator, getchange) pair.  The
                 getchange function returns the changelog entry for a numeric
                 revision.  The iterator yields 3-tuples.  They will be of one of
                 the following forms:
                 "window", incrementing, lastrev: stepping through a window,
                 positive if walking forwards through revs, last rev in the
                 sequence iterated over - use to reset state for the current window
                 "add", rev, fns: out-of-order traversal of the given file names
                 fns, which changed during revision rev - use to gather data for
                 possible display
                 "iter", rev, None: in-order traversal of the revs earlier iterated
                 over with "add" - use to display data'''
                 cwd = repo.getcwd()
                 if not pats and cwd:
                     opts['include'] = [os.path.join(cwd, i) for i in opts['include']]
                     opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]
                 files, matchfn, anypats = matchpats(repo, (pats and cwd) or '',
                                                     pats, opts)
                 revs = map(int, revrange(ui, repo, opts['rev'] or ['tip:0']))
                 wanted = {}
                 slowpath = anypats
                 window = 300
                 fncache = {}
                 chcache = {}
                 def getchange(rev):
                     ch = chcache.get(rev)
                     if ch is None:
                         chcache[rev] = ch = repo.changelog.read(repo.lookup(str(rev)))
                     return ch
                 if not slowpath and not files:
                     # No files, no patterns.  Display all revs.
                     wanted = dict(zip(revs, revs))
                 if not slowpath:
                     # Only files, no patterns.  Check the history of each file.
                     def filerevgen(filelog):
                         for i in xrange(filelog.count() - 1, -1, -window):
                             revs = []
                             for j in xrange(max(0, i - window), i + 1):
                                 revs.append(filelog.linkrev(filelog.node(j)))
                             revs.reverse()
                             for rev in revs:
                                 yield rev
                     minrev, maxrev = min(revs), max(revs)
                     for file in files:
                         filelog = repo.file(file)
                         # A zero count may be a directory or deleted file, so
                         # try to find matching entries on the slow path.
                         if filelog.count() == 0:
                             slowpath = True
                             break
                         for rev in filerevgen(filelog):
                             if rev <= maxrev:
                                 if rev < minrev:
                                     break
                                 fncache.setdefault(rev, [])
                                 fncache[rev].append(file)
                                 wanted[rev] = 1
                 if slowpath:
                     # The slow path checks files modified in every changeset.
                     def changerevgen():
                         for i in xrange(repo.changelog.count() - 1, -1, -window):
                             for j in xrange(max(0, i - window), i + 1):
                                 yield j, getchange(j)[3]
                     for rev, changefiles in changerevgen():
                         matches = filter(matchfn, changefiles)
                         if matches:
                             fncache[rev] = matches
                             wanted[rev] = 1
                 def iterate():
                     for i in xrange(0, len(revs), window):
                         yield 'window', revs[0] < revs[-1], revs[-1]
                         nrevs = [rev for rev in revs[i:min(i+window, len(revs))]
                                  if rev in wanted]
                         srevs = list(nrevs)
                         srevs.sort()
                         for rev in srevs:
                             fns = fncache.get(rev) or filter(matchfn, getchange(rev)[3])
                             yield 'add', rev, fns
                         for rev in nrevs:
                             yield 'iter', rev, None
                 return iterate(), getchange
             revrangesep = ':'
             def revrange(ui, repo, revs, revlog=None):
                 """Yield revision as strings from a list of revision specifications."""
                 if revlog is None:
                     revlog = repo.changelog
                 revcount = revlog.count()
                 def fix(val, defval):
                     if not val:
                         return defval
                     try:
                         num = int(val)
                         if str(num) != val:
                             raise ValueError
                         if num < 0: num += revcount
                         if num < 0: num = 0
                         elif num >= revcount:
                             raise ValueError
                     except ValueError:
                         try:
                             num = repo.changelog.rev(repo.lookup(val))
                         except KeyError:
                             try:
                                 num = revlog.rev(revlog.lookup(val))
                             except KeyError:
                                 raise util.Abort('invalid revision identifier %s', val)
                     return num
                 seen = {}
                 for spec in revs:
                     if spec.find(revrangesep) >= 0:
                         start, end = spec.split(revrangesep, 1)
                         start = fix(start, 0)
                         end = fix(end, revcount - 1)
                         step = start > end and -1 or 1
                         for rev in xrange(start, end+step, step):
                             if rev in seen: continue
                             seen[rev] = 1
                             yield str(rev)
                     else:
                         rev = fix(spec, None)
                         if rev in seen: continue
                         seen[rev] = 1
                         yield str(rev)
             def make_filename(repo, r, pat, node=None,
                               total=None, seqno=None, revwidth=None, pathname=None):
                 node_expander = {
                     'H': lambda: hex(node),
                     'R': lambda: str(r.rev(node)),
                     'h': lambda: short(node),
                     }
                 expander = {
                     '%': lambda: '%',
                     'b': lambda: os.path.basename(repo.root),
                     }
                 try:
                     if node:
                         expander.update(node_expander)
                     if node and revwidth is not None:
                         expander['r'] = lambda: str(r.rev(node)).zfill(revwidth)
                     if total is not None:
                         expander['N'] = lambda: str(total)
                     if seqno is not None:
                         expander['n'] = lambda: str(seqno)
                     if total is not None and seqno is not None:
                         expander['n'] = lambda:str(seqno).zfill(len(str(total)))
                     if pathname is not None:
                         expander['s'] = lambda: os.path.basename(pathname)
                         expander['d'] = lambda: os.path.dirname(pathname) or '.'
                         expander['p'] = lambda: pathname
                     newname = []
                     patlen = len(pat)
                     i = 0
                     while i < patlen:
                         c = pat[i]
                         if c == '%':
                             i += 1
                             c = pat[i]
                             c = expander[c]()
                         newname.append(c)
                         i += 1
                     return ''.join(newname)
                 except KeyError, inst:
                     raise util.Abort("invalid format spec '%%%s' in output file name",
                                 inst.args[0])
             def make_file(repo, r, pat, node=None,
                           total=None, seqno=None, revwidth=None, mode='wb', pathname=None):
                 if not pat or pat == '-':
                     return 'w' in mode and sys.stdout or sys.stdin
                 if hasattr(pat, 'write') and 'w' in mode:
                     return pat
                 if hasattr(pat, 'read') and 'r' in mode:
                     return pat
                 return open(make_filename(repo, r, pat, node, total, seqno, revwidth,
                                           pathname),
                             mode)
             def dodiff(fp, ui, repo, node1, node2, files=None, match=util.always,
                        changes=None, text=False):
                 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 hex or short
                     r = [hexfunc(node) for node in [node1, node2] if node]
                 change = repo.changelog.read(node1)
                 mmap = repo.manifest.read(change[0])
                 date1 = 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 trimuser(ui, name, rev, revcache):
                 """trim the name of the user who committed a change"""
                 user = revcache.get(rev)
                 if user is None:
                     user = revcache[rev] = ui.shortuser(name)
                 return user
             def show_changeset(ui, repo, rev=0, changenode=None, brinfo=None):
                 """show a single changeset or file revision"""
                 log = repo.changelog
                 if changenode is None:
                     changenode = log.node(rev)
                 elif not rev:
                     rev = log.rev(changenode)
                 if ui.quiet:
                     ui.write("%d:%s\n" % (rev, short(changenode)))
                     return
                 changes = log.read(changenode)
                 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 hex(p) or short(p))
                            for p in log.parents(changenode)
                            if ui.debugflag or p != nullid]
                 if not ui.debugflag and len(parents) == 1 and parents[0][0] == rev-1:
                     parents = []
                 if ui.verbose:
                     ui.write("changeset:   %d:%s\n" % (rev, hex(changenode)))
                 else:
                     ui.write("changeset:   %d:%s\n" % (rev, short(changenode)))
                 for tag in repo.nodetags(changenode):
                     ui.status("tag:         %s\n" % tag)
                 for parent in parents:
                     ui.write("parent:      %d:%s\n" % parent)
                 if brinfo and changenode in brinfo:
                     br = brinfo[changenode]
                     ui.write("branch:      %s\n" % " ".join(br))
                 ui.debug("manifest:    %d:%s\n" % (repo.manifest.rev(changes[0]),
                                                   hex(changes[0])))
                 ui.status("user:        %s\n" % changes[1])
                 ui.status("date:        %s\n" % date)
                 if ui.debugflag:
                     files = repo.changes(log.parents(changenode)[0], changenode)
                     for key, value in zip(["files:", "files+:", "files-:"], files):
                         if value:
                             ui.note("%-12s %s\n" % (key, " ".join(value)))
                 else:
                     ui.note("files:       %s\n" % " ".join(changes[3]))
                 description = changes[4].strip()
                 if description:
                     if ui.verbose:
                         ui.status("description:\n")
                         ui.status(description)
                         ui.status("\n\n")
                     else:
                         ui.status("summary:     %s\n" % description.splitlines()[0])
                 ui.status("\n")
             def show_version(ui):
                 """output version and copyright information"""
                 ui.write("Mercurial Distributed SCM (version %s)\n"
                          % version.get_version())
                 ui.status(
                     "\nCopyright (C) 2005 Matt Mackall <mpm@selenic.com>\n"
                     "This is free software; see the source for copying conditions. "
                     "There is NO\nwarranty; "
                     "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
                 )
             def help_(ui, cmd=None, with_version=False):
                 """show help for a given command or all commands"""
                 option_lists = []
                 if cmd and cmd != 'shortlist':
                     if with_version:
                         show_version(ui)
                         ui.write('\n')
                     key, i = find(cmd)
                     # synopsis
                     ui.write("%s\n\n" % i[2])
                     # description
                     doc = i[0].__doc__
                     if ui.quiet:
                         doc = doc.splitlines(0)[0]
                     ui.write("%s\n" % doc.rstrip())
                     if not ui.quiet:
                         # aliases
                         aliases = ', '.join(key.split('|')[1:])
                         if aliases:
                             ui.write("\naliases: %s\n" % aliases)
                         # options
                         if i[1]:
                             option_lists.append(("options", i[1]))
                 else:
                     # program name
                     if ui.verbose or with_version:
                         show_version(ui)
                     else:
                         ui.status("Mercurial Distributed SCM\n")
                     ui.status('\n')
                     # list of commands
                     if cmd == "shortlist":
                         ui.status('basic commands (use "hg help" '
                                   'for the full list or option "-v" for details):\n\n')
                     elif ui.verbose:
                         ui.status('list of commands:\n\n')
                     else:
                         ui.status('list of commands (use "hg help -v" '
                                   'to show aliases and global options):\n\n')
                     h = {}
                     cmds = {}
                     for c, e in table.items():
                         f = c.split("|")[0]
                         if cmd == "shortlist" and not f.startswith("^"):
                             continue
                         f = f.lstrip("^")
                         if not ui.debugflag and f.startswith("debug"):
                             continue
                         d = ""
                         if e[0].__doc__:
                             d = e[0].__doc__.splitlines(0)[0].rstrip()
                         h[f] = d
                         cmds[f]=c.lstrip("^")
                     fns = h.keys()
                     fns.sort()
                     m = max(map(len, fns))
                     for f in fns:
                         if ui.verbose:
                             commands = cmds[f].replace("|",", ")
                             ui.write(" %s:\n      %s\n"%(commands,h[f]))
                         else:
                             ui.write(' %-*s   %s\n' % (m, f, h[f]))
                 # global options
                 if ui.verbose:
                     option_lists.append(("global options", globalopts))
                 # list all option lists
                 opt_output = []
                 for title, options in option_lists:
                     opt_output.append(("\n%s:\n" % title, None))
                     for shortopt, longopt, default, desc in options:
                         opt_output.append(("%2s%s" % (shortopt and "-%s" % shortopt,
                                                       longopt and " --%s" % longopt),
                                            "%s%s" % (desc,
                                                      default and " (default: %s)" % default
                                                      or "")))
                 if opt_output:
                     opts_len = max([len(line[0]) for line in opt_output if line[1]])
                     for first, second in opt_output:
                         if second:
                             ui.write(" %-*s  %s\n" % (opts_len, first, second))
                         else:
                             ui.write("%s\n" % first)
             # Commands start here, listed alphabetically
             def add(ui, repo, *pats, **opts):
                 '''add the specified files on the next commit'''
                 names = []
                 for src, abs, rel, exact in walk(repo, pats, opts):
                     if exact:
                         if ui.verbose: ui.status('adding %s\n' % rel)
                         names.append(abs)
                     elif repo.dirstate.state(abs) == '?':
                         ui.status('adding %s\n' % rel)
                         names.append(abs)
                 repo.add(names)
             def addremove(ui, repo, *pats, **opts):
                 """add all new files, delete all missing files"""
                 add, remove = [], []
                 for src, abs, rel, exact in walk(repo, pats, opts):
                     if src == 'f' and repo.dirstate.state(abs) == '?':
                         add.append(abs)
                         if ui.verbose or not exact:
                             ui.status('adding ', rel, '\n')
                     if repo.dirstate.state(abs) != 'r' and not os.path.exists(rel):
                         remove.append(abs)
                         if ui.verbose or 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 short(repo.changelog.node(rev))
                 ucache = {}
                 def getname(rev):
                     cl = repo.changelog.read(repo.changelog.node(rev))
                     return trimuser(ui, cl[1], rev, ucache)
                 if not pats:
                     raise util.Abort('at least one file name or pattern required')
                 opmap = [['user', getname], ['number', str], ['changeset', getnode]]
                 if not opts['user'] and not opts['changeset']:
                     opts['number'] = 1
                 if opts['rev']:
                     node = repo.changelog.lookup(opts['rev'])
                 else:
                     node = repo.dirstate.parents()[0]
                 change = repo.changelog.read(node)
                 mmap = repo.manifest.read(change[0])
                 for src, abs, rel, exact in walk(repo, pats, opts):
                     if abs not in mmap:
                         ui.warn("warning: %s is not in the repository!\n" % rel)
                         continue
                     f = repo.file(abs)
                     if not opts['text'] and util.binary(f.read(mmap[abs])):
                         ui.write("%s: binary file\n" % rel)
                         continue
                     lines = f.annotate(mmap[abs])
                     pieces = []
                     for o, f in opmap:
                         if opts[o]:
                             l = [f(n) for n, dummy in lines]
                             if l:
                                 m = max(map(len, l))
                                 pieces.append(["%*s" % (m, x) for x in l])
                     if pieces:
                         for p, l in zip(zip(*pieces), lines):
                             ui.write("%s: %s" % (" ".join(p), l[1]))
             def bundle(ui, repo, fname, dest="default-push", **opts):
                 """create a changegroup file"""
                 f = open(fname, "wb")
                 dest = ui.expandpath(dest)
                 other = hg.repository(ui, dest)
                 o = repo.findoutgoing(other)
                 cg = repo.changegroup(o)
                 try:
                     f.write("HG10")
                     z = bz2.BZ2Compressor(9)
                     while 1:
                         chunk = cg.read(4096)
                         if not chunk:
                             break
                         f.write(z.compress(chunk))
                     f.write(z.flush())
                 except:
                     os.unlink(fname)
             def cat(ui, repo, file1, *pats, **opts):
                 """output the latest or given revisions of files"""
                 mf = {}
                 if opts['rev']:
                     change = repo.changelog.read(repo.lookup(opts['rev']))
                     mf = repo.manifest.read(change[0])
                 for src, abs, rel, exact in walk(repo, (file1,) + pats, opts):
                     r = repo.file(abs)
                     if opts['rev']:
                         try:
                             n = mf[abs]
                         except (hg.RepoError, KeyError):
                             try:
                                 n = r.lookup(rev)
                             except KeyError, inst:
                                 raise util.Abort('cannot find file %s in rev %s', rel, rev)
                     else:
                         n = r.tip()
                     fp = make_file(repo, r, opts['output'], node=n, pathname=abs)
                     fp.write(r.read(n))
             def clone(ui, source, dest=None, **opts):
                 """make a copy of an existing repository"""
                 if dest is None:
                     dest = os.path.basename(os.path.normpath(source))
                 if os.path.exists(dest):
                     raise util.Abort("destination '%s' already exists", dest)
                 dest = os.path.realpath(dest)
                 class Dircleanup:
                     def __init__(self, dir_):
                         self.rmtree = shutil.rmtree
                         self.dir_ = dir_
                         os.mkdir(dir_)
                     def close(self):
                         self.dir_ = None
                     def __del__(self):
                         if self.dir_:
                             self.rmtree(self.dir_, True)
                 if opts['ssh']:
                     ui.setconfig("ui", "ssh", opts['ssh'])
                 if opts['remotecmd']:
                     ui.setconfig("ui", "remotecmd", opts['remotecmd'])
                 d = Dircleanup(dest)
                 if not os.path.exists(source):
                     source = ui.expandpath(source)
                 abspath = source
                 other = hg.repository(ui, source)
                 copy = False
                 if not opts['pull'] and other.dev() != -1:
                     abspath = os.path.abspath(source)
                     copy = True
                 if copy:
                     try:
                         # we use a lock here because if we race with commit, we
                         # can end up with extra data in the cloned revlogs that's
                         # not pointed to by changesets, thus causing verify to
                         # fail
                         l1 = lock.lock(os.path.join(source, ".hg", "lock"))
                     except OSError:
                         copy = False
                 if copy:
                     # we lock here to avoid premature writing to the target
                     os.mkdir(os.path.join(dest, ".hg"))
                     l2 = lock.lock(os.path.join(dest, ".hg", "lock"))
                     files = "data 00manifest.d 00manifest.i 00changelog.d 00changelog.i"
                     for f in files.split():
                         src = os.path.join(source, ".hg", f)
                         dst = os.path.join(dest, ".hg", f)
                         util.copyfiles(src, dst)
                     repo = hg.repository(ui, dest)
                 else:
                     repo = hg.repository(ui, dest, create=1)
                     repo.pull(other)
                 f = repo.opener("hgrc", "w")
                 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 = []
                 try:
                     repo.commit(files, message, opts['user'], opts['date'], match)
                 except ValueError, inst:
                     raise util.Abort(str(inst))
             def docopy(ui, repo, pats, opts):
                 if not pats:
                     raise util.Abort('no source or destination specified')
                 elif len(pats) == 1:
                     raise util.Abort('no destination specified')
                 pats = list(pats)
                 dest = pats.pop()
                 sources = []
                 def okaytocopy(abs, rel, exact):
                     reasons = {'?': 'is not managed',
                                'a': 'has been marked for add'}
                     reason = reasons.get(repo.dirstate.state(abs))
                     if reason:
                         if exact: ui.warn('%s: not copying - file %s\n' % (rel, reason))
                     else:
                         return True
                 for src, abs, rel, exact in walk(repo, pats, opts):
                     if okaytocopy(abs, rel, exact):
                         sources.append((abs, rel, exact))
                 if not sources:
                     raise util.Abort('no files to copy')
                 cwd = repo.getcwd()
                 absdest = util.canonpath(repo.root, cwd, dest)
                 reldest = util.pathto(cwd, absdest)
                 if os.path.exists(reldest):
                     destisfile = not os.path.isdir(reldest)
                 else:
                     destisfile = len(sources) == 1 or repo.dirstate.state(absdest) != '?'
                 if destisfile:
                     if opts['parents']:
                         raise util.Abort('with --parents, destination must be a directory')
                     elif len(sources) > 1:
                         raise util.Abort('with multiple sources, destination must be a '
                                          'directory')
                 errs, copied = 0, []
                 for abs, rel, exact in sources:
                     if opts['parents']:
                         mydest = os.path.join(dest, rel)
                     elif destisfile:
                         mydest = reldest
                     else:
                         mydest = os.path.join(dest, os.path.basename(rel))
                     myabsdest = util.canonpath(repo.root, cwd, mydest)
                     myreldest = util.pathto(cwd, myabsdest)
                     if not opts['force'] and repo.dirstate.state(myabsdest) not in 'a?':
                         ui.warn('%s: not overwriting - file already managed\n' % myreldest)
                         continue
                     mydestdir = os.path.dirname(myreldest) or '.'
                     if not opts['after']:
                         try:
                             if opts['parents']: os.makedirs(mydestdir)
                             elif not destisfile: os.mkdir(mydestdir)
                         except OSError, inst:
                             if inst.errno != errno.EEXIST: raise
                     if ui.verbose or not exact:
                         ui.status('copying %s to %s\n' % (rel, myreldest))
                     if not opts['after']:
                         try:
                             shutil.copyfile(rel, myreldest)
                             n = repo.manifest.tip()
                             mf = repo.manifest.readflags(n)
                             util.set_exec(myreldest, util.is_exec(rel, mf[abs]))
                         except shutil.Error, inst:
                             raise util.Abort(str(inst))
                         except IOError, inst:
                             if inst.errno == errno.ENOENT:
                                 ui.warn('%s: deleted in working copy\n' % rel)
                             else:
                                 ui.warn('%s: cannot copy - %s\n' % (rel, inst.strerror))
                             errs += 1
                             continue
                     repo.copy(abs, myabsdest)
                     copied.append((abs, rel, exact))
                 if errs:
                     ui.warn('(consider using --after)\n')
                 return errs, copied
             def copy(ui, repo, *pats, **opts):
                 """mark files as copied for the next commit"""
                 errs, copied = docopy(ui, repo, pats, opts)
                 return errs
             def debugancestor(ui, index, rev1, rev2):
                 """find the ancestor revision of two revisions in a given index"""
                 r = revlog.revlog(file, index, "")
                 a = r.ancestor(r.lookup(rev1), r.lookup(rev2))
                 ui.write("%d:%s\n" % (r.rev(a), hex(a)))
             def debugcheckstate(ui, repo):
                 """validate the correctness of the current dirstate"""
                 parent1, parent2 = repo.dirstate.parents()
                 repo.dirstate.read()
                 dc = repo.dirstate.map
                 keys = dc.keys()
                 keys.sort()
                 m1n = repo.changelog.read(parent1)[0]
                 m2n = repo.changelog.read(parent2)[0]
                 m1 = repo.manifest.read(m1n)
                 m2 = repo.manifest.read(m2n)
                 errors = 0
                 for f in dc:
                     state = repo.dirstate.state(f)
                     if state in "nr" and f not in m1:
                         ui.warn("%s in state %s, but not in manifest1\n" % (f, state))
                         errors += 1
                     if state in "a" and f in m1:
                         ui.warn("%s in state %s, but also in manifest1\n" % (f, state))
                         errors += 1
                     if state in "m" and f not in m1 and f not in m2:
                         ui.warn("%s in state %s, but not in either manifest\n" %
                                 (f, state))
                         errors += 1
                 for f in m1:
                     state = repo.dirstate.state(f)
                     if state not in "nrm":
                         ui.warn("%s in manifest1, but listed as state %s" % (f, state))
                         errors += 1
                 if errors:
                     raise util.Abort(".hg/dirstate inconsistent with current parent's manifest")
             def debugconfig(ui):
                 """show combined config settings from all hgrc files"""
                 try:
                     repo = hg.repository(ui)
                 except hg.RepoError:
                     pass
                 for section, name, value in ui.walkconfig():
                     ui.write('%s.%s=%s\n' % (section, name, value))
             def debugstate(ui, repo):
                 """show the contents of the current dirstate"""
                 repo.dirstate.read()
                 dc = repo.dirstate.map
                 keys = dc.keys()
                 keys.sort()
                 for file_ in keys:
                     ui.write("%c %3o %10d %s %s\n"
                              % (dc[file_][0], dc[file_][1] & 0777, dc[file_][2],
                                 time.strftime("%x %X",
                                               time.localtime(dc[file_][3])), file_))
                 for f in repo.dirstate.copies:
                     ui.write("copy: %s -> %s\n" % (repo.dirstate.copies[f], f))
             def debugdata(ui, file_, rev):
                 """dump the contents of an data file revision"""
                 r = revlog.revlog(file, file_[:-2] + ".i", file_)
                 ui.write(r.revision(r.lookup(rev)))
             def debugindex(ui, file_):
                 """dump the contents of an index file"""
                 r = revlog.revlog(file, file_, "")
                 ui.write("   rev    offset  length   base linkrev" +
                          " nodeid       p1           p2\n")
                 for i in range(r.count()):
                     e = r.index[i]
                     ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (
                             i, e[0], e[1], e[2], e[3],
                         short(e[6]), short(e[4]), short(e[5])))
             def debugindexdot(ui, file_):
                 """dump an index DAG as a .dot file"""
                 r = revlog.revlog(file, file_, "")
                 ui.write("digraph G {\n")
                 for i in range(r.count()):
                     e = r.index[i]
                     ui.write("\t%d -> %d\n" % (r.rev(e[4]), i))
                     if e[5] != nullid:
                         ui.write("\t%d -> %d\n" % (r.rev(e[5]), i))
                 ui.write("}\n")
             def debugrename(ui, repo, file, rev=None):
                 """dump rename information"""
                 r = repo.file(relpath(repo, [file])[0])
                 if rev:
                     try:
                         # assume all revision numbers are for changesets
                         n = repo.lookup(rev)
                         change = repo.changelog.read(n)
                         m = repo.manifest.read(change[0])
                         n = m[relpath(repo, [file])[0]]
                     except hg.RepoError, KeyError:
                         n = r.lookup(rev)
                 else:
                     n = r.tip()
                 m = r.renamed(n)
                 if m:
                     ui.write("renamed from %s:%s\n" % (m[0], hex(m[1])))
                 else:
                     ui.write("not renamed\n")
             def debugwalk(ui, repo, *pats, **opts):
                 """show how files match on given patterns"""
                 items = list(walk(repo, pats, opts))
                 if not items:
                     return
                 fmt = '%%s  %%-%ds  %%-%ds  %%s\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")
                 fns, matchfn, anypats = matchpats(repo, repo.getcwd(), pats, opts)
                 dodiff(sys.stdout, ui, repo, node1, node2, fns, match=matchfn,
                        text=opts['text'])
             def doexport(ui, repo, changeset, seqno, total, revwidth, opts):
                 node = repo.lookup(changeset)
                 prev, other = repo.changelog.parents(node)
                 change = repo.changelog.read(node)
                 fp = make_file(repo, repo.changelog, opts['output'],
                                node=node, total=total, seqno=seqno,
                                revwidth=revwidth)
                 if fp != sys.stdout:
                     ui.note("%s\n" % fp.name)
                 fp.write("# HG changeset patch\n")
                 fp.write("# User %s\n" % change[1])
                 fp.write("# Node ID %s\n" % hex(node))
                 fp.write("# Parent  %s\n" % hex(prev))
                 if other != nullid:
                     fp.write("# Parent  %s\n" % hex(other))
                 fp.write(change[4].rstrip())
                 fp.write("\n\n")
                 dodiff(fp, ui, repo, prev, node, text=opts['text'])
                 if fp != sys.stdout:
                     fp.close()
             def export(ui, repo, *changesets, **opts):
                 """dump the header and diffs for one or more changesets"""
                 if not changesets:
                     raise util.Abort("export requires at least one changeset")
                 seqno = 0
                 revs = list(revrange(ui, repo, changesets))
                 total = len(revs)
                 revwidth = max(map(len, revs))
                 ui.note(len(revs) > 1 and "Exporting patches:\n" or "Exporting patch:\n")
                 for cset in revs:
                     seqno += 1
                     doexport(ui, repo, cset, seqno, total, revwidth, opts)
             def forget(ui, repo, *pats, **opts):
                 """don't add the specified files on the next commit"""
                 forget = []
                 for src, abs, rel, exact in walk(repo, pats, opts):
                     if repo.dirstate.state(abs) == 'a':
                         forget.append(abs)
                         if ui.verbose or not exact:
                             ui.status('forgetting ', rel, '\n')
                 repo.forget(forget)
             def grep(ui, repo, pattern, *pats, **opts):
                 """search for a pattern in specified files and revisions"""
                 reflags = 0
                 if opts['ignore_case']:
                     reflags |= re.I
                 regexp = re.compile(pattern, reflags)
                 sep, eol = ':', '\n'
                 if opts['print0']:
                     sep = eol = '\0'
                 fcache = {}
                 def getfile(fn):
                     if fn not in fcache:
                         fcache[fn] = repo.file(fn)
                     return fcache[fn]
                 def matchlines(body):
                     begin = 0
                     linenum = 0
                     while True:
                         match = regexp.search(body, begin)
                         if not match:
                             break
                         mstart, mend = match.span()
                         linenum += body.count('\n', begin, mstart) + 1
                         lstart = body.rfind('\n', begin, mstart) + 1 or begin
                         lend = body.find('\n', mend)
                         yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]
                         begin = lend + 1
                 class linestate:
                     def __init__(self, line, linenum, colstart, colend):
                         self.line = line
                         self.linenum = linenum
                         self.colstart = colstart
                         self.colend = colend
                     def __eq__(self, other):
                         return self.line == other.line
                     def __hash__(self):
                         return hash(self.line)
                 matches = {}
                 def grepbody(fn, rev, body):
                     matches[rev].setdefault(fn, {})
                     m = matches[rev][fn]
                     for lnum, cstart, cend, line in matchlines(body):
                         s = linestate(line, lnum, cstart, cend)
                         m[s] = s
                 prev = {}
                 ucache = {}
                 def display(fn, rev, states, prevstates):
                     diff = list(sets.Set(states).symmetric_difference(sets.Set(prevstates)))
                     diff.sort(lambda x, y: cmp(x.linenum, y.linenum))
                     counts = {'-': 0, '+': 0}
                     filerevmatches = {}
                     for l in diff:
                         if incrementing or not opts['all']:
                             change = ((l in prevstates) and '-') or '+'
                             r = rev
                         else:
                             change = ((l in states) and '-') or '+'
                             r = prev[fn]
                         cols = [fn, str(rev)]
                         if opts['line_number']: cols.append(str(l.linenum))
                         if opts['all']: cols.append(change)
                         if opts['user']: cols.append(trimuser(ui, getchange(rev)[1], rev,
                                                               ucache))
                         if opts['files_with_matches']:
                             c = (fn, rev)
                             if c in filerevmatches: continue
                             filerevmatches[c] = 1
                         else:
                             cols.append(l.line)
                         ui.write(sep.join(cols), eol)
                         counts[change] += 1
                     return counts['+'], counts['-']
                 fstate = {}
                 skip = {}
                 changeiter, getchange = walkchangerevs(ui, repo, repo.getcwd(), pats, opts)
                 count = 0
                 for st, rev, fns in changeiter:
                     if st == 'window':
                         incrementing = rev
                         matches.clear()
                     elif st == 'add':
                         change = repo.changelog.read(repo.lookup(str(rev)))
                         mf = repo.manifest.read(change[0])
                         matches[rev] = {}
                         for fn in fns:
                             if fn in skip: continue
                             fstate.setdefault(fn, {})
                             try:
                                 grepbody(fn, rev, getfile(fn).read(mf[fn]))
                             except KeyError:
                                 pass
                     elif st == 'iter':
                         states = matches[rev].items()
                         states.sort()
                         for fn, m in states:
                             if fn in skip: continue
                             if incrementing or not opts['all'] or fstate[fn]:
                                 pos, neg = display(fn, rev, m, fstate[fn])
                                 count += pos + neg
                                 if pos and not opts['all']:
                                     skip[fn] = True
                             fstate[fn] = m
                             prev[fn] = rev
                 if not incrementing:
                     fstate = fstate.items()
                     fstate.sort()
                     for fn, state in fstate:
                         if fn in skip: continue
                         display(fn, rev, {}, state)
                 return (count == 0 and 1) or 0
             def heads(ui, repo, **opts):
                 """show current repository heads"""
                 heads = repo.changelog.heads()
                 br = None
                 if opts['branches']:
                     br = repo.branchlookup(heads)
                 for n in repo.changelog.heads():
                     show_changeset(ui, repo, changenode=n, brinfo=br)
             def identify(ui, repo):
                 """print information about the working copy"""
                 parents = [p for p in repo.dirstate.parents() if p != nullid]
                 if not parents:
                     ui.write("unknown\n")
                     return
                 hexfunc = ui.verbose and hex or short
                 (c, a, d, u) = repo.changes()
                 output = ["%s%s" % ('+'.join([hexfunc(parent) for parent in parents]),
                                     (c or a or d) and "+" or "")]
                 if not ui.quiet:
                     # multiple tags for a single parent separated by '/'
                     parenttags = ['/'.join(tags)
                                   for tags in map(repo.nodetags, parents) if tags]
                     # tags for multiple parents separated by ' + '
                     if parenttags:
                         output.append(' + '.join(parenttags))
                 ui.write("%s\n" % ' '.join(output))
             def import_(ui, repo, patch1, *patches, **opts):
                 """import an ordered set of patches"""
                 patches = (patch1,) + patches
                 if not opts['force']:
                     (c, a, d, u) = repo.changes()
                     if c or a or d:
                         raise util.Abort("outstanding uncommitted changes")
                 d = opts["base"]
                 strip = opts["strip"]
                 mailre = re.compile(r'(?:From |[\w-]+:)')
                 diffre = re.compile(r'(?:diff -|--- .*\s+\w+ \w+ +\d+ \d+:\d+:\d+ \d+)')
                 for patch in patches:
                     ui.status("applying %s\n" % patch)
                     pf = os.path.join(d, patch)
                     message = []
                     user = None
                     hgpatch = False
                     for line in file(pf):
                         line = line.rstrip()
                         if (not message and not hgpatch and
                                mailre.match(line) and not opts['force']):
                             if len(line) > 35: line = line[:32] + '...'
                             raise util.Abort('first line looks like a '
                                              'mail header: ' + line)
                         if diffre.match(line):
                             break
                         elif hgpatch:
                             # parse values when importing the result of an hg export
                             if line.startswith("# User "):
                                 user = line[7:]
                                 ui.debug('User: %s\n' % user)
                             elif not line.startswith("# ") and line:
                                 message.append(line)
                                 hgpatch = False
                         elif line == '# HG changeset patch':
                             hgpatch = True
                             message = []       # We may have collected garbage
                         else:
                             message.append(line)
                     # make sure message isn't empty
                     if not message:
                         message = "imported patch %s\n" % patch
                     else:
                         message = "%s\n" % '\n'.join(message)
                     ui.debug('message:\n%s\n' % message)
-                    f = os.popen("patch -p%d < '%s'" % (strip, pf))
+                    files = util.patch(strip, pf, ui)
-                    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", **opts):
                 """show new changesets found in source"""
                 source = ui.expandpath(source)
                 other = hg.repository(ui, source)
                 if not other.local():
                     raise util.Abort("incoming doesn't work for remote repositories yet")
                 o = repo.findincoming(other)
                 if not o:
                     return
                 o = other.newer(o)
                 o.reverse()
                 for n in o:
                     show_changeset(ui, other, changenode=n)
                     if opts['patch']:
                         prev = other.changelog.parents(n)[0]
                         dodiff(ui, ui, other, prev, n)
                         ui.write("\n")
             def init(ui, dest="."):
                 """create a new repository in the given directory"""
                 if not os.path.exists(dest):
                     os.mkdir(dest)
                 hg.repository(ui, dest, create=1)
             def locate(ui, repo, *pats, **opts):
                 """locate files matching specific patterns"""
                 end = opts['print0'] and '\0' or '\n'
                 for src, abs, rel, exact in walk(repo, pats, opts, '(?:.*/|)'):
                     if repo.dirstate.state(abs) == '?':
                         continue
                     if opts['fullpath']:
                         ui.write(os.path.join(repo.root, abs), end)
                     else:
                         ui.write(rel, end)
             def log(ui, repo, *pats, **opts):
                 """show revision history of entire repository or files"""
                 class dui:
                     # Implement and delegate some ui protocol.  Save hunks of
                     # output for later display in the desired order.
                     def __init__(self, ui):
                         self.ui = ui
                         self.hunk = {}
                     def bump(self, rev):
                         self.rev = rev
                         self.hunk[rev] = []
                     def note(self, *args):
                         if self.verbose:
                             self.write(*args)
                     def status(self, *args):
                         if not self.quiet:
                             self.write(*args)
                     def write(self, *args):
                         self.hunk[self.rev].append(args)
                     def __getattr__(self, key):
                         return getattr(self.ui, key)
                 cwd = repo.getcwd()
                 if not pats and cwd:
                     opts['include'] = [os.path.join(cwd, i) for i in opts['include']]
                     opts['exclude'] = [os.path.join(cwd, x) for x in opts['exclude']]
                 changeiter, getchange = walkchangerevs(ui, repo, (pats and cwd) or '',
                                                        pats, opts)
                 for st, rev, fns in changeiter:
                     if st == 'window':
                         du = dui(ui)
                     elif st == 'add':
                         du.bump(rev)
                         br = None
                         if opts['branch']:
                             br = repo.branchlookup([repo.changelog.node(rev)])
                         show_changeset(du, repo, rev, brinfo=br)
                         if opts['patch']:
                             changenode = repo.changelog.node(rev)
                             prev, other = repo.changelog.parents(changenode)
                             dodiff(du, du, repo, prev, changenode, fns)
                             du.write("\n\n")
                     elif st == 'iter':
                         for args in du.hunk[rev]:
                             ui.write(*args)
             def manifest(ui, repo, rev=None):
                 """output the latest or given revision of the project manifest"""
                 if rev:
                     try:
                         # assume all revision numbers are for changesets
                         n = repo.lookup(rev)
                         change = repo.changelog.read(n)
                         n = change[0]
                     except hg.RepoError:
                         n = repo.manifest.lookup(rev)
                 else:
                     n = repo.manifest.tip()
                 m = repo.manifest.read(n)
                 mf = repo.manifest.readflags(n)
                 files = m.keys()
                 files.sort()
                 for f in files:
                     ui.write("%40s %3s %s\n" % (hex(m[f]), mf[f] and "755" or "644", f))
             def outgoing(ui, repo, dest="default-push", **opts):
                 """show changesets not found in destination"""
                 dest = ui.expandpath(dest)
                 other = hg.repository(ui, dest)
                 o = repo.findoutgoing(other)
                 o = repo.newer(o)
                 o.reverse()
                 for n in o:
                     show_changeset(ui, repo, changenode=n)
                     if opts['patch']:
                         prev = repo.changelog.parents(n)[0]
                         dodiff(ui, ui, repo, prev, n)
                         ui.write("\n")
             def parents(ui, repo, rev=None):
                 """show the parents of the working dir or revision"""
                 if rev:
                     p = repo.changelog.parents(repo.lookup(rev))
                 else:
                     p = repo.dirstate.parents()
                 for n in p:
                     if n != nullid:
                         show_changeset(ui, repo, changenode=n)
             def paths(ui, search=None):
                 """show definition of symbolic path names"""
                 try:
                     repo = hg.repository(ui=ui)
                 except hg.RepoError:
                     pass
                 if search:
                     for name, path in ui.configitems("paths"):
                         if name == search:
                             ui.write("%s\n" % path)
                             return
                     ui.warn("not found!\n")
                     return 1
                 else:
                     for name, path in ui.configitems("paths"):
                         ui.write("%s = %s\n" % (name, path))
             def pull(ui, repo, source="default", **opts):
                 """pull changes from the specified source"""
                 source = ui.expandpath(source)
                 ui.status('pulling from %s\n' % (source))
                 if opts['ssh']:
                     ui.setconfig("ui", "ssh", opts['ssh'])
                 if opts['remotecmd']:
                     ui.setconfig("ui", "remotecmd", opts['remotecmd'])
                 other = hg.repository(ui, source)
                 r = repo.pull(other)
                 if not r:
                     if opts['update']:
                         return update(ui, repo)
                     else:
                         ui.status("(run 'hg update' to get a working copy)\n")
                 return r
             def push(ui, repo, dest="default-push", force=False, ssh=None, remotecmd=None):
                 """push changes to the specified destination"""
                 dest = ui.expandpath(dest)
                 ui.status('pushing to %s\n' % (dest))
                 if ssh:
                     ui.setconfig("ui", "ssh", ssh)
                 if remotecmd:
                     ui.setconfig("ui", "remotecmd", remotecmd)
                 other = hg.repository(ui, dest)
                 r = repo.push(other, force)
                 return r
             def rawcommit(ui, repo, *flist, **rc):
                 "raw commit interface"
                 if rc['text']:
                     ui.warn("Warning: -t and --text is deprecated,"
                             " please use -m or --message instead.\n")
                 message = rc['message'] or rc['text']
                 if not message and rc['logfile']:
                     try:
                         message = open(rc['logfile']).read()
                     except IOError:
                         pass
                 if not message and not rc['logfile']:
                     raise util.Abort("missing commit message")
                 files = relpath(repo, list(flist))
                 if rc['files']:
                     files += open(rc['files']).read().splitlines()
                 rc['parent'] = map(repo.lookup, rc['parent'])
                 try:
                     repo.rawcommit(files, message, rc['user'], rc['date'], *rc['parent'])
                 except ValueError, inst:
                     raise util.Abort(str(inst))
             def recover(ui, repo):
                 """roll back an interrupted transaction"""
                 repo.recover()
             def remove(ui, repo, pat, *pats, **opts):
                 """remove the specified files on the next commit"""
                 names = []
                 def okaytoremove(abs, rel, exact):
                     c, a, d, u = repo.changes(files = [abs])
                     reason = None
                     if c: reason = 'is modified'
                     elif a: reason = 'has been marked for add'
                     elif u: reason = 'is not managed'
                     if reason:
                         if exact: ui.warn('not removing %s: file %s\n' % (rel, reason))
                     else:
                         return True
                 for src, abs, rel, exact in walk(repo, (pat,) + pats, opts):
                     if okaytoremove(abs, rel, exact):
                         if ui.verbose or not exact: ui.status('removing %s\n' % rel)
                         names.append(abs)
                 for name in names:
                     try:
                         os.unlink(name)
                     except OSError, inst:
                         if inst.errno != errno.ENOENT: raise
                 repo.remove(names)
             def rename(ui, repo, *pats, **opts):
                 """rename files; equivalent of copy + remove"""
                 errs, copied = docopy(ui, repo, pats, opts)
                 names = []
                 for abs, rel, exact in copied:
                     if ui.verbose or not exact: ui.status('removing %s\n' % rel)
                     try:
                         os.unlink(rel)
                     except OSError, inst:
                         if inst.errno != errno.ENOENT: raise
                     names.append(abs)
                 repo.remove(names)
                 return errs
             def revert(ui, repo, *names, **opts):
                 """revert modified files or dirs back to their unmodified states"""
                 node = opts['rev'] and repo.lookup(opts['rev']) or \
                        repo.dirstate.parents()[0]
                 root = os.path.realpath(repo.root)
                 def trimpath(p):
                     p = os.path.realpath(p)
                     if p.startswith(root):
                         rest = p[len(root):]
                         if not rest:
                             return rest
                         if p.startswith(os.sep):
                             return rest[1:]
                         return p
                 relnames = map(trimpath, names or [os.getcwd()])
                 chosen = {}
                 def choose(name):
                     def body(name):
                         for r in relnames:
                             if not name.startswith(r):
                                 continue
                             rest = name[len(r):]
                             if not rest:
                                 return r, True
                             depth = rest.count(os.sep)
                             if not r:
                                 if depth == 0 or not opts['nonrecursive']:
                                     return r, True
                             elif rest[0] == os.sep:
                                 if depth == 1 or not opts['nonrecursive']:
                                     return r, True
                         return None, False
                     relname, ret = body(name)
                     if ret:
                         chosen[relname] = 1
                     return ret
                 r = repo.update(node, False, True, choose, False)
                 for n in relnames:
                     if n not in chosen:
                         ui.warn('error: no matches for %s\n' % n)
                         r = 1
                 sys.stdout.flush()
                 return r
             def root(ui, repo):
                 """print the root (top) of the current working dir"""
                 ui.write(repo.root + "\n")
             def serve(ui, repo, **opts):
                 """export the repository via HTTP"""
                 if opts["stdio"]:
                     fin, fout = sys.stdin, sys.stdout
                     sys.stdout = sys.stderr
                     def getarg():
                         argline = fin.readline()[:-1]
                         arg, l = argline.split()
                         val = fin.read(int(l))
                         return arg, val
                     def respond(v):
                         fout.write("%d\n" % len(v))
                         fout.write(v)
                         fout.flush()
                     lock = None
                     while 1:
                         cmd = fin.readline()[:-1]
                         if cmd == '':
                             return
                         if cmd == "heads":
                             h = repo.heads()
                             respond(" ".join(map(hex, h)) + "\n")
                         if cmd == "lock":
                             lock = repo.lock()
                             respond("")
                         if cmd == "unlock":
                             if lock:
                                 lock.release()
                             lock = None
                             respond("")
                         elif cmd == "branches":
                             arg, nodes = getarg()
                             nodes = map(bin, nodes.split(" "))
                             r = []
                             for b in repo.branches(nodes):
                                 r.append(" ".join(map(hex, b)) + "\n")
                             respond("".join(r))
                         elif cmd == "between":
                             arg, pairs = getarg()
                             pairs = [map(bin, p.split("-")) for p in pairs.split(" ")]
                             r = []
                             for b in repo.between(pairs):
                                 r.append(" ".join(map(hex, b)) + "\n")
                             respond("".join(r))
                         elif cmd == "changegroup":
                             nodes = []
                             arg, roots = getarg()
                             nodes = map(bin, roots.split(" "))
                             cg = repo.changegroup(nodes)
                             while 1:
                                 d = cg.read(4096)
                                 if not d:
                                     break
                                 fout.write(d)
                             fout.flush()
                         elif cmd == "addchangegroup":
                             if not lock:
                                 respond("not locked")
                                 continue
                             respond("")
                             r = repo.addchangegroup(fin)
                             respond("")
                 optlist = "name templates style address port ipv6 accesslog errorlog"
                 for o in optlist.split():
                     if opts[o]:
                         ui.setconfig("web", o, opts[o])
                 try:
                     httpd = hgweb.create_server(repo)
                 except socket.error, inst:
                     raise util.Abort('cannot start server: ' + inst.args[1])
                 if ui.verbose:
                     addr, port = httpd.socket.getsockname()
                     if addr == '0.0.0.0':
                         addr = socket.gethostname()
                     else:
                         try:
                             addr = socket.gethostbyaddr(addr)[0]
                         except socket.error:
                             pass
                     if port != 80:
                         ui.status('listening at http://%s:%d/\n' % (addr, port))
                     else:
                         ui.status('listening at http://%s/\n' % addr)
                 httpd.serve_forever()
             def status(ui, repo, *pats, **opts):
                 '''show changed files in the working directory
                 M = modified
                 A = added
                 R = removed
                 ? = not tracked
                 '''
                 cwd = repo.getcwd()
                 files, matchfn, anypats = matchpats(repo, cwd, pats, opts)
                 (c, a, d, u) = [[util.pathto(cwd, x) for x in n]
                                 for n in repo.changes(files=files, match=matchfn)]
                 changetypes = [('modified', 'M', c),
                                ('added', 'A', a),
                                ('removed', 'R', d),
                                ('unknown', '?', u)]
                 end = opts['print0'] and '\0' or '\n'
                 for opt, char, changes in ([ct for ct in changetypes if opts[ct[0]]]
                                            or changetypes):
                     if opts['no_status']:
                         format = "%%s%s" % end
                     else:
                         format = "%s %%s%s" % (char, end);
                     for f in changes:
                         ui.write(format % f)
             def tag(ui, repo, name, rev=None, **opts):
                 """add a tag for the current tip or a given revision"""
                 if opts['text']:
                     ui.warn("Warning: -t and --text is deprecated,"
                             " please use -m or --message instead.\n")
                 if name == "tip":
                     raise util.Abort("the name 'tip' is reserved")
                 if rev:
                     r = hex(repo.lookup(rev))
                 else:
                     r = hex(repo.changelog.tip())
                 if name.find(revrangesep) >= 0:
                     raise util.Abort("'%s' cannot be used in a tag name" % revrangesep)
                 if opts['local']:
                     repo.opener("localtags", "a").write("%s %s\n" % (r, name))
                     return
                 (c, a, d, u) = repo.changes()
                 for x in (c, a, d, u):
                     if ".hgtags" in x:
                         raise util.Abort("working copy of .hgtags is changed "
                                          "(please commit .hgtags manually)")
                 repo.wfile(".hgtags", "ab").write("%s %s\n" % (r, name))
                 if repo.dirstate.state(".hgtags") == '?':
                     repo.add([".hgtags"])
                 message = (opts['message'] or opts['text'] or
                            "Added tag %s for changeset %s" % (name, r))
                 try:
                     repo.commit([".hgtags"], message, opts['user'], opts['date'])
                 except ValueError, inst:
                     raise util.Abort(str(inst))
             def tags(ui, repo):
                 """list repository tags"""
                 l = repo.tagslist()
                 l.reverse()
                 for t, n in l:
                     try:
                         r = "%5d:%s" % (repo.changelog.rev(n), hex(n))
                     except KeyError:
                         r = "    ?:?"
                     ui.write("%-30s %s\n" % (t, r))
             def tip(ui, repo):
                 """show the tip revision"""
                 n = repo.changelog.tip()
                 show_changeset(ui, repo, changenode=n)
             def unbundle(ui, repo, fname):
                 """apply a changegroup file"""
                 f = urllib.urlopen(fname)
                 if f.read(4) != "HG10":
                     raise util.Abort("%s: not a Mercurial bundle file" % fname)
                 class bzread:
                     def __init__(self, f):
                         self.zd = bz2.BZ2Decompressor()
                         self.f = f
                         self.buf = ""
                     def read(self, l):
                         while l > len(self.buf):
                             r = self.f.read(4096)
                             if r:
                                 self.buf += self.zd.decompress(r)
                             else:
                                 break
                         d, self.buf = self.buf[:l], self.buf[l:]
                         return d
                 repo.addchangegroup(bzread(f))
             def undo(ui, repo):
                 """undo the last commit or pull
                 Roll back the last pull or commit transaction on the
                 repository, restoring the project to its earlier state.
                 This command should be used with care. There is only one level of
                 undo and there is no redo.
                 This command is not intended for use on public repositories. Once
                 a change is visible for pull by other users, undoing it locally is
                 ineffective.
                 """
                 repo.undo()
             def update(ui, repo, node=None, merge=False, clean=False, branch=None):
                 '''update or merge working directory
                 If there are no outstanding changes in the working directory and
                 there is a linear relationship between the current version and the
                 requested version, the result is the requested version.
                 Otherwise the result is a merge between the contents of the
                 current working directory and the requested version. Files that
                 changed between either parent are marked as changed for the next
                 commit and a commit must be performed before any further updates
                 are allowed.
                 '''
                 if branch:
                     br = repo.branchlookup(branch=branch)
                     found = []
                     for x in br:
                         if branch in br[x]:
                             found.append(x)
                     if len(found) > 1:
                         ui.warn("Found multiple heads for %s\n" % branch)
                         for x in found:
                             show_changeset(ui, repo, changenode=x, brinfo=br)
                         return 1
                     if len(found) == 1:
                         node = found[0]
                         ui.warn("Using head %s for branch %s\n" % (short(node), branch))
                     else:
                         ui.warn("branch %s not found\n" % (branch))
                         return 1
                 else:
                     node = node and repo.lookup(node) or repo.changelog.tip()
                 return repo.update(node, allow=merge, force=clean)
             def verify(ui, repo):
                 """verify the integrity of the repository"""
                 return repo.verify()
             # Command options and aliases are listed here, alphabetically
             table = {
                 "^add":
                     (add,
                      [('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'exclude path from search')],
                      "hg add [OPTION]... [FILE]..."),
                 "addremove":
                     (addremove,
                      [('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'exclude path from search')],
                      "hg addremove [OPTION]... [FILE]..."),
                 "^annotate":
                     (annotate,
                      [('r', 'rev', '', 'revision'),
                       ('a', 'text', None, 'treat all files as text'),
                       ('u', 'user', None, 'show user'),
                       ('n', 'number', None, 'show revision number'),
                       ('c', 'changeset', None, 'show changeset'),
                       ('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'exclude path from search')],
                      'hg annotate [OPTION]... FILE...'),
                 "bundle":
                     (bundle,
                      [],
                      'hg bundle FILE DEST'),
                 "cat":
                     (cat,
                      [('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'exclude path from search'),
                       ('o', 'output', "", 'output to file'),
                       ('r', 'rev', '', 'revision')],
                      'hg cat [OPTION]... FILE...'),
                 "^clone":
                     (clone,
                      [('U', 'noupdate', None, 'skip update after cloning'),
                       ('e', 'ssh', "", 'ssh command'),
                       ('', 'pull', None, 'use pull protocol to copy metadata'),
                       ('', 'remotecmd', "", 'remote hg command')],
                      'hg clone [OPTION]... SOURCE [DEST]'),
                 "^commit|ci":
                     (commit,
                      [('A', 'addremove', None, 'run add/remove during commit'),
                       ('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'exclude path from search'),
                       ('m', 'message', "", 'commit message'),
                       ('t', 'text', "", 'commit message (deprecated: use -m)'),
                       ('l', 'logfile', "", 'commit message file'),
                       ('d', 'date', "", 'date code'),
                       ('u', 'user', "", 'user')],
                      'hg commit [OPTION]... [FILE]...'),
                 "copy|cp": (copy,
                          [('I', 'include', [], 'include path in search'),
                           ('X', 'exclude', [], 'exclude path from search'),
                           ('A', 'after', None, 'record a copy after it has happened'),
                           ('f', 'force', None, 'replace destination if it exists'),
                           ('p', 'parents', None, 'append source path to dest')],
                          'hg copy [OPTION]... [SOURCE]... DEST'),
                 "debugancestor": (debugancestor, [], 'debugancestor INDEX REV1 REV2'),
                 "debugcheckstate": (debugcheckstate, [], 'debugcheckstate'),
                 "debugconfig": (debugconfig, [], 'debugconfig'),
                 "debugstate": (debugstate, [], 'debugstate'),
                 "debugdata": (debugdata, [], 'debugdata FILE REV'),
                 "debugindex": (debugindex, [], 'debugindex FILE'),
                 "debugindexdot": (debugindexdot, [], 'debugindexdot FILE'),
                 "debugrename": (debugrename, [], 'debugrename FILE [REV]'),
                 "debugwalk":
                     (debugwalk,
                      [('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'exclude path from search')],
                      'debugwalk [OPTION]... [FILE]...'),
                 "^diff":
                     (diff,
                      [('r', 'rev', [], 'revision'),
                       ('a', 'text', None, 'treat all files as text'),
                       ('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'exclude path from search')],
                      'hg diff [-a] [-I] [-X] [-r REV1 [-r REV2]] [FILE]...'),
                 "^export":
                     (export,
                      [('o', 'output', "", 'output to file'),
                       ('a', 'text', None, 'treat all files as text')],
                      "hg export [-a] [-o OUTFILE] REV..."),
                 "forget":
                     (forget,
                      [('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'exclude path from search')],
                      "hg forget [OPTION]... FILE..."),
                 "grep":
                     (grep,
                      [('0', 'print0', None, 'end fields with NUL'),
                       ('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'include path in search'),
                       ('', 'all', None, 'print all revisions with matches'),
                       ('i', 'ignore-case', None, 'ignore case when matching'),
                       ('l', 'files-with-matches', None, 'print names of files and revs with matches'),
                       ('n', 'line-number', None, 'print line numbers'),
                       ('r', 'rev', [], 'search in revision rev'),
                       ('u', 'user', None, 'print user who made change')],
                      "hg grep [OPTION]... PATTERN [FILE]..."),
                 "heads":
                     (heads,
                      [('b', 'branches', None, 'find branch info')],
                      'hg heads [-b]'),
                 "help": (help_, [], 'hg help [COMMAND]'),
                 "identify|id": (identify, [], 'hg identify'),
                 "import|patch":
                     (import_,
                      [('p', 'strip', 1, 'path strip'),
                       ('f', 'force', None, 'skip check for outstanding changes'),
                       ('b', 'base', "", 'base path')],
                      "hg import [-f] [-p NUM] [-b BASE] PATCH..."),
                 "incoming|in": (incoming,
                      [('p', 'patch', None, 'show patch')],
                      'hg incoming [-p] [SOURCE]'),
                 "^init": (init, [], 'hg init [DEST]'),
                 "locate":
                     (locate,
                      [('r', 'rev', '', 'revision'),
                       ('0', 'print0', None, 'end filenames with NUL'),
                       ('f', 'fullpath', None, 'print complete paths'),
                       ('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'exclude path from search')],
                      'hg locate [OPTION]... [PATTERN]...'),
                 "^log|history":
                     (log,
                      [('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'exclude path from search'),
                       ('b', 'branch', None, 'show branches'),
                       ('r', 'rev', [], 'revision'),
                       ('p', 'patch', None, 'show patch')],
                      'hg log [-I] [-X] [-r REV]... [-p] [FILE]'),
                 "manifest": (manifest, [], 'hg manifest [REV]'),
                 "outgoing|out": (outgoing,
                      [('p', 'patch', None, 'show patch')],
                      'hg outgoing [-p] [DEST]'),
                 "parents": (parents, [], 'hg parents [REV]'),
                 "paths": (paths, [], 'hg paths [NAME]'),
                 "^pull":
                     (pull,
                      [('u', 'update', None, 'update working directory'),
                       ('e', 'ssh', "", 'ssh command'),
                       ('', 'remotecmd', "", 'remote hg command')],
                      'hg pull [-u] [-e FILE] [--remotecmd FILE] [SOURCE]'),
                 "^push":
                     (push,
                      [('f', 'force', None, 'force push'),
                       ('e', 'ssh', "", 'ssh command'),
                       ('', 'remotecmd', "", 'remote hg command')],
                      'hg push [-f] [-e FILE] [--remotecmd FILE] [DEST]'),
                 "rawcommit":
                     (rawcommit,
                      [('p', 'parent', [], 'parent'),
                       ('d', 'date', "", 'date code'),
                       ('u', 'user', "", 'user'),
                       ('F', 'files', "", 'file list'),
                       ('m', 'message', "", 'commit message'),
                       ('t', 'text', "", 'commit message (deprecated: use -m)'),
                       ('l', 'logfile', "", 'commit message file')],
                      'hg rawcommit [OPTION]... [FILE]...'),
                 "recover": (recover, [], "hg recover"),
                 "^remove|rm": (remove,
                                [('I', 'include', [], 'include path in search'),
                                 ('X', 'exclude', [], 'exclude path from search')],
                                "hg remove [OPTION]... FILE..."),
                 "rename|mv": (rename,
                               [('I', 'include', [], 'include path in search'),
                                ('X', 'exclude', [], 'exclude path from search'),
                                ('A', 'after', None, 'record a copy after it has happened'),
                                ('f', 'force', None, 'replace destination if it exists'),
                                ('p', 'parents', None, 'append source path to dest')],
                               'hg rename [OPTION]... [SOURCE]... DEST'),
                 "^revert":
                     (revert,
                      [("n", "nonrecursive", None, "don't recurse into subdirs"),
                       ("r", "rev", "", "revision")],
                      "hg revert [-n] [-r REV] [NAME]..."),
                 "root": (root, [], "hg root"),
                 "^serve":
                     (serve,
                      [('A', 'accesslog', '', 'access log file'),
                       ('E', 'errorlog', '', 'error log file'),
                       ('p', 'port', 0, 'listen port'),
                       ('a', 'address', '', 'interface address'),
                       ('n', 'name', "", 'repository name'),
                       ('', 'stdio', None, 'for remote clients'),
                       ('t', 'templates', "", 'template directory'),
                       ('', 'style', "", 'template style'),
                       ('6', 'ipv6', None, 'use IPv6 in addition to IPv4')],
                      "hg serve [OPTION]..."),
                 "^status":
                     (status,
                      [('m', 'modified', None, 'show only modified files'),
                       ('a', 'added', None, 'show only added files'),
                       ('r', 'removed', None, 'show only removed files'),
                       ('u', 'unknown', None, 'show only unknown (not tracked) files'),
                       ('n', 'no-status', None, 'hide status prefix'),
                       ('0', 'print0', None, 'end filenames with NUL'),
                       ('I', 'include', [], 'include path in search'),
                       ('X', 'exclude', [], 'exclude path from search')],
                      "hg status [OPTION]... [FILE]..."),
                 "tag":
                     (tag,
                      [('l', 'local', None, 'make the tag local'),
                       ('m', 'message', "", 'commit message'),
                       ('t', 'text', "", 'commit message (deprecated: use -m)'),
                       ('d', 'date', "", 'date code'),
                       ('u', 'user', "", 'user')],
                      'hg tag [OPTION]... NAME [REV]'),
                 "tags": (tags, [], 'hg tags'),
                 "tip": (tip, [], 'hg tip'),
                 "unbundle":
                     (unbundle,
                      [],
                      'hg unbundle FILE'),
                 "undo": (undo, [], 'hg undo'),
                 "^update|up|checkout|co":
                     (update,
                      [('b', 'branch', "", 'checkout the head of a specific branch'),
                       ('m', 'merge', None, 'allow merging of conflicts'),
                       ('C', 'clean', None, 'overwrite locally modified files')],
                      'hg update [-b TAG] [-m] [-C] [REV]'),
                 "verify": (verify, [], 'hg verify'),
                 "version": (show_version, [], 'hg version'),
             }
             globalopts = [
                 ('R', 'repository', "", 'repository root directory'),
                 ('', 'cwd', '', 'change working directory'),
                 ('y', 'noninteractive', None, 'run non-interactively'),
                 ('q', 'quiet', None, 'quiet mode'),
                 ('v', 'verbose', None, 'verbose mode'),
                 ('', 'debug', None, 'debug mode'),
                 ('', 'debugger', None, 'start debugger'),
                 ('', 'traceback', None, 'print traceback on exception'),
                 ('', 'time', None, 'time how long the command takes'),
                 ('', 'profile', None, 'profile'),
                 ('', 'version', None, 'output version information and exit'),
                 ('h', 'help', None, 'display help and exit'),
             ]
             norepo = ("clone init version help debugancestor debugconfig debugdata"
                       " debugindex debugindexdot paths")
             def find(cmd):
                 for e in table.keys():
                     if re.match("(%s)$" % e, cmd):
                         return e, table[e]
                 raise UnknownCommand(cmd)
             class SignalInterrupt(Exception):
                 """Exception raised on SIGTERM and SIGHUP."""
             def catchterm(*args):
                 raise SignalInterrupt
             def run():
                 sys.exit(dispatch(sys.argv[1:]))
             class ParseError(Exception):
                 """Exception raised on errors in parsing the command line."""
             def parse(args):
                 options = {}
                 cmdoptions = {}
                 try:
                     args = fancyopts.fancyopts(args, globalopts, options)
                 except fancyopts.getopt.GetoptError, inst:
                     raise ParseError(None, inst)
                 if args:
                     cmd, args = args[0], args[1:]
                     i = find(cmd)[1]
                     c = list(i[1])
                 else:
                     cmd = None
                     c = []
                 # combine global options into local
                 for o in globalopts:
                     c.append((o[0], o[1], options[o[1]], o[3]))
                 try:
                     args = fancyopts.fancyopts(args, c, cmdoptions)
                 except fancyopts.getopt.GetoptError, inst:
                     raise ParseError(cmd, inst)
                 # separate global options back out
                 for o in globalopts:
                     n = o[1]
                     options[n] = cmdoptions[n]
                     del cmdoptions[n]
                 return (cmd, cmd and i[0] or None, args, options, cmdoptions)
             def dispatch(args):
                 signal.signal(signal.SIGTERM, catchterm)
                 try:
                     signal.signal(signal.SIGHUP, catchterm)
                 except AttributeError:
                     pass
                 u = ui.ui()
                 external = []
                 for x in u.extensions():
                     if x[1]:
                         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"])
                 # enter the debugger before command execution
                 if options['debugger']:
                     pdb.set_trace()
                 try:
                     try:
                         if options['help']:
                             help_(u, cmd, options['version'])
                             sys.exit(0)
                         elif options['version']:
                             show_version(u)
                             sys.exit(0)
                         elif not cmd:
                             help_(u, 'shortlist')
                             sys.exit(0)
                         if options['cwd']:
                             try:
                                 os.chdir(options['cwd'])
                             except OSError, inst:
                                 raise util.Abort('%s: %s' %
                                                  (options['cwd'], inst.strerror))
                         if cmd not in norepo.split():
                             path = options["repository"] or ""
                             repo = hg.repository(ui=u, path=path)
                             for x in external:
                                 x.reposetup(u, repo)
                             d = lambda: func(u, repo, *args, **cmdoptions)
                         else:
                             d = lambda: func(u, *args, **cmdoptions)
                         if options['profile']:
                             import hotshot, hotshot.stats
                             prof = hotshot.Profile("hg.prof")
                             r = prof.runcall(d)
                             prof.close()
                             stats = hotshot.stats.load("hg.prof")
                             stats.strip_dirs()
                             stats.sort_stats('time', 'calls')
                             stats.print_stats(40)
                             return r
                         else:
                             return d()
                     except:
                         # enter the debugger when we hit an exception
                         if options['debugger']:
                             pdb.post_mortem(sys.exc_info()[2])
                         if options['traceback']:
                             traceback.print_exc()
                         raise
                 except hg.RepoError, inst:
                     u.warn("abort: ", inst, "!\n")
                 except revlog.RevlogError, inst:
                     u.warn("abort: ", inst, "!\n")
                 except SignalInterrupt:
                     u.warn("killed!\n")
                 except KeyboardInterrupt:
                     try:
                         u.warn("interrupted!\n")
                     except IOError, inst:
                         if inst.errno == errno.EPIPE:
                             if u.debugflag:
                                 u.warn("\nbroken pipe\n")
                         else:
                             raise
                 except IOError, inst:
                     if hasattr(inst, "code"):
                         u.warn("abort: %s\n" % inst)
                     elif hasattr(inst, "reason"):
                         u.warn("abort: error: %s\n" % inst.reason[1])
                     elif hasattr(inst, "args") and inst[0] == errno.EPIPE:
                         if u.debugflag:
                             u.warn("broken pipe\n")
                     else:
                         raise
                 except OSError, inst:
                     if hasattr(inst, "filename"):
                         u.warn("abort: %s: %s\n" % (inst.strerror, inst.filename))
                     else:
                         u.warn("abort: %s\n" % inst.strerror)
                 except util.Abort, inst:
                     u.warn('abort: ', inst.args[0] % inst.args[1:], '\n')
                     sys.exit(1)
                 except TypeError, inst:
                     # was this an argument error?
                     tb = traceback.extract_tb(sys.exc_info()[2])
                     if len(tb) > 2: # no
                         raise
                     u.debug(inst, "\n")
                     u.warn("%s: invalid arguments\n" % cmd)
                     help_(u, cmd)
                 except UnknownCommand, inst:
                     u.warn("hg: unknown command '%s'\n" % inst.args[0])
                     help_(u, 'shortlist')
                 except SystemExit:
                     # don't catch this in the catch-all below
                     raise
                 except:
                     u.warn("** unknown exception encountered, details follow\n")
                     u.warn("** report bug details to mercurial@selenic.com\n")
                     raise
                 sys.exit(-1)

             """
             util.py - Mercurial utility functions and platform specfic implementations
              Copyright 2005 K. Thananchayan <thananck@yahoo.com>
             This software may be used and distributed according to the terms
             of the GNU General Public License, incorporated herein by reference.
             This contains helper routines that are independent of the SCM core and hide
             platform-specific details from the core.
             """
             import os, errno
             from demandload import *
             demandload(globals(), "re cStringIO shutil popen2 threading")
             def filter(s, cmd):
                 "filter a string through a command that transforms its input to its output"
                 (pout, pin) = popen2.popen2(cmd, -1, 'b')
                 def writer():
                     pin.write(s)
                     pin.close()
                 # we should use select instead on UNIX, but this will work on most
                 # systems, including Windows
                 w = threading.Thread(target=writer)
                 w.start()
                 f = pout.read()
                 pout.close()
                 w.join()
                 return f
+            def patch(strip, patchname, ui):
+                """apply the patch <patchname> to the working directory.
+                a list of patched files is returned"""
+                fp = os.popen('patch -p%d < "%s"' % (strip, patchname))
+                files = {}
+                for line in fp:
+                    line = line.rstrip()
+                    ui.status("%s\n" % line)
+                    if line.startswith('patching file '):
+                        pf = parse_patch_output(line)
+                        files.setdefault(pf, 1)
+                code = fp.close()
+                if code:
+                    raise Abort("patch command failed: exit status %s " % code)
+                return files.keys()
             def binary(s):
                 """return true if a string is binary data using diff's heuristic"""
                 if s and '\0' in s[:4096]:
                     return True
                 return False
             def unique(g):
                 """return the uniq elements of iterable g"""
                 seen = {}
                 for f in g:
                     if f not in seen:
                         seen[f] = 1
                         yield f
             class Abort(Exception):
                 """Raised if a command needs to print an error and exit."""
             def always(fn): return True
             def never(fn): return False
             def globre(pat, head='^', tail='$'):
                 "convert a glob pattern into a regexp"
                 i, n = 0, len(pat)
                 res = ''
                 group = False
                 def peek(): return i < n and pat[i]
                 while i < n:
                     c = pat[i]
                     i = i+1
                     if c == '*':
                         if peek() == '*':
                             i += 1
                             res += '.*'
                         else:
                             res += '[^/]*'
                     elif c == '?':
                         res += '.'
                     elif c == '[':
                         j = i
                         if j < n and pat[j] in '!]':
                             j += 1
                         while j < n and pat[j] != ']':
                             j += 1
                         if j >= n:
                             res += '\\['
                         else:
                             stuff = pat[i:j].replace('\\','\\\\')
                             i = j + 1
                             if stuff[0] == '!':
                                 stuff = '^' + stuff[1:]
                             elif stuff[0] == '^':
                                 stuff = '\\' + stuff
                             res = '%s[%s]' % (res, stuff)
                     elif c == '{':
                         group = True
                         res += '(?:'
                     elif c == '}' and group:
                         res += ')'
                         group = False
                     elif c == ',' and group:
                         res += '|'
                     else:
                         res += re.escape(c)
                 return head + res + tail
             _globchars = {'[': 1, '{': 1, '*': 1, '?': 1}
             def pathto(n1, n2):
                 '''return the relative path from one place to another.
                 this returns a path in the form used by the local filesystem, not hg.'''
                 if not n1: return localpath(n2)
                 a, b = n1.split('/'), n2.split('/')
                 a.reverse(), b.reverse()
                 while a and b and a[-1] == b[-1]:
                     a.pop(), b.pop()
                 b.reverse()
                 return os.sep.join((['..'] * len(a)) + b)
             def canonpath(root, cwd, myname):
                 """return the canonical path of myname, given cwd and root"""
                 rootsep = root + os.sep
                 name = myname
                 if not name.startswith(os.sep):
                     name = os.path.join(root, cwd, name)
                 name = os.path.normpath(name)
                 if name.startswith(rootsep):
                     return pconvert(name[len(rootsep):])
                 elif name == root:
                     return ''
                 else:
                     raise Abort('%s not under root' % myname)
             def matcher(canonroot, cwd='', names=['.'], inc=[], exc=[], head=''):
                 """build a function to match a set of file patterns
                 arguments:
                 canonroot - the canonical root of the tree you're matching against
                 cwd - the current working directory, if relevant
                 names - patterns to find
                 inc - patterns to include
                 exc - patterns to exclude
                 head - a regex to prepend to patterns to control whether a match is rooted
                 a pattern is one of:
                 'glob:<rooted glob>'
                 're:<rooted regexp>'
                 'path:<rooted path>'
                 'relglob:<relative glob>'
                 'relpath:<relative path>'
                 'relre:<relative regexp>'
                 '<rooted path or regexp>'
                 returns:
                 a 3-tuple containing
                 - list of explicit non-pattern names passed in
                 - a bool match(filename) function
                 - a bool indicating if any patterns were passed in
                 todo:
                 make head regex a rooted bool
                 """
                 def patkind(name):
                     for prefix in 're', 'glob', 'path', 'relglob', 'relpath', 'relre':
                         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 == 'relglob':
                         return head + globre(name, '(?:|.*/)', tail)
                     elif kind == 'relpath':
                         return head + re.escape(name) + tail
                     elif kind == 'relre':
                         if name.startswith('^'):
                             return name
                         return '.*' + name
                     return head + globre(name, '', tail)
                 def matchfn(pats, tail):
                     """build a matching function from a set of patterns"""
                     if pats:
                         pat = '(?:%s)' % '|'.join([regex(k, p, tail) for (k, p) in pats])
                         return re.compile(pat).match
                 def globprefix(pat):
                     '''return the non-glob prefix of a path, e.g. foo/* -> foo'''
                     root = []
                     for p in pat.split(os.sep):
                         if patkind(p)[0] == 'glob': break
                         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 copyfiles(src, dst, hardlink=None):
                 """Copy a directory tree using hardlinks if possible"""
                 if hardlink is None:
                     hardlink = (os.stat(src).st_dev ==
                                 os.stat(os.path.dirname(dst)).st_dev)
                 if os.path.isdir(src):
                     os.mkdir(dst)
                     for name in os.listdir(src):
                         srcname = os.path.join(src, name)
                         dstname = os.path.join(dst, name)
                         copyfiles(srcname, dstname, hardlink)
                 else:
                     if hardlink:
                         try:
                             os_link(src, dst)
                         except:
                             hardlink = False
                             shutil.copy2(src, dst)
                     else:
                         shutil.copy2(src, dst)
             def opener(base):
                 """
                 return a function that opens files relative to base
                 this function is used to hide the details of COW semantics and
                 remote file access from higher level code.
                 """
                 p = base
                 def o(path, mode="r"):
                     f = os.path.join(p, path)
                     mode += "b" # for that other OS
                     if mode[0] != "r":
                         try:
                             nlink = nlinks(f)
                         except OSError:
                             d = os.path.dirname(f)
                             if not os.path.isdir(d):
                                 os.makedirs(d)
                         else:
                             if nlink > 1:
                                 file(f + ".tmp", "wb").write(file(f, "rb").read())
                                 rename(f+".tmp", f)
                     return file(f, mode)
                 return o
             def _makelock_file(info, pathname):
                 ld = os.open(pathname, os.O_CREAT | os.O_WRONLY | os.O_EXCL)
                 os.write(ld, info)
                 os.close(ld)
             def _readlock_file(pathname):
                 return file(pathname).read()
             def nlinks(pathname):
                 """Return number of hardlinks for the given file."""
                 return os.stat(pathname).st_nlink
             if hasattr(os, 'link'):
                 os_link = os.link
             else:
                 def os_link(src, dst):
                     raise OSError(0, "Hardlinks not supported")
             # Platform specific variants
             if os.name == 'nt':
                 nulldev = 'NUL:'
+                def parse_patch_output(output_line):
+                    """parses the output produced by patch and returns the file name"""
+                    pf = output_line[14:]
+                    if pf[0] == '`':
+                        pf = pf[1:-1] # Remove the quotes
+                    return pf
                 try: # ActivePython can create hard links using win32file module
                     import win32file
                     def os_link(src, dst): # NB will only succeed on NTFS
                         win32file.CreateHardLink(dst, src)
                     def nlinks(pathname):
                         """Return number of hardlinks for the given file."""
                         try:
                             fh = win32file.CreateFile(pathname,
                                 win32file.GENERIC_READ, win32file.FILE_SHARE_READ,
                                 None, win32file.OPEN_EXISTING, 0, None)
                             res = win32file.GetFileInformationByHandle(fh)
                             fh.Close()
                             return res[7]
                         except:
                             return os.stat(pathname).st_nlink
                 except ImportError:
                     pass
                 def is_exec(f, last):
                     return last
                 def set_exec(f, mode):
                     pass
                 def pconvert(path):
                     return path.replace("\\", "/")
                 def localpath(path):
                     return path.replace('/', '\\')
                 def normpath(path):
                     return pconvert(os.path.normpath(path))
                 makelock = _makelock_file
                 readlock = _readlock_file
                 def explain_exit(code):
                     return "exited with status %d" % code, code
             else:
                 nulldev = '/dev/null'
+                def parse_patch_output(output_line):
+                    """parses the output produced by patch and returns the file name"""
+                    return output_line[14:]
                 def is_exec(f, last):
                     """check whether a file is executable"""
                     return (os.stat(f).st_mode & 0100 != 0)
                 def set_exec(f, mode):
                     s = os.stat(f).st_mode
                     if (s & 0100 != 0) == mode:
                         return
                     if mode:
                         # Turn on +x for every +r bit when making a file executable
                         # and obey umask.
                         umask = os.umask(0)
                         os.umask(umask)
                         os.chmod(f, s | (s & 0444) >> 2 & ~umask)
                     else:
                         os.chmod(f, s & 0666)
                 def pconvert(path):
                     return path
                 def localpath(path):
                     return path
                 normpath = os.path.normpath
                 def makelock(info, pathname):
                     try:
                         os.symlink(info, pathname)
                     except OSError, why:
                         if why.errno == errno.EEXIST:
                             raise
                         else:
                             _makelock_file(info, pathname)
                 def readlock(pathname):
                     try:
                         return os.readlink(pathname)
                     except OSError, why:
                         if why.errno == errno.EINVAL:
                             return _readlock_file(pathname)
                         else:
                             raise
                 def explain_exit(code):
                     """return a 2-tuple (desc, code) describing a process's status"""
                     if os.WIFEXITED(code):
                         val = os.WEXITSTATUS(code)
                         return "exited with status %d" % val, val
                     elif os.WIFSIGNALED(code):
                         val = os.WTERMSIG(code)
                         return "killed by signal %d" % val, val
                     elif os.WIFSTOPPED(code):
                         val = os.WSTOPSIG(code)
                         return "stopped by signal %d" % val, val
                     raise ValueError("invalid exit code")
             class chunkbuffer(object):
                 """Allow arbitrary sized chunks of data to be efficiently read from an
                 iterator over chunks of arbitrary size."""
                 def __init__(self, in_iter, targetsize = 2**16):
                     """in_iter is the iterator that's iterating over the input chunks.
                     targetsize is how big a buffer to try to maintain."""
                     self.in_iter = iter(in_iter)
                     self.buf = ''
                     self.targetsize = int(targetsize)
                     if self.targetsize <= 0:
                         raise ValueError("targetsize must be greater than 0, was %d" %
                                          targetsize)
                     self.iterempty = False
                 def fillbuf(self):
                     """Ignore target size; read every chunk from iterator until empty."""
                     if not self.iterempty:
                         collector = cStringIO.StringIO()
                         collector.write(self.buf)
                         for ch in self.in_iter:
                             collector.write(ch)
                         self.buf = collector.getvalue()
                         self.iterempty = True
                 def read(self, l):
                     """Read L bytes of data from the iterator of chunks of data.
             	Returns less than L bytes if the iterator runs dry."""
                     if l > len(self.buf) and not self.iterempty:
                         # Clamp to a multiple of self.targetsize
                         targetsize = self.targetsize * ((l // self.targetsize) + 1)
                         collector = cStringIO.StringIO()
                         collector.write(self.buf)
                         collected = len(self.buf)
                         for chunk in self.in_iter:
                             collector.write(chunk)
                             collected += len(chunk)
                             if collected >= targetsize:
                                 break
                         if collected < targetsize:
                             self.iterempty = True
                         self.buf = collector.getvalue()
                     s, self.buf = self.buf[:l], buffer(self.buf, l)
                     return s
             def filechunkiter(f, size = 65536):
                 """Create a generator that produces all the data in the file size
                 (default 65536) bytes at a time.  Chunks may be less than size
                 bytes if the chunk is the last chunk in the file, or the file is a
                 socket or some other type of file that sometimes reads less data
                 than is requested."""
                 s = f.read(size)
                 while len(s) >= 0:
                     yield s
                     s = f.read(size)