3136 

  3137 def findpossible(ui, cmd):

  3138     """

  3139     Return cmd -> (aliases, command table entry)

  3140     for each matching command.

  3141     Return debug commands (or their aliases) only if no normal command matches.

  3142     """

  3143     choice = {}

  3144     debugchoice = {}

  3145     for e in table.keys():

  3146         aliases = e.lstrip("^").split("|")

  3147         found = None

  3148         if cmd in aliases:

  3149             found = cmd

  3150         elif not ui.config("ui", "strict"):

  3151             for a in aliases:

  3152                 if a.startswith(cmd):

  3153                     found = a

  3154                     break

  3155         if found is not None:

  3156             if aliases[0].startswith("debug") or found.startswith("debug"):

  3157                 debugchoice[found] = (aliases, table[e])

  3158             else:

  3159                 choice[found] = (aliases, table[e])

  3160 

  3161     if not choice and debugchoice:

  3162         choice = debugchoice

  3163 

  3164     return choice

  3165 

  3166 def findcmd(ui, cmd):

  3167     """Return (aliases, command table entry) for command string."""

  3168     choice = findpossible(ui, cmd)

  3169 

  3170     if choice.has_key(cmd):

  3171         return choice[cmd]

  3172 

  3173     if len(choice) > 1:

  3174         clist = choice.keys()

  3175         clist.sort()

  3176         raise AmbiguousCommand(cmd, clist)

  3177 

  3178     if choice:

  3179         return choice.values()[0]

  3180 

  3181     raise UnknownCommand(cmd)

  3182 

  3183 class ParseError(Exception):

  3184     """Exception raised on errors in parsing the command line."""

  3185 

  3186 def parse(ui, args):

  3187     options = {}

  3188     cmdoptions = {}

  3189 

  3190     try:

  3191         args = fancyopts.fancyopts(args, globalopts, options)

  3192     except fancyopts.getopt.GetoptError, inst:

  3193         raise ParseError(None, inst)

  3194 

  3195     if args:

  3196         cmd, args = args[0], args[1:]

  3197         aliases, i = findcmd(ui, cmd)

  3198         cmd = aliases[0]

  3199         defaults = ui.config("defaults", cmd)

  3200         if defaults:

  3201             args = shlex.split(defaults) + args

  3202         c = list(i[1])

  3203     else:

  3204         cmd = None

  3205         c = []

  3206 

  3207     # combine global options into local

  3208     for o in globalopts:

  3209         c.append((o[0], o[1], options[o[1]], o[3]))

  3210 

  3211     try:

  3212         args = fancyopts.fancyopts(args, c, cmdoptions)

  3213     except fancyopts.getopt.GetoptError, inst:

  3214         raise ParseError(cmd, inst)

  3215 

  3216     # separate global options back out

  3217     for o in globalopts:

  3218         n = o[1]

  3219         options[n] = cmdoptions[n]

  3220         del cmdoptions[n]

  3221 

  3222     return (cmd, cmd and i[0] or None, args, options, cmdoptions)

  3223 

  3224 def parseconfig(config):

  3225     """parse the --config options from the command line"""

  3226     parsed = []

  3227     for cfg in config:

  3228         try:

  3229             name, value = cfg.split('=', 1)

  3230             section, name = name.split('.', 1)

  3231             if not section or not name:

  3232                 raise IndexError

  3233             parsed.append((section, name, value))

  3234         except (IndexError, ValueError):

  3235             raise util.Abort(_('malformed --config option: %s') % cfg)

  3236     return parsed

  3237 

  3238 def dispatch(u, args):

  3239     extensions.loadall(u)

  3240     u.addreadhook(extensions.loadall)

  3241 

  3242     try:

  3243         cmd, func, args, options, cmdoptions = parse(u, args)

  3244         if options["encoding"]:

  3245             util._encoding = options["encoding"]

  3246         if options["encodingmode"]:

  3247             util._encodingmode = options["encodingmode"]

  3248         if options["time"]:

  3249             def get_times():

  3250                 t = os.times()

  3251                 if t[4] == 0.0: # Windows leaves this as zero, so use time.clock()

  3252                     t = (t[0], t[1], t[2], t[3], time.clock())

  3253                 return t

  3254             s = get_times()

  3255             def print_time():

  3256                 t = get_times()

  3257                 u.warn(_("Time: real %.3f secs (user %.3f+%.3f sys %.3f+%.3f)\n") %

  3258                     (t[4]-s[4], t[0]-s[0], t[2]-s[2], t[1]-s[1], t[3]-s[3]))

  3259             atexit.register(print_time)

  3260 

  3261         # enter the debugger before command execution

  3262         if options['debugger']:

  3263             pdb.set_trace()

  3264 

  3265         try:

  3266             if options['cwd']:

  3267                 os.chdir(options['cwd'])

  3268 

  3269             u.updateopts(options["verbose"], options["debug"], options["quiet"],

  3270                          not options["noninteractive"], options["traceback"],

  3271                          parseconfig(options["config"]))

  3272 

  3273             path = u.expandpath(options["repository"]) or ""

  3274             repo = path and hg.repository(u, path=path) or None

  3275             if repo and not repo.local():

  3276                 raise util.Abort(_("repository '%s' is not local") % path)

  3277 

  3278             if options['help']:

  3279                 return help_(u, cmd, options['version'])

  3280             elif options['version']:

  3281                 return version_(u)

  3282             elif not cmd:

  3283                 return help_(u, 'shortlist')

  3284 

  3285             if cmd not in norepo.split():

  3286                 try:

  3287                     if not repo:

  3288                         repo = hg.repository(u, path=path)

  3289                     u = repo.ui

  3290                 except hg.RepoError:

  3291                     if cmd not in optionalrepo.split():

  3292                         raise

  3293                 d = lambda: func(u, repo, *args, **cmdoptions)

  3294             else:

  3295                 d = lambda: func(u, *args, **cmdoptions)

  3296 

  3297             try:

  3298                 if options['profile']:

  3299                     import hotshot, hotshot.stats

  3300                     prof = hotshot.Profile("hg.prof")

  3301                     try:

  3302                         try:

  3303                             return prof.runcall(d)

  3304                         except:

  3305                             try:

  3306                                 u.warn(_('exception raised - generating '

  3307                                          'profile anyway\n'))

  3308                             except:

  3309                                 pass

  3310                             raise

  3311                     finally:

  3312                         prof.close()

  3313                         stats = hotshot.stats.load("hg.prof")

  3314                         stats.strip_dirs()

  3315                         stats.sort_stats('time', 'calls')

  3316                         stats.print_stats(40)

  3317                 elif options['lsprof']:

  3318                     try:

  3319                         from mercurial import lsprof

  3320                     except ImportError:

  3321                         raise util.Abort(_(

  3322                             'lsprof not available - install from '

  3323                             'http://codespeak.net/svn/user/arigo/hack/misc/lsprof/'))

  3324                     p = lsprof.Profiler()

  3325                     p.enable(subcalls=True)

  3326                     try:

  3327                         return d()

  3328                     finally:

  3329                         p.disable()

  3330                         stats = lsprof.Stats(p.getstats())

  3331                         stats.sort()

  3332                         stats.pprint(top=10, file=sys.stderr, climit=5)

  3333                 else:

  3334                     return d()

  3335             finally:

  3336                 u.flush()

  3337         except:

  3338             # enter the debugger when we hit an exception

  3339             if options['debugger']:

  3340                 pdb.post_mortem(sys.exc_info()[2])

  3341             u.print_exc()

  3342             raise

  3343     except ParseError, inst:

  3344         if inst.args[0]:

  3345             u.warn(_("hg %s: %s\n") % (inst.args[0], inst.args[1]))

  3346             help_(u, inst.args[0])

  3347         else:

  3348             u.warn(_("hg: %s\n") % inst.args[1])

  3349             help_(u, 'shortlist')

  3350     except AmbiguousCommand, inst:

  3351         u.warn(_("hg: command '%s' is ambiguous:\n    %s\n") %

  3352                 (inst.args[0], " ".join(inst.args[1])))

  3353     except UnknownCommand, inst:

  3354         u.warn(_("hg: unknown command '%s'\n") % inst.args[0])

  3355         help_(u, 'shortlist')