X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=wizard%2Fbertos_utils.py;h=7be67fe10cdfcafb24b897cc4dc0ae8d36c22935;hb=HEAD;hp=b57801a0fe6ef6db2658d510cc071d941ad35adb;hpb=9b2a54e784f116cc9b4f770e1acbc15c4c5f013a;p=bertos.git

diff --git a/wizard/bertos_utils.py b/wizard/bertos_utils.py
index b57801a0..7be67fe1 100644
--- a/wizard/bertos_utils.py
+++ b/wizard/bertos_utils.py
@@ -28,7 +28,6 @@
 #
 # Copyright 2008 Develer S.r.l. (http://www.develer.com/)
 #
-# $Id$
 #
 # Author: Lorenzo Berni <duplo@develer.com>
 #
@@ -40,12 +39,25 @@ import re
 import shutil
 # Use custom copytree function
 import copytree
+import relpath
 import pickle
 
 import const
 import plugins
 import DefineException
-import BProject
+
+from _wizard_version import WIZARD_VERSION
+
+from LoadException import VersionException, ToolchainException
+
+def _cmp(x, y):
+    result = cmp(x["info"].get('ord', 0), y["info"].get('ord', 0))
+    if result == 0:
+        result = cmp(
+            x["info"].get("name", x["info"]["filename"]).lower(),
+            y["info"].get("name", y["info"]["filename"]).lower()
+        )
+    return result
 
 def isBertosDir(directory):
    return os.path.exists(directory + "/VERSION")
@@ -53,34 +65,51 @@ def isBertosDir(directory):
 def bertosVersion(directory):
    return open(directory + "/VERSION").readline().strip()
 
-def loadBertosProject(project_file):
-    project_data = pickle.loads(open(project_file, "r").read())
-    project_info = BProject.BProject()
-    project_info.setInfo("PROJECT_PATH", os.path.dirname(project_file))
-    project_info.setInfo("SOURCES_PATH", project_data["SOURCES_PATH"])
-    project_info.setInfo("TOOLCHAIN", project_data["TOOLCHAIN"])
-    loadSourceTree(project_info)
-    cpu_name = project_data["CPU_NAME"]
-    project_info.setInfo("CPU_NAME", cpu_name)
-    cpu_info = loadCpuInfos(project_info)
-    for cpu in cpu_info:
-        if cpu["CPU_NAME"] == cpu_name:
-            project_info.setInfo("CPU_INFOS", cpu)
-            break
-    tag_list = getTagSet(cpu_info)
-    # Create, fill and store the dict with the tags
-    tag_dict = {}
-    for element in tag_list:
-        tag_dict[element] = False
-    infos = project_info.info("CPU_INFOS")
-    for tag in tag_dict:
-        if tag in infos["CPU_TAGS"] + [infos["CPU_NAME"], infos["CORE_CPU"], infos["TOOLCHAIN"]]:
-            tag_dict[tag] = True
-        else:
-            tag_dict[tag] = False
-    project_info.setInfo("ALL_CPU_TAGS", tag_dict)
-    loadModuleData(project_info, True)
-    return project_info
+def enabledModules(project_info):
+    enabled_modules = []
+    for name, module in project_info.info("MODULES").items():
+        if module["enabled"]:
+            enabled_modules.append(name)
+    return enabled_modules
+
+def presetList(directory):
+    """
+    Return the list of the preset found in the selected BeRTOS Version.
+    """
+    abspath = os.path.join(directory, const.PREDEFINED_BOARDS_DIR)
+    preset_list = dict([
+        (os.path.join(abspath, preset_dir), presetInfo(os.path.join(abspath, preset_dir)))
+        for preset_dir in os.listdir(os.path.join(directory, const.PREDEFINED_BOARDS_DIR))
+    ])
+    return preset_list
+
+def presetInfo(preset_dir):
+    """
+    Return the preset-relevant info contined into the project_file.
+    """
+    preset_info = pickle.loads(open(os.path.join(preset_dir, "project.bertos"), "r").read())
+    try:
+        description = open(os.path.join(preset_dir, "description"), "r").read()
+    except IOError:
+        # No description file found.
+        description = ""
+    relevant_info = {
+        "CPU_NAME": preset_info.get("CPU_NAME"),
+        "SELECTED_FREQ": preset_info.get("SELECTED_FREQ"),
+        "WIZARD_VERSION": preset_info.get("WIZARD_VERSION", None),
+        "PRESET_NAME": preset_info.get("PROJECT_NAME"),
+        "PRESET_DESCRIPTION": description.decode("utf-8"),
+    }
+    return relevant_info
+
+def mergeSources(srcdir, new_sources, old_sources):
+    # The current mergeSources function provide only a raw copy of the sources in the
+    # created project.
+    #
+    # TODO: implement the three way merge algorithm
+    #
+    shutil.rmtree(srcdir, True)
+    copytree.copytree(os.path.join(new_sources, "bertos"), srcdir, ignore_list=const.IGNORE_LIST)
 
 def projectFileGenerator(project_info):
     directory = project_info.info("PROJECT_PATH")
@@ -89,126 +118,103 @@ def projectFileGenerator(project_info):
     for module, information in project_info.info("MODULES").items():
         if information["enabled"]:
             enabled_modules.append(module)
-    project_data["ENABLED_MODULES"] = enabled_modules
-    project_data["SOURCES_PATH"] = project_info.info("SOURCES_PATH")
-    project_data["TOOLCHAIN"] = project_info.info("TOOLCHAIN")
+    project_data["ENABLED_MODULES"] = sorted(enabled_modules)
+    if project_info.info("PRESET"):
+        # For presets save again the BERTOS_PATH into project file
+        project_data["PRESET"] = True
+        project_data["BERTOS_PATH"] = relpath.relpath(project_info.info("BERTOS_PATH"), directory)
+    elif project_info.edit:
+        # If in editing mode the BERTOS_PATH is maintained
+        project_data["BERTOS_PATH"] = relpath.relpath(project_info.info("BERTOS_PATH"), directory)
+    else:
+        # Use the local BeRTOS version instead of the original one
+        # project_data["BERTOS_PATH"] = project_info.info("BERTOS_PATH")
+        project_data["BERTOS_PATH"] = "."
+    project_data["PROJECT_NAME"] = project_info.info("PROJECT_NAME", os.path.basename(directory))
+    project_src_relpath = relpath.relpath(project_info.info("PROJECT_SRC_PATH"), directory)
+    project_data["PROJECT_SRC_PATH"] = project_src_relpath
+    project_data["PROJECT_SRC_PATH_FROM_MAKEFILE"] = project_info.info("PROJECT_SRC_PATH_FROM_MAKEFILE")
+    project_data["TOOLCHAIN"] = {'path': project_info.info("TOOLCHAIN")['path']}
     project_data["CPU_NAME"] = project_info.info("CPU_NAME")
     project_data["SELECTED_FREQ"] = project_info.info("SELECTED_FREQ")
+    project_data["OUTPUT"] = project_info.info("OUTPUT")
+    project_data["WIZARD_VERSION"] = WIZARD_VERSION
+    project_data["PRESET"] = project_info.info("PRESET")
+    project_data["PROJECT_HW_PATH"] = relpath.relpath(project_info.info("PROJECT_HW_PATH"), directory)
+    project_data["PROJECT_HW_PATH_FROM_MAKEFILE"] = project_info.info("PROJECT_HW_PATH_FROM_MAKEFILE")
     return pickle.dumps(project_data)
 
-def createBertosProject(project_info):
-    directory = project_info.info("PROJECT_PATH")
-    sources_dir = project_info.info("SOURCES_PATH")
-    if os.path.isdir(directory):
-        shutil.rmtree(directory, True)        
-    os.makedirs(directory)
-    f = open(directory + "/project.bertos", "w")
-    f.write(projectFileGenerator(project_info))
-    f.close()
-    # Destination source dir
-    srcdir = directory + "/bertos"
-    shutil.rmtree(srcdir, True)
-    copytree.copytree(sources_dir + "/bertos", srcdir, ignore_list=const.IGNORE_LIST)
-    # Destination makefile
-    makefile = directory + "/Makefile"
-    if os.path.exists(makefile):
-        os.remove(makefile)
-    makefile = open("mktemplates/Makefile").read()
-    makefile = makefileGenerator(project_info, makefile)
-    open(directory + "/Makefile", "w").write(makefile)
-    # Destination project dir
-    prjdir = directory + "/" + os.path.basename(directory)
-    shutil.rmtree(prjdir, True)
-    os.mkdir(prjdir)
-    # Destination hw files
-    hwdir = prjdir + "/hw"
-    shutil.rmtree(hwdir, True)
-    os.mkdir(hwdir)
-    # Copy all the hw files
-    for module, information in project_info.info("MODULES").items():
-        for hwfile in information["hw"]:
-            string = open(sources_dir + "/" + hwfile, "r").read()
-            open(hwdir + "/" + os.path.basename(hwfile), "w").write(string)
-    # Destination configurations files
-    cfgdir = prjdir + "/cfg"
-    shutil.rmtree(cfgdir, True)
-    os.mkdir(cfgdir)
-    # Set to 1 the autoenabled for enabled modules
-    for module, information in project_info.info("MODULES").items():
-        if information["enabled"] and "configuration" in information and information["configuration"] != "":
-            configurations = project_info.info("CONFIGURATIONS")
-            configuration = configurations[information["configuration"]]
-            for start, parameter in configuration["paramlist"]:
-                if "type" in configuration[parameter]["informations"] and configuration[parameter]["informations"]["type"] == "autoenabled":
-                    configuration[parameter]["value"] = "1"
-            project_info.setInfo("CONFIGURATIONS", configurations)
-    # Copy all the configuration files
-    for configuration, information in project_info.info("CONFIGURATIONS").items():
-        string = open(sources_dir + "/" + configuration, "r").read()
-        for start, parameter in information["paramlist"]:
-            infos = information[parameter]
-            value = infos["value"]
-            if "unsigned" in infos["informations"] and infos["informations"]["unsigned"]:
-                value += "U"
-            if "long" in infos["informations"] and infos["informations"]["long"]:
-                value += "L"
-            string = sub(string, parameter, value)
-        f = open(cfgdir + "/" + os.path.basename(configuration), "w")
-        f.write(string)
-        f.close()
-    # Destinatio mk file
-    makefile = open("mktemplates/template.mk", "r").read()
-    makefile = mkGenerator(project_info, makefile)
-    open(prjdir + "/" + os.path.basename(prjdir) + ".mk", "w").write(makefile)
-    # Destination main.c file
-    main = open("srctemplates/main.c", "r").read()
-    open(prjdir + "/main.c", "w").write(main)
-    # Files for selected plugins
-    relevants_files = {}
-    for plugin in project_info.info("OUTPUT"):
-        module = loadPlugin(plugin)
-        relevants_files[plugin] = module.createProject(project_info)
-    project_info.setInfo("RELEVANT_FILES", relevants_files)
-
 def loadPlugin(plugin):
     """
     Returns the given plugin module.
     """
     return getattr(__import__("plugins", {}, {}, [plugin]), plugin)
-    
-def mkGenerator(project_info, makefile):
+
+def versionFileGenerator(project_info, version_file):
+    version = bertosVersion(project_info.info("BERTOS_PATH"))
+    return version_file.replace('$version', version)
+
+def userMkGeneratorFromPreset(project_info):
+    project_name = project_info.info("PROJECT_NAME")
+    preset_path = project_info.info("PRESET_PATH")
+    preset_name = project_info.info("PRESET_NAME")
+    preset_src_dir = project_info.info("PRESET_SRC_PATH")
+    makefile = open(os.path.join(preset_path, preset_src_dir, "%s_user.mk" %preset_name), 'r').read()
+    destination = os.path.join(project_info.prjdir, "%s_user.mk" %project_info.info("PROJECT_NAME"))
+    # Temporary code.
+    # TODO: write it using regular expressions to secure this function
+    makefile = makefile.replace(preset_name + "_", project_name + "_")
+    open(destination, "w").write(makefile)
+
+def userMkGenerator(project_info):
+    makefile = open(os.path.join(const.DATA_DIR, "mktemplates/template_user.mk"), "r").read()
+    destination = os.path.join(project_info.prjdir, os.path.basename(project_info.prjdir) + "_user.mk")
+    # Deadly performances loss was here :(
+    mk_data = {}
+    mk_data["$pname"] = os.path.basename(project_info.info("PROJECT_PATH"))
+    mk_data["$ppath"] = project_info.info("PROJECT_SRC_PATH_FROM_MAKEFILE")
+    mk_data["$main"] = "/".join(["$(%s_SRC_PATH)" %project_info.info("PROJECT_NAME"), "main.c"])
+    for key in mk_data:
+        makefile = makefile.replace(key, mk_data[key])
+    open(destination, "w").write(makefile)
+
+def mkGenerator(project_info):
     """
     Generates the mk file for the current project.
     """
+    makefile = open(os.path.join(const.DATA_DIR, "mktemplates/template.mk"), "r").read()
+    prjdir = os.path.abspath(project_info.prjdir)
+    destination = os.path.join(prjdir, os.path.basename(prjdir) + ".mk")
     mk_data = {}
-    mk_data["$pname"] = os.path.basename(project_info.info("PROJECT_PATH"))
-    mk_data["$cpuflag"] = project_info.info("CPU_INFOS")["CPU_FLAG_NAME"]
-    mk_data["$cpuname"] = project_info.info("CPU_INFOS")["CORE_CPU"]
+    mk_data["$pname"] = project_info.info("PROJECT_NAME")
+    mk_data["$ppath"] = project_info.info("PROJECT_SRC_PATH_FROM_MAKEFILE")
     mk_data["$cpuclockfreq"] = project_info.info("SELECTED_FREQ")
-    mk_data["$cflags"] = " ".join(project_info.info("CPU_INFOS")["C_FLAGS"])
-    mk_data["$ldflags"] = " ".join(project_info.info("CPU_INFOS")["LD_FLAGS"])
-    mk_data["$cppflags"] = " ".join(project_info.info("CPU_INFOS")["CPP_FLAGS"])
-    mk_data["$cppaflags"] = " ".join(project_info.info("CPU_INFOS")["CPPA_FLAGS"])
-    mk_data["$cxxflags"] = " ".join(project_info.info("CPU_INFOS")["CXX_FLAGS"])
-    mk_data["$asflags"] = " ".join(project_info.info("CPU_INFOS")["AS_FLAGS"])
-    mk_data["$arflags"] = " ".join(project_info.info("CPU_INFOS")["AR_FLAGS"])
+    cpu_mk_parameters = []
+    for key, value in project_info.info("CPU_INFOS").items():
+        if key.startswith(const.MK_PARAM_ID):
+            cpu_mk_parameters.append("%s = %s" %(key.replace("MK", mk_data["$pname"]), value))
+    mk_data["$cpuparameters"] = "\n".join(cpu_mk_parameters)
     mk_data["$csrc"], mk_data["$pcsrc"], mk_data["$cppasrc"], mk_data["$cxxsrc"], mk_data["$asrc"], mk_data["$constants"] = csrcGenerator(project_info)
-    mk_data["$prefix"] = replaceSeparators(project_info.info("TOOLCHAIN")["path"].split("gcc")[0])
-    mk_data["$suffix"] = replaceSeparators(project_info.info("TOOLCHAIN")["path"].split("gcc")[1])
-    mk_data["$main"] = os.path.basename(project_info.info("PROJECT_PATH")) + "/main.c"
+    mk_data["$prefix"] = replaceSeparators(project_info.info("TOOLCHAIN")["path"].rsplit("gcc", 1)[0])
+    mk_data["$suffix"] = replaceSeparators(project_info.info("TOOLCHAIN")["path"].rsplit("gcc", 1)[1])
+    mk_data["$hwpath"] = project_info.info("PROJECT_HW_PATH_FROM_MAKEFILE")
     for key in mk_data:
-        while makefile.find(key) != -1:
-            makefile = makefile.replace(key, mk_data[key])
-    return makefile
+        makefile = makefile.replace(key, mk_data[key])
+    open(destination, "w").write(makefile)
 
-def makefileGenerator(project_info, makefile):
+def makefileGenerator(project_info):
     """
     Generate the Makefile for the current project.
     """
+    makefile = open(os.path.join(const.DATA_DIR, "mktemplates/Makefile"), "r").read()
+    destination = os.path.join(project_info.maindir, "Makefile")
     # TODO write a general function that works for both the mk file and the Makefile
-    while makefile.find("project_name") != -1:
-        makefile = makefile.replace("project_name", os.path.basename(project_info.info("PROJECT_PATH")))
-    return makefile
+    mk_data = {}
+    mk_data["$pname"] = project_info.info("PROJECT_NAME")
+    mk_data["$ppath"] = project_info.info("PROJECT_SRC_PATH_FROM_MAKEFILE")
+    for key in mk_data:
+        makefile = makefile.replace(key, mk_data[key])
+    open(destination, "w").write(makefile)
 
 def csrcGenerator(project_info):
     modules = project_info.info("MODULES")
@@ -234,7 +240,7 @@ def csrcGenerator(project_info):
         dependency_files = set([])
         # assembly sources
         asm_files = set([])
-        hwdir = os.path.basename(project_info.info("PROJECT_PATH")) + "/hw" 
+        hwdir = os.path.basename(project_info.info("PROJECT_PATH")) + "/hw"
         if information["enabled"]:
             if "constants" in information:
                 constants.update(information["constants"])
@@ -244,8 +250,7 @@ def csrcGenerator(project_info):
             for file in information["hw"]:
                 if file.endswith(".c"):
                     module_files |= set([hwdir + "/" + os.path.basename(file)])
-            for file_dependency in information["depends"]:
-                if file_dependency in files:
+            for file_dependency in information["depends"] + tuple(files.keys()):
                     dependencyCFiles, dependencySFiles = findModuleFiles(file_dependency, project_info)
                     dependency_files |= set(dependencyCFiles)
                     asm_files |= set(dependencySFiles)
@@ -268,12 +273,17 @@ def csrcGenerator(project_info):
         cxxsrc.append(file)
     for file in project_info.info("CPU_INFOS")["ASRC"]:
         asrc.append(file)
+    csrc = sorted(set(csrc))
     csrc = " \\\n\t".join(csrc) + " \\"
+    pcsrc = sorted(set(pcsrc))
     pcsrc = " \\\n\t".join(pcsrc) + " \\"
+    cppasrc = sorted(set(cppasrc))
     cppasrc = " \\\n\t".join(cppasrc) + " \\"
+    cxxsrc = sorted(set(cxxsrc))
     cxxsrc = " \\\n\t".join(cxxsrc) + " \\"
+    asrc = sorted(set(asrc))
     asrc = " \\\n\t".join(asrc) + " \\"
-    constants = "\n".join([os.path.basename(project_info.info("PROJECT_PATH")) + "_" + key + " = " + unicode(value) for key, value in constants.items()])
+    constants = "\n".join([project_info.info("PROJECT_NAME") + "_" + key + " = " + unicode(value) for key, value in constants.items()])
     return csrc, pcsrc, cppasrc, cxxsrc, asrc, constants
 
 def findModuleFiles(module, project_info):
@@ -281,29 +291,41 @@ def findModuleFiles(module, project_info):
     cfiles = []
     sfiles = []
     # .c files related to the module and the cpu architecture
-    for filename, path in findDefinitions(module + ".c", project_info) + \
-            findDefinitions(module + "_" + project_info.info("CPU_INFOS")["TOOLCHAIN"] + ".c", project_info):
-        path = path.replace(project_info.info("SOURCES_PATH") + os.sep, "")
+    for filename, path in project_info.searchFiles(module + ".c"):
+        path = path.replace(project_info.info("BERTOS_PATH") + os.sep, "")
         path = replaceSeparators(path)
         cfiles.append(path + "/" + filename)
     # .s files related to the module and the cpu architecture
-    for filename, path in findDefinitions(module + ".s", project_info) + \
-            findDefinitions(module + "_" + project_info.info("CPU_INFOS")["TOOLCHAIN"] + ".s", project_info) + \
-            findDefinitions(module + ".S", project_info) + \
-            findDefinitions(module + "_" + project_info.info("CPU_INFOS")["TOOLCHAIN"] + ".S", project_info):
-        path = path.replace(project_info.info("SOURCES_PATH") + os.sep, "")
+    for filename, path in project_info.searchFiles(module + ".s") + \
+            project_info.searchFiles(module + ".S"):
+        path = path.replace(project_info.info("BERTOS_PATH") + os.sep, "")
         path = replaceSeparators(path)
         sfiles.append(path + "/" + filename)
     # .c and .s files related to the module and the cpu tags
-    for tag in project_info.info("CPU_INFOS")["CPU_TAGS"]:
-        for filename, path in findDefinitions(module + "_" + tag + ".c", project_info):
-            path = path.replace(project_info.info("SOURCES_PATH") + os.sep, "")
+    tags = project_info.info("CPU_INFOS")["CPU_TAGS"]
+
+    # Awful, but secure check for version
+    # TODO: split me in a method/function
+    try:
+        version_string = bertosVersion(project_info.info("BERTOS_PATH"))
+        version_list = [int(i) for i in version_string.split()[1].split('.')]
+    except ValueError:
+        # If the version file hasn't a valid version number assume it's an older
+        # project.
+        version_list = [0, 0]
+    if version_list < [2, 5]:
+        # For older versions of BeRTOS add the toolchain to the tags
+        tags.append(project_info.info("CPU_INFOS")["TOOLCHAIN"])
+
+    for tag in tags:
+        for filename, path in project_info.searchFiles(module + "_" + tag + ".c"):
+            path = path.replace(project_info.info("BERTOS_PATH") + os.sep, "")
             if os.sep != "/":
                 path = replaceSeparators(path)
             cfiles.append(path + "/" + filename)
-        for filename, path in findDefinitions(module + "_" + tag + ".s", project_info) + \
-                findDefinitions(module + "_" + tag + ".S", project_info):
-            path = path.replace(project_info.info("SOURCES_PATH") + os.sep, "")
+        for filename, path in project_info.searchFiles(module + "_" + tag + ".s") + \
+                project_info.searchFiles(module + "_" + tag + ".S"):
+            path = path.replace(project_info.info("BERTOS_PATH") + os.sep, "")
             path = replaceSeparators(path)
             sfiles.append(path + "/" + filename)
     return cfiles, sfiles
@@ -313,23 +335,28 @@ def replaceSeparators(path):
     Replace the separators in the given path with unix standard separator.
     """
     if os.sep != "/":
-        while path.find(os.sep) != -1:
-            path = path.replace(os.sep, "/")
+        path = path.replace(os.sep, "/")
     return path
 
 def getSystemPath():
     path = os.environ["PATH"]
-    if os.name == "nt":
-        path = path.split(";")
-    else:
-        path = path.split(":")
+    path = path.split(os.pathsep)
     return path
 
+def findInPath(file, path=None):
+    if path is None:
+        path = os.environ.get('PATH', '')
+    if type(path) is type(''):
+        path = path.split(os.pathsep)
+    return filter(os.path.exists, map(lambda dir, file=file: os.path.join(dir, file), path))
+
+
 def findToolchains(path_list):
     toolchains = []
     for element in path_list:
         for toolchain in glob.glob(element+ "/" + const.GCC_NAME):
-            toolchains.append(toolchain)
+            if not os.path.isdir(toolchain):
+                toolchains.append(toolchain)
     return list(set(toolchains))
 
 def getToolchainInfo(output):
@@ -362,34 +389,14 @@ def getToolchainName(toolchain_info):
     name = "GCC " + toolchain_info["version"] + " - " + toolchain_info["target"].strip()
     return name
 
-def loadSourceTree(project):
-    fileList = [f for f in os.walk(project.info("SOURCES_PATH"))]
-    project.setInfo("FILE_LIST", fileList)
-
-def findDefinitions(ftype, project):
-    L = project.info("FILE_LIST")
-    definitions = []
-    for element in L:
-        for filename in element[2]:
-            if fnmatch.fnmatch(filename, ftype):
-                definitions.append((filename, element[0]))
-    return definitions
-
-def loadCpuInfos(project):
-    cpuInfos = []
-    for definition in findDefinitions(const.CPU_DEFINITION, project):
-        cpuInfos.append(getInfos(definition))
-    return cpuInfos
-
 def getTagSet(cpu_info):
     tag_set = set([])
     for cpu in cpu_info:
         tag_set |= set([cpu["CPU_NAME"]])
         tag_set |= set(cpu["CPU_TAGS"])
-        tag_set |= set([cpu["CORE_CPU"]])
         tag_set |= set([cpu["TOOLCHAIN"]])
     return tag_set
-        
+
 
 def getInfos(definition):
     D = {}
@@ -545,59 +552,6 @@ def getDefinitionBlocks(text):
         block.append(([comment], define, start))
     return block
 
-def loadModuleData(project, edit=False):
-    module_info_dict = {}
-    list_info_dict = {}
-    configuration_info_dict = {}
-    file_dict = {}
-    for filename, path in findDefinitions("*.h", project) + findDefinitions("*.c", project) + findDefinitions("*.s", project) + findDefinitions("*.S", project):
-        comment_list = getCommentList(open(path + "/" + filename, "r").read())
-        if len(comment_list) > 0:
-            module_info = {}
-            configuration_info = {}
-            try:
-                to_be_parsed, module_dict = loadModuleDefinition(comment_list[0])
-            except ParseError, err:
-                raise DefineException.ModuleDefineException(path, err.line_number, err.line)
-            for module, information in module_dict.items():
-                if "depends" not in information:
-                    information["depends"] = ()
-                information["depends"] += (filename.split(".")[0],)
-                information["category"] = os.path.basename(path)
-                if "configuration" in information and len(information["configuration"]):
-                    configuration = module_dict[module]["configuration"]
-                    try:
-                        configuration_info[configuration] = loadConfigurationInfos(project.info("SOURCES_PATH") + "/" + configuration)
-                    except ParseError, err:
-                        raise DefineException.ConfigurationDefineException(project.info("SOURCES_PATH") + "/" + configuration, err.line_number, err.line)
-                    if edit:
-                        try:
-                            path = os.path.basename(project.info("PROJECT_PATH"))
-                            directory = project.info("PROJECT_PATH")
-                            user_configuration = loadConfigurationInfos(directory + "/" + configuration.replace("bertos", path))
-                            configuration_info[configuration] = updateConfigurationValues(configuration_info[configuration], user_configuration)
-                        except ParseError, err:
-                            raise DefineException.ConfigurationDefineException(directory + "/" + configuration.replace("bertos", path))
-            module_info_dict.update(module_dict)
-            configuration_info_dict.update(configuration_info)
-            if to_be_parsed:
-                try:
-                    list_dict = loadDefineLists(comment_list[1:])
-                    list_info_dict.update(list_dict)
-                except ParseError, err:
-                    raise DefineException.EnumDefineException(path, err.line_number, err.line)
-    for filename, path in findDefinitions("*_" + project.info("CPU_INFOS")["TOOLCHAIN"] + ".h", project):
-        comment_list = getCommentList(open(path + "/" + filename, "r").read())
-        list_info_dict.update(loadDefineLists(comment_list))
-    for tag in project.info("CPU_INFOS")["CPU_TAGS"]:
-        for filename, path in findDefinitions("*_" + tag + ".h", project):
-            comment_list = getCommentList(open(path + "/" + filename, "r").read())
-            list_info_dict.update(loadDefineLists(comment_list))
-    project.setInfo("MODULES", module_info_dict)
-    project.setInfo("LISTS", list_info_dict)
-    project.setInfo("CONFIGURATIONS", configuration_info_dict)
-    project.setInfo("FILES", file_dict)
-
 def formatParamNameValue(text):
     """
     Take the given string and return a tuple with the name of the parameter in the first position
@@ -619,6 +573,7 @@ def loadConfigurationInfos(path):
             "long": boolean indicating if the num is a long
             "unsigned": boolean indicating if the num is an unsigned
             "value_list": the name of the enum for enum parameters
+            "conditional_deps": the list of conditional dependencies for boolean parameters
     """
     configuration_infos = {}
     configuration_infos["paramlist"] = []
@@ -641,13 +596,22 @@ def loadConfigurationInfos(path):
                 configuration_infos[name]["value"].find("U") != -1):
             configuration_infos[name]["informations"]["unsigned"] = True
             configuration_infos[name]["value"] = configuration_infos[name]["value"].replace("U", "")
+        if "conditional_deps" in configuration_infos[name]["informations"]:
+            if (type(configuration_infos[name]["informations"]["conditional_deps"]) == str or
+                    type(configuration_infos[name]["informations"]["conditional_deps"]) == unicode):
+                configuration_infos[name]["informations"]["conditional_deps"] = (configuration_infos[name]["informations"]["conditional_deps"], )
+            elif type(configuration_infos[name]["informations"]["conditional_deps"]) == tuple:
+                pass
+            else:
+                configuration_infos[name]["informations"]["conditional_deps"] = ()
         configuration_infos[name]["description"] = description
         configuration_infos[name]["brief"] = brief
     return configuration_infos
 
 def updateConfigurationValues(def_conf, user_conf):
     for param in def_conf["paramlist"]:
-        def_conf[param[1]]["value"] = user_conf[param[1]]["value"]
+        if param[1] in user_conf and "value" in user_conf[param[1]]:
+            def_conf[param[1]]["value"] = user_conf[param[1]]["value"]
     return def_conf
 
 def findParameterType(parameter):