示例#1
0
def get_all_webkitdom_symbol_files():
    static_symbol_files_path = common.top_level_path('Source', 'WebCore',
                                                     'bindings', 'gobject')
    generated_symbol_files_path = common.build_path('DerivedSources',
                                                    'webkitdom')

    symbol_files = []
    for header_name in header_name_list_from_gtkdoc_config_file():
        # webkitdomdefines.h doesn't have a corresponding symbols file and webkitdom.symbols is a
        # file containing the expected symbols results.
        if header_name in ("webkitdom.h", "webkitdomdefines.h"):
            continue

        symbol_file = header_name.replace(".h", ".symbols")
        path = os.path.join(static_symbol_files_path, symbol_file)
        if os.path.exists(path):
            symbol_files.append(path)
            continue
        path = os.path.join(generated_symbol_files_path, symbol_file)
        if os.path.exists(path):
            symbol_files.append(path)
            continue
        sys.stderr.write("Could not find symbol file for header: %s\n" %
                         header_name)
        sys.exit(1)

    return symbol_files
示例#2
0
def write_doc_files():
    doc_dir = common.build_path('DerivedSources', 'webkitdom', 'docs')

    try:
        os.mkdir(doc_dir)
    except OSError, e:
        if e.errno != errno.EEXIST or not os.path.isdir(doc_dir):
            sys.stderr.write("Could not create doc dir at %s: %s\n" % (doc_dir, str(e)))
            sys.exit(1)
示例#3
0
def write_doc_files(module_name):
    doc_dir = common.build_path('DerivedSources', 'webkitdom', 'docs')

    try:
        os.mkdir(doc_dir)
    except OSError, e:
        if e.errno != errno.EEXIST or not os.path.isdir(doc_dir):
            sys.stderr.write("Could not create doc dir at %s: %s\n" %
                             (doc_dir, str(e)))
            sys.exit(1)
示例#4
0
def header_name_list_from_gtkdoc_config_file():
    config_file = common.build_path('gtkdoc-webkitdom.cfg')
    if not os.path.isfile(config_file):
        sys.stderr.write("Could not find config file at %s\n" % config_file)
        return sys.exit(1)

    config = SafeConfigParser()
    config.read(config_file)
    module_name = config.sections()[0]
    return [os.path.basename(f) for f in str(config.get(module_name, 'headers')).replace(';', ' ').split()]
示例#5
0
def header_name_list_from_gtkdoc_config_file():
    config_file = common.build_path('gtkdoc-webkitdom.cfg')
    if not os.path.isfile(config_file):
        sys.stderr.write("Could not find config file at %s\n" % config_file)
        return sys.exit(1)

    config = SafeConfigParser()
    config.read(config_file)
    module_name = config.sections()[0]
    return [
        os.path.basename(f) for f in str(config.get(
            module_name, 'headers')).replace(';', ' ').split()
    ]
示例#6
0
def write_doc_files():
    doc_dir = common.build_path('DerivedSources', 'webkitdom', 'docs')

    try:
        os.mkdir(doc_dir)
    except:
        pass  # Commonly happens if the directory already exists.

    with open(os.path.join(doc_dir, 'webkitdomgtk-sections.txt'), 'w') as sections_file:
        generator = WebKitDOMDocGeneratorSections(get_all_webkitdom_symbol_files(), sections_file)
        generator.generate()
    with open(os.path.join(doc_dir, 'webkitdomgtk-docs.sgml'), 'w') as sgml_file:
        generator = WebKitDOMDocGeneratorSGML(get_all_webkitdom_symbol_files(), sgml_file)
        generator.generate()
示例#7
0
def build_part(part):
    install_dir = part.install_path()
    source_dir = part.source_path()
    build_dir = part.build_path()

    if part.gconfig.clean_build:
        remove_dir(build_dir)

    # copy tree: source -> build
    if not os.path.exists(build_dir):
        shutil.copytree(source_dir, build_dir)
        part.set_build_state("CLEAN")
    else:
        print_warn("Part '{}' has ever been built,".format(part.name),
                   "in order to perform a clean build, use --clean-build")

    remove_dir(install_dir)

    # get module parameters and put them in 'module_params'
    var_name_prefix = part.build + "-"
    prefix_len = len(var_name_prefix)
    module_params = dict(
        (k[prefix_len:], v) for k, v in part.doc.iteritems()
        if len(k) > prefix_len and k[:prefix_len] == var_name_prefix)

    env = {
        "BUILD_ROOT": build_path(part.gconfig),
        "INSTALL_ROOT": install_path(part.gconfig),
        "BUILD_DIR": build_dir,
        "INSTALL_DIR": install_dir
    }

    # do the build prepare
    os.chdir(build_dir)
    build_prepare(part, env)

    # do the make main
    os.chdir(build_dir)
    if build_override(part, env) is False:
        part.build_module.build(part, module_params, env.copy())
    part.set_build_state("BUILT")

    # do the make install
    os.chdir(build_dir)
    create_dir(install_dir)
    if install_override(part, env) is False:
        part.build_module.install(part, module_params, env.copy())
    part.set_build_state("INSTALLED")
示例#8
0
def write_doc_files():
    doc_dir = common.build_path('DerivedSources', 'webkitdom', 'docs')

    try:
        os.mkdir(doc_dir)
    except:
        pass  # Commonly happens if the directory already exists.

    with open(os.path.join(doc_dir, 'webkitdomgtk-sections.txt'),
              'w') as sections_file:
        generator = WebKitDOMDocGeneratorSections(
            get_all_webkitdom_symbol_files(), sections_file)
        generator.generate()
    with open(os.path.join(doc_dir, 'webkitdomgtk-docs.sgml'),
              'w') as sgml_file:
        generator = WebKitDOMDocGeneratorSGML(get_all_webkitdom_symbol_files(),
                                              sgml_file)
        generator.generate()
示例#9
0
def get_all_webkitdom_symbol_files():
    static_symbol_files_path = common.top_level_path('Source', 'WebCore', 'bindings', 'gobject')
    generated_symbol_files_path = common.build_path('DerivedSources', 'webkitdom')

    symbol_files = []
    for header_name in header_name_list_from_gtkdoc_config_file():
        # webkitdomdefines.h doesn't have a corresponding symbols file and webkitdom.symbols is a
        # file containing the expected symbols results.
        if header_name in ("webkitdom.h", "webkitdomdefines.h"):
            continue

        symbol_file = header_name.replace(".h", ".symbols")
        path = os.path.join(static_symbol_files_path, symbol_file)
        if os.path.exists(path):
            symbol_files.append(path)
            continue
        path = os.path.join(generated_symbol_files_path, symbol_file)
        if os.path.exists(path):
            symbol_files.append(path)
            continue

    return symbol_files
示例#10
0
文件: iddfs.py 项目: mbaiges/sia-tp1
def iddfs(level, n, testall):
    initial_time = datetime.now()

    smap = level.smap

    first_node = Node(level.start, None, [], 0)

    deque = []

    #metemos al nodo inicial en la cola
    deque.append(first_node)
    known_nodes = HashTable()

    known_nodes.put(first_node.config, first_node)

    nodes_processed = 0

    # curr_n = n

    # mientras que la cola tenga elementos y no gane
    won = False

    limit_nodes_per_n = []
    limit_nodes_per_n_size = 0

    while deque and not won:

        # saco el primer nodo del stack
        node = deque.pop()

        # if node in processed:
        #     l = list(processed)
        #     idx = l.index(node)

        #     if idx >= 0 and idx < len(l):
        #         proc_node = l[idx]
        #         if node.depth >= proc_node.depth:
        #             pase = True
        #             continue
        #     else:
        #         continue

        # primero me fijo si gane
        if (finished(node.config.boxes, level)):
            # si gane listo
            won = True
        else:
            nodes_processed += 1

            # si no gane pido mis movimientos legales
            possible_configs = next_configs(node.config, level.smap)
            children = node.children

            if (node.depth + 1) % n == 0:
                children_at_limit = True
            else:
                children_at_limit = False

            for config in possible_configs:
                proc_node = known_nodes.get(config)

                if proc_node and node.depth + 1 >= proc_node.depth:
                    continue

                new_node = Node(copy.copy(config), node, [], node.depth + 1)

                known_nodes.put(config, new_node)

                children.append(new_node)

                if children_at_limit:
                    limit_idx = int(new_node.depth / n) - 1
                    if len(limit_nodes_per_n) < limit_idx + 1:
                        limit_nodes_per_n.append(0)
                    limit_nodes_per_n[limit_idx] += 1

                    deque.insert(0, new_node)
                else:
                    deque.append(new_node)

                # print("Added move: ", new_node.config)

            # print("Used configs: ", processed)
            # print("deque is: ", deque)

    finish_time = datetime.now()

    elapsed_time = finish_time - initial_time

    #print(limit_nodes_per_n)

    if won:
        path = build_path(node)
        return process_results(won, testall, elapsed_time, smap, node, path,
                               f"{ALGORITHM_NAME} (n='{n}')",
                               nodes_processed - 1, len(deque))
    else:
        return process_results(won, testall, elapsed_time, smap, None, [],
                               f"{ALGORITHM_NAME} (n='{n}')",
                               nodes_processed - 1, len(deque))
示例#11
0
def idastar(level, heu, testall):
    h=heu["func"]
    initial_time = datetime.now()

    smap = level.smap

    first_node = Node(level.start, None, [], 0, {'g': 0, 'h': h(smap, level.goals, level.start)})

    lim = first_node.meta['g'] + first_node.meta['h'] # f(n0)

    min_exceeded_lim = -1

    def cp(e1, e2):
        g1 = e1.meta['g']
        g2 = e2.meta['g']
        h1 = e1.meta['h']
        h2 = e2.meta['h']

        f1 = g1 + h1
        f2 = g2 + h2
        
        if f1 == f2:
            return h1 - h2
        else:
            return f1 - f2

    q1 = []
    q2 = []

    out_of_frontier = OrderedList(cp)

    q1.append(first_node)
    known_nodes = HashTable()

    known_nodes.put(first_node.config, first_node)

    nodes_processed = 0

    won = False

    first_found = False

    while (q1 or q2) and not won:

        if not q1:
            q1 = q2
            q2 = []
            lim = min_exceeded_lim
            min_exceeded_lim = -1

        node = q1.pop()

        f = node.meta['g'] + node.meta['h']

        if f > lim:
            q2.append(node)
            continue

        if(finished(node.config.boxes, level)):
            won = True
        else:
            nodes_processed += 1
            possible_configs = next_configs(node.config, level.smap)

            children = node.children
            
            for config in possible_configs:

                proc_node = known_nodes.get(config)

                if proc_node and node.depth + 1 >= proc_node.depth:
                    continue

                new_node = Node(copy.copy(config), node, [], node.depth + 1, {'g': node.depth + 1, 'h': h(smap, level.goals, config)})

                known_nodes.put(config, new_node)  

                children.append(new_node)

                f = new_node.meta['g'] + new_node.meta['h']

                if f > lim:
                    q2.append(new_node) 
                    if min_exceeded_lim == -1 or f < min_exceeded_lim:
                        min_exceeded_lim = f
                else:
                    q1.append(new_node)     
                

    finish_time = datetime.now()

    elapsed_time = finish_time - initial_time

    if won:
        path = build_path(node)
        return process_results(won, testall, elapsed_time, smap, node, path, f"{ALGORITHM_NAME} ({heu['name']})", nodes_processed - 1, len(q1) + len(q2))
    else:
        return process_results(won, testall, elapsed_time, smap, None, [], f"{ALGORITHM_NAME} ({heu['name']})", nodes_processed - 1, len(q1) + len(q2))
示例#12
0
def dfs(level, testall):
    initial_time = datetime.now()

    smap = level.smap

    first_node = Node(level.start, None, [])

    stack = []

    #metemos al nodo inicial en la cola

    stack.append(first_node)
    known_cfgs = set()

    known_cfgs.add(first_node.config)

    nodes_processed = 0

    # mientras que la cola tenga elementos y no gane

    won = False

    while stack and not won:

        # saco el primer nodo del stack
        node = stack.pop()
        # print('ITERATION: ', nodes_processed, ' --------------------------------------------------------------')

        # print("Current node: ", node.config)

        # primero me fijo si gane
        if (finished(node.config.boxes, level)):
            # si gane listo
            # print("Found solution!")
            won = True
        else:
            nodes_processed += 1

            # si no gane pido mis movimientos legales
            possible_configs = next_configs(node.config, level.smap)
            # print("Possible configs: ", possible_configs)

            children = node.children

            #por cada movimiento legal me fijo si ya tube esta config antes y si no la apendeo a la cola
            # print("Procesed: ===>", processed)
            for config in possible_configs:

                if config in known_cfgs:
                    continue

                known_cfgs.add(config)

                new_node = Node(copy.copy(config), node, [])
                children.append(new_node)
                stack.append(new_node)
                # print("Added move: ", new_node.config)

            # print("Used configs: ", processed)
            # print("Stack is: ", stack)

    finish_time = datetime.now()

    elapsed_time = finish_time - initial_time

    if won:
        path = build_path(node)
        return process_results(won, testall, elapsed_time, smap, node, path,
                               ALGORITHM_NAME, nodes_processed - 1, len(stack))
    else:
        return process_results(won, testall, elapsed_time, smap, None, [],
                               ALGORITHM_NAME, nodes_processed - 1, len(stack))
示例#13
0
 def build_state_path(self):
     return os.path.join(build_path(self.gconfig), ".state." + self.name)
示例#14
0
 def build_path(self):
     return os.path.join(build_path(self.gconfig), self.name)
示例#15
0
文件: astar.py 项目: mbaiges/sia-tp1
def astar(level, heu, testall):

    h = heu["func"]

    initial_time = datetime.now()

    smap = level.smap

    first_node = Node(level.start, None, [], 0, {
        'g': 0,
        'h': h(smap, level.goals, level.start)
    })

    def cp(e1, e2):
        g1 = e1.meta['g']
        g2 = e2.meta['g']
        h1 = e1.meta['h']
        h2 = e2.meta['h']

        f1 = g1 + h1
        f2 = g2 + h2

        if f1 == f2:
            return h1 - h2
        else:
            return f1 - f2

    nodes_list = OrderedList(cp)

    nodes_list.add(first_node)

    #known_cfgs = set()
    known_nodes = HashTable()

    #known_cfgs.add(first_node.config)
    known_nodes.put(first_node.config, first_node)

    nodes_processed = 0

    won = False

    while nodes_list.length() > 0 and not won:

        node = nodes_list.pop()

        if (finished(node.config.boxes, level)):
            won = True
        else:
            nodes_processed += 1

            possible_configs = next_configs(node.config, level.smap)

            children = node.children

            for config in possible_configs:

                proc_node = known_nodes.get(config)
                new_node = Node(copy.copy(config), node, [], node.depth + 1, {
                    'g': node.depth + 1,
                    'h': h(smap, level.goals, config)
                })

                if proc_node:
                    new_node_f = new_node.meta['g'] + new_node.meta['h']
                    proc_node_f = proc_node.meta['g'] + proc_node.meta['h']

                    if (new_node_f >= proc_node_f):
                        continue

                # if config in known_cfgs:
                #     continue

                #known_cfgs.add(config)
                known_nodes.put(config, new_node)

                children.append(new_node)
                nodes_list.add(new_node)

    finish_time = datetime.now()

    elapsed_time = finish_time - initial_time

    if won:
        path = build_path(node)
        return process_results(won, testall, elapsed_time, smap, node, path,
                               f"{ALGORITHM_NAME} ({heu['name']})",
                               nodes_processed - 1, nodes_list.length())
    else:
        return process_results(won, testall, elapsed_time, smap, None, [],
                               f"{ALGORITHM_NAME} ({heu['name']})",
                               nodes_processed - 1, nodes_list.length())
示例#16
0
def ggs(level, heu, testall):

    h = heu["func"]

    initial_time = datetime.now()

    smap = level.smap

    first_node = Node(level.start, None, [], 0,
                      {'h': h(smap, level.goals, level.start)})

    def cp(e1, e2):
        return e1.meta['h'] - e2.meta['h']

    nodes_list = OrderedList(cp)

    #metemos al nodo inicial en la cola ( ͡° ͜ʖ ͡°)

    nodes_list.add(first_node)
    known_cfgs = set()

    known_cfgs.add(first_node.config)

    nodes_processed = 0

    # mientras que la cola tenga elementos y no gane

    won = False

    while nodes_list.length() > 0 and not won:

        # saco el primer nodo del nodes_list
        node = nodes_list.pop()
        # print('ITERATION: ', nodes_processed, ' --------------------------------------------------------------')

        # print("Current node: ", node.config)

        # primero me fijo si gane
        if (finished(node.config.boxes, level)):
            # si gane listo
            # print("Found solution!")
            won = True
        else:
            nodes_processed += 1

            # si no gane pido mis movimientos legales
            possible_configs = next_configs(node.config, level.smap)
            # print("Possible configs: ", possible_configs)

            children = node.children

            #por cada movimiento legal me fijo si ya tube esta config antes y si no la apendeo a la cola
            # print("Procesed: ===>", processed)
            for config in possible_configs:

                if config in known_cfgs:
                    continue

                known_cfgs.add(config)

                new_node = Node(copy.copy(config), node, [], node.depth + 1,
                                {'h': h(smap, level.goals, config)})
                children.append(new_node)
                nodes_list.add(new_node)
                # print("Added move: ", new_node.config)

            # print("Used configs: ", processed)
            # print("Stack is: ", stack)

    finish_time = datetime.now()

    elapsed_time = finish_time - initial_time

    if won:
        path = build_path(node)
        return process_results(won, testall, elapsed_time, smap, node, path,
                               f"{ALGORITHM_NAME} ({heu['name']})",
                               nodes_processed - 1, nodes_list.length())
    else:
        return process_results(won, testall, elapsed_time, smap, None, [],
                               f"{ALGORITHM_NAME} ({heu['name']})",
                               nodes_processed - 1, nodes_list.length())