X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=wizard%2Fbertos_utils.py;h=d3e7127eed4dbab8b40feeace72193e83f297630;hb=695e044f1387440a718abf42a79800e785f71c7f;hp=fc225d0a4ebf5e7e331a024c2a1bb1fdd9d17210;hpb=50f6a053718d917970b9ff56f81056761254ffd4;p=bertos.git

diff --git a/wizard/bertos_utils.py b/wizard/bertos_utils.py
index fc225d0a..d3e7127e 100644
--- a/wizard/bertos_utils.py
+++ b/wizard/bertos_utils.py
@@ -13,6 +13,7 @@ import os
 import fnmatch
 import glob
 import re
+import shutil
 
 import const
 
@@ -22,10 +23,41 @@ def isBertosDir(directory):
 def bertosVersion(directory):
    return open(directory + "/VERSION").readline().strip()
 
-def createBertosProject(directory):
+def createBertosProject(projectInfos):
+    directory = projectInfos.info("PROJECT_PATH")
+    sourcesDir = projectInfos.info("SOURCES_PATH")
     if not os.path.isdir(directory):
         os.mkdir(directory)
-    open(directory + "/project.bertos", "w")
+    f = open(directory + "/project.bertos", "w")
+    f.write(repr(projectInfos))
+    f.close()
+    ## Destination source dir
+    srcdir = directory + "/bertos"
+    shutil.rmtree(srcdir, True)
+    shutil.copytree(sourcesDir + "/bertos", srcdir)
+    ## Destination makefile
+    makefile = directory + "/Makefile"
+    if os.path.exists(makefile):
+        os.remove(makefile)
+    shutil.copy(sourcesDir + "/Makefile", makefile)
+    ## Destination project dir
+    prjdir = directory + "/" + os.path.basename(directory)
+    shutil.rmtree(prjdir, True)
+    os.mkdir(prjdir)
+    ## Destination configurations files
+    cfgdir = prjdir + "/cfg"
+    shutil.rmtree(cfgdir, True)
+    os.mkdir(cfgdir)
+    for key, value in projectInfos.info("CONFIGURATIONS").items():
+        string = open(sourcesDir + "/" + key, "r").read()
+        for parameter, infos in value.items():
+            value = infos["value"]
+            if "long" in infos["informations"].keys() and infos["informations"]["long"]:
+                value += "L"
+            string = sub(string, parameter, value)
+        f = open(cfgdir + "/" + os.path.basename(key), "w")
+        f.write(string)
+        f.close()
 
 def getSystemPath():
     path = os.environ["PATH"]
@@ -95,9 +127,122 @@ def getInfos(definition):
     return D
 
 def getDefinitionBlocks(text):
+    """
+    Take a text and return a list of tuple (description, name-value).
+    """
     block = []
-    block_tmp = re.findall("^/\*+\s*(.*?)\s*?\*/\s*#define\s+(\w+[\s\w]*?)\s*$", text, re.DOTALL | re.MULTILINE)
+    block_tmp = re.findall(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/\s*#define\s+((?:[^/]*?/?)+)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE)
     for comment, define in block_tmp:
-        block.append((" ".join(re.findall("^\s*\*?\s*(.*?)\s*?$", comment, re.MULTILINE)), define))
-    block += re.findall("/{3}<?\s*(.*)\s*#define\s+(.*)\s*?$", text, re.MULTILINE)
-    return block
\ No newline at end of file
+        block.append((" ".join(re.findall(r"^\s*\*?\s*(.*?)\s*?(?:/{2}.*?)?$", comment, re.MULTILINE)).strip(), define))
+    block += re.findall(r"/{3}\s*([^<].*?)\s*#define\s+((?:[^/]*?/?)+)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE)
+    block += [(comment, define) for define, comment in re.findall(r"#define\s*(.*?)\s*/{3}<\s*(.+?)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE)]
+    return block
+
+def formatParamNameValue(text):
+    """
+    Take the given string and return a tuple with the name of the parameter in the first position
+    and the value in the second.
+    """
+    block = re.findall("\s*([^\s]+)\s*(.+?)\s*$", text, re.MULTILINE)
+    return block[0]
+
+def getDescriptionInformations(text): 
+    """ 
+    Take the doxygen comment and strip the wizard informations, returning the tuple 
+    (comment, wizard_informations) 
+    """ 
+    index = text.find("$WIZARD") 
+    if index != -1: 
+        exec(text[index + 1:]) 
+        informations = WIZARD 
+        return text[:index].strip(), informations
+    else:
+        return text.strip(), {}
+
+def loadConfigurationInfos(path):
+    """
+    Return the module configurations found in the given file as a dict with the
+    parameter name as key and a dict containig the fields above as value:
+        "value": the value of the parameter
+        "description": the description of the parameter
+        "informations": a dict containig optional informations:
+            "type": "int" | "boolean" | "enum"
+            "min": the minimum value for integer parameters
+            "max": the maximum value for integer parameters
+            "long": boolean indicating if the num is a long
+            "value_list": the name of the enum for enum parameters
+    """
+    configurationInfos = {}
+    for comment, define in getDefinitionBlocks(open(path, "r").read()):
+        name, value = formatParamNameValue(define)
+        description, informations = getDescriptionInformations(comment)
+        configurationInfos[name] = {}
+        configurationInfos[name]["value"] = value
+        configurationInfos[name]["informations"] = informations
+        configurationInfos[name]["description"] = description
+    return configurationInfos
+
+def loadModuleInfos(path):
+    """
+    Return the module infos found in the given file as a dict with the module
+    name as key and a dict containig the fields above as value or an empty dict
+    if the given file is not a BeRTOS module:
+        "depends": a list of modules needed by this module
+        "configuration": the cfg_*.h with the module configurations
+        "description": a string containing the brief description of doxygen
+        "enabled": contains False but the wizard will change if the user select
+        the module
+    """
+    moduleInfos = {}
+    string = open(path, "r").read()
+    commentList = re.findall(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/", string)
+    commentList = [" ".join(re.findall(r"^\s*\*?\s*(.*?)\s*?(?:/{2}.*?)?$", comment, re.MULTILINE)).strip() for comment in commentList]
+    for comment in commentList:
+        index = comment.find("$WIZARD_MODULE")
+        if index != -1:
+            exec(comment[index + 1:])
+            moduleInfos[WIZARD_MODULE["name"]] = {"depends": WIZARD_MODULE["depends"],
+                                                    "configuration": WIZARD_MODULE["configuration"],
+                                                    "description": "",
+                                                    "enabled": False}
+            return moduleInfos
+    return {}
+
+def loadModuleInfosDict(path):
+    """
+    Return the dict containig all the modules
+    """
+    moduleInfosDict = {}
+    for filename, path in findDefinitions("*.h", path):
+        moduleInfosDict.update(loadModuleInfos(path + "/" + filename))
+    return moduleInfosDict
+
+def loadDefineLists(path):
+    """
+    Return a dict with the name of the list as key and a list of string as value
+    """
+    string = open(path, "r").read()
+    commentList = re.findall(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/", string)
+    commentList = [" ".join(re.findall(r"^\s*\*?\s*(.*?)\s*?(?:/{2}.*?)?$", comment, re.MULTILINE)).strip() for comment in commentList]
+    listDict = {}
+    for comment in commentList:
+        index = comment.find("$WIZARD_LIST")
+        if index != -1:
+            exec(comment[index + 1:])
+            listDict.update(WIZARD_LIST)
+    return listDict
+
+def loadDefineListsDict(path):
+    """
+    Return the dict containing all the define lists
+    """
+    defineListsDict = {}
+    for filename, path in findDefinitions("*.h", path):
+        defineListsDict.update(loadDefineLists(path + "/" + filename))
+    return defineListsDict
+
+def sub(string, parameter, value):
+    """
+    Substitute the given value at the given parameter define in the given string
+    """
+    return re.sub(r"(?P<define>#define\s+" + parameter + r"\s+)([^\s]+)", r"\g<define>" + value, string)