Exemple #1
0
def make_cmdline_overview(descr, title=True):
    content = Rest()
    if title:
        content.add(
            Title("Overview of Command Line Options for '%s'" %
                  (descr._name, ),
                  abovechar="=",
                  belowchar="="))
    cmdlines = []
    config = Config(descr)
    for path in config.getpaths(include_groups=False):
        subconf, step = config._cfgimpl_get_home_by_path(path)
        fullpath = (descr._name + "." + path)
        subdescr = getattr(subconf._cfgimpl_descr, step)
        cmdline = get_cmdline(subdescr.cmdline, fullpath)
        if cmdline is not None:
            header = _get_section_header(cmdline, fullpath, subdescr)
            cmdlines.append((header, cmdline, fullpath, subdescr))
    cmdlines.sort(key=lambda x: (x[0], x[1].strip("-")))
    currheader = ""
    curr = content
    for header, cmdline, fullpath, subdescr in cmdlines:
        if header != currheader:
            content.add(Title(header, abovechar="", belowchar="="))
            curr = content.add(Paragraph())
            currheader = header
        curr.add(
            ListItem(Link(cmdline + ":", fullpath + ".html"),
                     Text(subdescr.doc)))
    return content
Exemple #2
0
def get_combined_translation_config(other_optdescr=None,
                                    existing_config=None,
                                    overrides=None,
                                    translating=False):
    if overrides is None:
        overrides = {}
    d = BoolOption("translating",
                   "indicates whether we are translating currently",
                   default=False,
                   cmdline=None)
    if other_optdescr is None:
        children = []
        newname = ""
    else:
        children = [other_optdescr]
        newname = other_optdescr._name
    if existing_config is None:
        children += [d, translation_optiondescription]
    else:
        children += [
            child for child in existing_config._cfgimpl_descr._children
            if child._name != newname
        ]
    descr = OptionDescription("pypy", "all options", children)
    config = Config(descr, **overrides)
    if translating:
        config.translating = True
    if existing_config is not None:
        for child in existing_config._cfgimpl_descr._children:
            if child._name == newname:
                continue
            value = getattr(existing_config, child._name)
            config._cfgimpl_values[child._name] = value
    return config
Exemple #3
0
 def get_content(self, txtpath, encoding):
     if txtpath.basename == "commandline.rst":
         result = []
         for line in txtpath.read().splitlines():
             if line.startswith('.. GENERATE:'):
                 start = line[len('.. GENERATE:'):].strip()
                 descr = start_to_descr[start]
                 line = make_cmdline_overview(descr, title=False).text()
             result.append(line)
         return "\n".join(result)
     fullpath = txtpath.purebasename
     start = fullpath.split(".")[0]
     path = fullpath.rsplit(".", 1)[0]
     basedescr = start_to_descr.get(start)
     if basedescr is None:
         return txtpath.read()
     if fullpath.count(".") == 0:
         descr = basedescr
         path = ""
     else:
         conf = Config(basedescr)
         subconf, step = conf._cfgimpl_get_home_by_path(
             fullpath.split(".", 1)[1])
         descr = getattr(subconf._cfgimpl_descr, step)
     text = unicode(descr.make_rest_doc(path).text())
     if txtpath.check(file=True):
         content = txtpath.read()
         if content:
             text += "\nDescription\n==========="
             return u"%s\n\n%s" % (text, unicode(txtpath.read(), encoding))
     return text
Exemple #4
0
def test_check_documentation():
    def check_file_exists(fn):
        assert configdocdir.join(fn).check()

    from pypy.doc.config.generate import all_optiondescrs
    configdocdir = thisdir.dirpath().dirpath().join("doc", "config")
    for descr in all_optiondescrs:
        prefix = descr._name
        c = Config(descr)
        for path in c.getpaths(include_groups=True):
            fn = prefix + "." + path + ".txt"
            yield fn, check_file_exists, fn
Exemple #5
0
def main_(argv=None):
    starttime = time.time()
    config, parser = option.get_standard_options()
    interactiveconfig = Config(cmdline_optiondescr)
    to_optparse(interactiveconfig, parser=parser)

    def set_family_of_options(option, opt, value, parser):
        from pypy.config.pypyoption import set_pypy_opt_level
        set_pypy_opt_level(config, value)

    parser.add_option('--cc',
                      type=str,
                      action="callback",
                      callback=set_compiler,
                      help="Compiler to use for compiling generated C")
    parser.add_option(
        '--opt',
        type=str,
        action="callback",
        callback=set_family_of_options,
        help="Set the family of options based on -opt=0,1,2,jit...")
    args = option.process_options(parser, argv[1:])
    if interactiveconfig.verbose:
        error.RECORD_INTERPLEVEL_TRACEBACK = True
    # --allworkingmodules takes really long to start up, but can be forced on
    config.objspace.suggest(allworkingmodules=False)
    config.objspace.usemodules.struct = True
    if config.objspace.allworkingmodules:
        pypyoption.enable_allworkingmodules(config)
    if config.objspace.usemodules._continuation:
        config.translation.continuation = True
    if config.objspace.usemodules.thread:
        config.translation.thread = True

    # create the object space

    space = option.make_objspace(config)

    space._starttime = starttime
    space.setitem(space.sys.w_dict, space.wrap('executable'),
                  space.wrap(argv[0]))

    if interactiveconfig.optimize:
        #change the optimize flag's value and set __debug__ to False
        space.appexec([], """():
            import sys
            flags = list(sys.flags)
            flags[3] = 2
            sys.flags = type(sys.flags)(flags)
            __builtins__.__dict__['__debug__'] = False
        """)

    # call pypy_find_stdlib: the side-effect is that it sets sys.prefix and
    # sys.exec_prefix
    executable = argv[0]
    space.appexec([space.wrap(executable)], """(executable):
        import sys
        sys.pypy_find_stdlib(executable)
    """)

    # set warning control options (if any)
    warn_arg = interactiveconfig.warn
    if warn_arg is not None:
        space.appexec([space.wrap(warn_arg)], """(arg):
        import sys
        sys.warnoptions.append(arg)""")

    w_path = space.sys.get('path')
    path = os.getenv('PYTHONPATH')
    if path:
        path = path.split(os.pathsep)
    else:
        path = []
    path.insert(0, '')
    for i, dir in enumerate(path):
        space.call_method(w_path, 'insert', space.wrap(i), space.wrap(dir))

    # store the command-line arguments into sys.argv
    go_interactive = interactiveconfig.interactive
    banner = ''
    exit_status = 0
    command = None
    if interactiveconfig.runcommand:
        command = args[0]
        args[0] = '-c'
    if interactiveconfig.runmodule:
        command = args.pop(0)
    for arg in args:
        space.call_method(space.sys.get('argv'), 'append',
                          space.newfilename(arg))

    # load the source of the program given as command-line argument
    if interactiveconfig.runcommand:

        def doit():
            main.run_string(command, space=space)
    elif interactiveconfig.runmodule:

        def doit():
            main.run_module(command, args, space=space)
    elif args:
        scriptdir = os.path.dirname(os.path.abspath(args[0]))
        space.call_method(space.sys.get('path'), 'insert', space.wrap(0),
                          space.wrap(scriptdir))

        def doit():
            main.run_file(args[0], space=space)
    else:

        def doit():
            pass

        space.call_method(space.sys.get('argv'), 'append', space.wrap(''))
        go_interactive = 1
        banner = None

    try:

        def do_start():
            space.startup()
            pypy_init(space, space.wrap(not interactiveconfig.no_site_import))

        if main.run_toplevel(space,
                             do_start,
                             verbose=interactiveconfig.verbose):
            # compile and run it
            if not main.run_toplevel(
                    space, doit, verbose=interactiveconfig.verbose):
                exit_status = 1

            # start the interactive console
            if go_interactive or os.getenv('PYTHONINSPECT'):
                try:
                    import readline
                except:
                    pass
                con = interactive.PyPyConsole(
                    space,
                    verbose=interactiveconfig.verbose,
                    completer=interactiveconfig.completer)
                if banner == '':
                    banner = '%s / %s' % (con.__class__.__name__, repr(space))
                con.interact(banner)
                exit_status = 0
    finally:

        def doit():
            space.finish()

        main.run_toplevel(space, doit, verbose=interactiveconfig.verbose)

    return exit_status
Exemple #6
0
            default=False,
            cmdline="--withext-%s" % extname
        ) for extname in OPTIONAL_EXTS]

hippy_optiondescription = OptionDescription("optexts",
    "Optional extensions", optexts_descriptions)

# You need this top-level container when calling Config ctor directly.
# You don't need this is the target because the opt parser does this part.
top_hippy_optiondescription = \
        OptionDescription("hippy", "all options", [
            BoolOption("translating", "Are we translating?", default=False),
            hippy_optiondescription])


OPTIONS = Config(top_hippy_optiondescription) # default config


def set_options(config):
    import sys
    thismod = sys.modules[__name__]
    setattr(thismod, "OPTIONS", config)


def enable_all_optional_extensions():
    for extname in OPTIONAL_EXTS:
        setattr(OPTIONS.optexts, extname, True)


@specialize.memo()
def is_optional_extension_enabled(extname):
Exemple #7
0
def parse_options_and_load_target():
    opt_parser = optparse.OptionParser(
        usage="%prog [options] [target] [target-specific-options]",
        prog="translate",
        formatter=OptHelpFormatter(),
        add_help_option=False)

    opt_parser.disable_interspersed_args()

    config = get_combined_translation_config(translating=True)
    to_optparse(config, parser=opt_parser, useoptions=['translation.*'])
    translateconfig = Config(translate_optiondescr)
    to_optparse(translateconfig, parser=opt_parser)

    options, args = opt_parser.parse_args()

    # set goals and skipped_goals
    reset = False
    for name, _, _, _ in GOALS:
        if name.startswith('?'):
            continue
        if getattr(translateconfig.goal_options, name):
            if name not in translateconfig.goals:
                translateconfig.goals.append(name)
        if getattr(translateconfig.goal_options, 'no_' + name):
            if name not in translateconfig.skipped_goals:
                if not reset:
                    translateconfig.skipped_goals[:] = []
                    reset = True
                translateconfig.skipped_goals.append(name)

    if args:
        arg = args[0]
        args = args[1:]
        if os.path.isfile(arg + '.py'):
            assert not os.path.isfile(arg), (
                "ambiguous file naming, please rename %s" % arg)
            translateconfig.targetspec = arg
        elif os.path.isfile(arg) and arg.endswith('.py'):
            translateconfig.targetspec = arg[:-3]
        else:
            log.ERROR("Could not find target %r" % (arg, ))
            sys.exit(1)
    else:
        show_help(translateconfig, opt_parser, None, config)

    # print the version of the host
    # (if it's PyPy, it includes the hg checksum)
    log.info(sys.version)

    # apply the platform settings
    set_platform(config)

    targetspec = translateconfig.targetspec
    targetspec_dic = load_target(targetspec)

    if args and not targetspec_dic.get('take_options', False):
        log.WARNING(
            "target specific arguments supplied but will be ignored: %s" %
            ' '.join(args))

    # give the target the possibility to get its own configuration options
    # into the config
    if 'get_additional_config_options' in targetspec_dic:
        optiondescr = targetspec_dic['get_additional_config_options']()
        config = get_combined_translation_config(optiondescr,
                                                 existing_config=config,
                                                 translating=True)

    # show the target-specific help if --help was given
    show_help(translateconfig, opt_parser, targetspec_dic, config)

    # apply the optimization level settings
    set_opt_level(config, translateconfig.opt)

    # let the target modify or prepare itself
    # based on the config
    if 'handle_config' in targetspec_dic:
        targetspec_dic['handle_config'](config, translateconfig)

    return targetspec_dic, translateconfig, config, args