Extract the validateToolchain function from the BToolchainPage in order to use it...

[bertos.git] / wizard / bertos_utils.py

diff --git a/wizard/bertos_utils.py b/wizard/bertos_utils.py
index 00b687d788c5510b97b830bfdf6e022faf990e8f..b57801a0fe6ef6db2658d510cc071d941ad35adb 100644 (file)
--- a/wizard/bertos_utils.py
+++ b/wizard/bertos_utils.py
@@ -45,6 +45,7 @@ import pickle
 import const
 import plugins
 import DefineException
+import BProject
 
 def isBertosDir(directory):
    return os.path.exists(directory + "/VERSION")
@@ -52,13 +53,57 @@ 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 projectFileGenerator(project_info):
+    directory = project_info.info("PROJECT_PATH")
+    project_data = {}
+    enabled_modules = []
+    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["CPU_NAME"] = project_info.info("CPU_NAME")
+    project_data["SELECTED_FREQ"] = project_info.info("SELECTED_FREQ")
+    return pickle.dumps(project_data)
+
 def createBertosProject(project_info):
     directory = project_info.info("PROJECT_PATH")
     sources_dir = project_info.info("SOURCES_PATH")
-    if not os.path.isdir(directory):
-        os.mkdir(directory)
+    if os.path.isdir(directory):
+        shutil.rmtree(directory, True)        
+    os.makedirs(directory)
     f = open(directory + "/project.bertos", "w")
-    f.write(pickle.dumps(project_info))
+    f.write(projectFileGenerator(project_info))
     f.close()
     # Destination source dir
     srcdir = directory + "/bertos"
@@ -313,6 +358,10 @@ def getToolchainInfo(output):
         info["thread"] = thread[0].split("Thread model: ")[1]
     return info
 
+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)
@@ -395,8 +444,7 @@ def loadModuleDefinition(first_comment):
             del module_definition["module_description"]
         if const.MODULE_DEFINITION["module_harvard"] in module_definition:
             harvard = module_definition[const.MODULE_DEFINITION["module_harvard"]]
-            if harvard == "both" or harvard == "pgm_memory":
-                module_dict[module_name]["harvard"] = harvard
+            module_dict[module_name]["harvard"] = harvard
             del module_definition[const.MODULE_DEFINITION["module_harvard"]]
         if const.MODULE_DEFINITION["module_hw"] in module_definition:
             hw = module_definition[const.MODULE_DEFINITION["module_hw"]]
@@ -497,7 +545,7 @@ def getDefinitionBlocks(text):
         block.append(([comment], define, start))
     return block
 
-def loadModuleData(project):
+def loadModuleData(project, edit=False):
     module_info_dict = {}
     list_info_dict = {}
     configuration_info_dict = {}
@@ -522,6 +570,14 @@ def loadModuleData(project):
                         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:
@@ -589,6 +645,11 @@ def loadConfigurationInfos(path):
         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"]
+    return def_conf
+
 def findParameterType(parameter):
     if "value_list" in parameter["informations"]:
         return "enum"
@@ -646,4 +707,4 @@ class ParseError(Exception):
 class SupportedException(Exception):
     def __init__(self, support_string):
         Exception.__init__(self)
-        self.support_string = support_string
\ No newline at end of file
+        self.support_string = support_string