X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=wizard%2Fbertos_utils.py;h=cfaf2a7fd631f4f0a18f3c0f4f5d662c4845fac9;hb=d685c5f413bd6cbd5f00c35da830a9a93ff943f1;hp=925774ba387fefe0761b66364763fb40c9a8bc9d;hpb=9d4807e10b3ffccbee160aab1b67b13779cf6766;p=bertos.git

diff --git a/wizard/bertos_utils.py b/wizard/bertos_utils.py
index 925774ba..cfaf2a7f 100644
--- a/wizard/bertos_utils.py
+++ b/wizard/bertos_utils.py
@@ -24,13 +24,13 @@ def isBertosDir(directory):
 def bertosVersion(directory):
    return open(directory + "/VERSION").readline().strip()
 
-def createBertosProject(projectInfos):
-    directory = projectInfos.info("PROJECT_PATH")
-    sourcesDir = projectInfos.info("SOURCES_PATH")
+def createBertosProject(projectInfo):
+    directory = projectInfo.info("PROJECT_PATH")
+    sourcesDir = projectInfo.info("SOURCES_PATH")
     if not os.path.isdir(directory):
         os.mkdir(directory)
     f = open(directory + "/project.bertos", "w")
-    f.write(repr(projectInfos))
+    f.write(repr(projectInfo))
     f.close()
     ## Destination source dir
     srcdir = directory + "/bertos"
@@ -41,7 +41,7 @@ def createBertosProject(projectInfos):
     if os.path.exists(makefile):
         os.remove(makefile)
     makefile = open("mktemplates/Makefile").read()
-    makefile = makefileGenerator(projectInfos, makefile)
+    makefile = makefileGenerator(projectInfo, makefile)
     open(directory + "/Makefile", "w").write(makefile)
     ## Destination project dir
     prjdir = directory + "/" + os.path.basename(directory)
@@ -51,7 +51,7 @@ def createBertosProject(projectInfos):
     cfgdir = prjdir + "/cfg"
     shutil.rmtree(cfgdir, True)
     os.mkdir(cfgdir)
-    for key, value in projectInfos.info("CONFIGURATIONS").items():
+    for key, value in projectInfo.info("CONFIGURATIONS").items():
         string = open(sourcesDir + "/" + key, "r").read()
         for parameter, infos in value.items():
             value = infos["value"]
@@ -65,32 +65,48 @@ def createBertosProject(projectInfos):
         f.close()
     ## Destinatio mk file
     makefile = open("mktemplates/template.mk", "r").read()
-    makefile = mkGenerator(projectInfos, makefile)
+    makefile = mkGenerator(projectInfo, makefile)
     open(prjdir + "/" + os.path.basename(prjdir) + ".mk", "w").write(makefile)
 
-def mkGenerator(projectInfos, makefile):
+def mkGenerator(projectInfo, makefile):
     """
     Generates the mk file for the current project.
     """
     mkData = {}
-    mkData["pname"] = os.path.basename(projectInfos.info("PROJECT_PATH"))
-    mkData["cpuname"] = projectInfos.info("CPU_INFOS")["CPU_NAME"]
-    mkData["cflags"] = " ".join(projectInfos.info("CPU_INFOS")["C_FLAGS"])
-    mkData["ldflags"] = " ".join(projectInfos.info("CPU_INFOS")["LD_FLAGS"])
+    mkData["$pname"] = os.path.basename(projectInfo.info("PROJECT_PATH"))
+    mkData["$cpuname"] = projectInfo.info("CPU_INFOS")["CPU_NAME"]
+    mkData["$cflags"] = " ".join(projectInfo.info("CPU_INFOS")["C_FLAGS"])
+    mkData["$ldflags"] = " ".join(projectInfo.info("CPU_INFOS")["LD_FLAGS"])
+    mkData["$csrc"] = csrcGenerator(projectInfo)
     for key in mkData:
         while makefile.find(key) != -1:
             makefile = makefile.replace(key, mkData[key])
     return makefile
 
-def makefileGenerator(projectInfos, makefile):
+def makefileGenerator(projectInfo, makefile):
     """
     Generate the Makefile for the current project.
     """
     # 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(projectInfos.info("PROJECT_PATH")))
+        makefile = makefile.replace("project_name", os.path.basename(projectInfo.info("PROJECT_PATH")))
     return makefile
 
+def csrcGenerator(projectInfo):
+    modules = projectInfo.info("MODULES")
+    files = []
+    for module, information in modules.items():
+        if information["enabled"]:
+            for filename, path in findDefinitions(module + ".c", projectInfo):
+                files.append(path + "/" + filename)
+            for filename, path in findDefinitions(module + "_" + projectInfo.info("CPU_INFOS")["TOOLCHAIN"] + ".c", projectInfo):
+                files.append(path + "/" + filename)
+            for tag in projectInfo.info("CPU_INFOS")["CPU_TAGS"]:
+                for filename, path in findDefinitions(module + "_" + tag + ".c", projectInfo):
+                    files.append(path + "/" + filename)
+    csrc = " \\\n\t".join(files)
+    return csrc
+    
 def getSystemPath():
     path = os.environ["PATH"]
     if os.name == "nt":
@@ -133,16 +149,22 @@ def getToolchainInfo(output):
         info["thread"] = thread[0].split("Thread model: ")[1]
     return info
 
-def findDefinitions(ftype, path):
-    L = os.walk(path)
+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):
-                yield (filename, element[0])
+                definitions.append((filename, element[0]))
+    return definitions
 
-def loadCpuInfos(path):
+def loadCpuInfos(project):
     cpuInfos = []
-    for definition in findDefinitions(const.CPU_DEFINITION, path):
+    for definition in findDefinitions(const.CPU_DEFINITION, project):
         cpuInfos.append(getInfos(definition))
     return cpuInfos
 
@@ -158,6 +180,84 @@ def getInfos(definition):
     del D["include"]
     return D
 
+def getCommentList(string):
+    commentList = re.findall(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/", string)
+    commentList = [re.findall(r"^\s*\* *(.*?)$", comment, re.MULTILINE) for comment in commentList]
+    return commentList
+
+def loadModuleDefinition(first_comment):
+    toBeParsed = False
+    moduleDefinition = {}
+    for num, line in enumerate(first_comment):
+        index = line.find("$WIZ$")
+        if index != -1:
+            toBeParsed = True
+            try:
+                exec line[index + len("$WIZ$ "):] in {}, moduleDefinition
+            except:
+                raise ParseError(num, line[index:])
+        elif line.find("\\brief") != -1:
+            moduleDefinition["module_description"] = line[line.find("\\brief") + len("\\brief "):]
+    moduleDict = {}
+    if "module_name" in moduleDefinition.keys():
+        moduleDict[moduleDefinition["module_name"]] = {}
+        if "module_depends" in moduleDefinition.keys():
+            if type(moduleDefinition["module_depends"]) == str:
+                moduleDefinition["module_depends"] = (moduleDefinition["module_depends"],)
+            moduleDict[moduleDefinition["module_name"]]["depends"] = moduleDefinition["module_depends"]
+        else:
+            moduleDict[moduleDefinition["module_name"]]["depends"] = ()
+        if "module_configuration" in moduleDefinition.keys():
+            moduleDict[moduleDefinition["module_name"]]["configuration"] = moduleDefinition["module_configuration"]
+        else:
+            moduleDict[moduleDefinition["module_name"]]["configuration"] = ""
+        if "module_description" in moduleDefinition.keys():
+            moduleDict[moduleDefinition["module_name"]]["description"] = moduleDefinition["module_description"]
+        moduleDict[moduleDefinition["module_name"]]["enabled"] = False
+    return toBeParsed, moduleDict
+
+def loadDefineLists(commentList):
+    defineList = {}
+    for comment in commentList:
+        for num, line in enumerate(comment):
+            index = line.find("$WIZ$")
+            if index != -1:
+                try:
+                    exec line[index + len("$WIZ$ "):] in {}, defineList
+                except:
+                    raise ParseError(num, line[index:])
+    for key, value in defineList.items():
+        if type(value) == str:
+            defineList[key] = (value,)
+    return defineList
+
+def getDescriptionInformations(comment): 
+    """ 
+    Take the doxygen comment and strip the wizard informations, returning the tuple 
+    (comment, wizard_information) 
+    """
+    brief = ""
+    description = ""
+    information = {}
+    for num, line in enumerate(comment):
+        index = line.find("$WIZ$")
+        if index != -1:
+            if len(brief) == 0:
+                brief += line[:index].strip()
+            else:
+                description += " " + line[:index]
+            try:
+                exec line[index + len("$WIZ$ "):] in {}, information
+            except:
+                raise ParseError(num, line[index:])
+        else:
+            if len(brief) == 0:
+                brief += line.strip()
+            else:
+                description += " " + line
+                description = description.strip()
+    return brief.strip(), description.strip(), information
+
 def getDefinitionBlocks(text):
     """
     Take a text and return a list of tuple (description, name-value).
@@ -165,11 +265,53 @@ def getDefinitionBlocks(text):
     block = []
     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(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)]
+        # Only the first element is needed
+        block.append(([re.findall(r"^\s*\* *(.*?)$", line, re.MULTILINE)[0] for line in comment.splitlines()], define))
+    for comment, define in re.findall(r"/{3}\s*([^<].*?)\s*#define\s+((?:[^/]*?/?)+)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE):
+        block.append(([comment], define))
+    for define, comment in re.findall(r"#define\s*(.*?)\s*/{3}<\s*(.+?)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE):
+        block.append(([comment], define))
     return block
 
+def loadModuleData(project):
+    moduleInfoDict = {}
+    listInfoDict = {}
+    configurationInfoDict = {}
+    for filename, path in findDefinitions("*.h", project):
+        commentList = getCommentList(open(path + "/" + filename, "r").read())
+        if len(commentList) > 0:
+            moduleInfo = {}
+            configurationInfo = {}
+            try:
+                toBeParsed, moduleDict = loadModuleDefinition(commentList[0])
+            except ParseError, err:
+                raise DefineException.ModuleDefineException(path, err.line_number, err.line)
+            for module, information in moduleDict.items():
+                if "configuration" in information.keys() and len(information["configuration"]):
+                    configuration = moduleDict[module]["configuration"]
+                    try:
+                        configurationInfo[configuration] = loadConfigurationInfos(project.info("SOURCES_PATH") + "/" + configuration)
+                    except ParseError, err:
+                        raise DefineException.ConfigurationDefineException(project.info("SOURCES_PATH") + "/" + configuration, err.line_number, err.line)
+            moduleInfoDict.update(moduleDict)
+            configurationInfoDict.update(configurationInfo)
+            if toBeParsed:
+                try:
+                    listDict = loadDefineLists(commentList[1:])
+                    listInfoDict.update(listDict)
+                except ParseError, err:
+                    raise DefineException.EnumDefineException(path, err.line_number, err.line)
+    for filename, path in findDefinitions("*_" + project.info("CPU_INFOS")["TOOLCHAIN"] + ".h", project):
+        commentList = getCommentList(open(path + "/" + filename, "r").read())
+        listInfoDict.update(loadDefineLists(commentList))
+    for tag in project.info("CPU_INFOS")["CPU_TAGS"]:
+        for filename, path in findDefinitions("*_" + tag + ".h", project):
+            commentList = getCommentList(open(path + "/" + filename, "r").read())
+            listInfoDict.update(loadDefineLists(commentList))
+    project.setInfo("MODULES", moduleInfoDict)
+    project.setInfo("LISTS", listInfoDict)
+    project.setInfo("CONFIGURATIONS", configurationInfoDict)
+    
 def formatParamNameValue(text):
     """
     Take the given string and return a tuple with the name of the parameter in the first position
@@ -178,19 +320,6 @@ def formatParamNameValue(text):
     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
@@ -204,98 +333,26 @@ def loadConfigurationInfos(path):
             "long": boolean indicating if the num is a long
             "value_list": the name of the enum for enum parameters
     """
-    try:
-        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
-            if ("type" in configurationInfos[name]["informations"].keys() and
-                    configurationInfos[name]["informations"]["type"] == "int" and
-                    configurationInfos[name]["value"].find("L") != -1):
-                configurationInfos[name]["informations"]["long"] = True
-                configurationInfos[name]["value"] = configurationInfos[name]["value"].replace("L", "")
-            if ("type" in configurationInfos[name]["informations"].keys() and
-                    configurationInfos[name]["informations"]["type"] == "int" and
-                    configurationInfos[name]["value"].find("U") != -1):
-                configurationInfos[name]["informations"]["unsigned"] = True
-                configurationInfos[name]["value"] = configurationInfos[name]["value"].replace("U", "")
-            configurationInfos[name]["description"] = description
-        return configurationInfos
-    except SyntaxError:
-        raise DefineException.ConfigurationDefineException(path)
-
-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
-    """
-    try:
-        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}
-                index = comment.find("\\brief")
-                if index != -1:
-                    description = comment[index + 7:]
-                    description = description[:description.find(" * ")]
-                    moduleInfos[WIZARD_MODULE["name"]]["description"] = description
-                return moduleInfos
-        return {}
-    except SyntaxError:
-        raise DefineException.ModuleDefineException(path)
-
-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
-    """
-    try:
-        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
-    except SyntaxError:
-        raise DefineException.EnumDefineException(path)
-
-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
+    configurationInfos = {}
+    for comment, define in getDefinitionBlocks(open(path, "r").read()):
+        name, value = formatParamNameValue(define)
+        brief, description, informations = getDescriptionInformations(comment)
+        configurationInfos[name] = {}
+        configurationInfos[name]["value"] = value
+        configurationInfos[name]["informations"] = informations
+        if ("type" in configurationInfos[name]["informations"].keys() and
+                configurationInfos[name]["informations"]["type"] == "int" and
+                configurationInfos[name]["value"].find("L") != -1):
+            configurationInfos[name]["informations"]["long"] = True
+            configurationInfos[name]["value"] = configurationInfos[name]["value"].replace("L", "")
+        if ("type" in configurationInfos[name]["informations"].keys() and
+                configurationInfos[name]["informations"]["type"] == "int" and
+                configurationInfos[name]["value"].find("U") != -1):
+            configurationInfos[name]["informations"]["unsigned"] = True
+            configurationInfos[name]["value"] = configurationInfos[name]["value"].replace("U", "")
+        configurationInfos[name]["description"] = description
+        configurationInfos[name]["brief"] = brief
+    return configurationInfos
 
 def sub(string, parameter, value):
     """
@@ -337,4 +394,10 @@ def isUnsignedLong(informations):
     if "unsigned" in informations.keys() and "long" in informations.keys() and informations["unsigned"] and informations["long"]:
         return True
     else:
-        return False
\ No newline at end of file
+        return False
+
+class ParseError(Exception):
+    def __init__(self, line_number, line):
+        Exception.__init__(self)
+        self.line_number = line_number
+        self.line = line