4 # Copyright 2008 Develer S.r.l. (http://www.develer.com/)
9 # Author: Lorenzo Berni <duplo@develer.com>
19 def isBertosDir(directory):
20 return os.path.exists(directory + "/VERSION")
22 def bertosVersion(directory):
23 return open(directory + "/VERSION").readline().strip()
25 def createBertosProject(directory):
26 if not os.path.isdir(directory):
28 open(directory + "/project.bertos", "w")
31 path = os.environ["PATH"]
33 path = path.split(";")
35 path = path.split(":")
38 def findToolchains(pathList):
40 for element in pathList:
41 for toolchain in glob.glob(element+ "/" + const.GCC_NAME):
42 if not os.path.islink(toolchain):
43 toolchains.append(toolchain)
44 return list(set(toolchains))
46 def getToolchainInfo(output):
48 expr = re.compile("Target: .*")
49 target = expr.findall(output)
51 info["target"] = target[0].split("Target: ")[1]
52 expr = re.compile("gcc version [0-9,.]*")
53 version = expr.findall(output)
55 info["version"] = version[0].split("gcc version ")[1]
56 expr = re.compile("gcc version [0-9,.]* \(.*\)")
57 build = expr.findall(output)
59 build = build[0].split("gcc version ")[1]
60 build = build[build.find("(") + 1 : build.find(")")]
62 expr = re.compile("Configured with: .*")
63 configured = expr.findall(output)
64 if len(configured) == 1:
65 info["configured"] = configured[0].split("Configured with: ")[1]
66 expr = re.compile("Thread model: .*")
67 thread = expr.findall(output)
69 info["thread"] = thread[0].split("Thread model: ")[1]
72 def findDefinitions(ftype, path):
75 for filename in element[2]:
76 if fnmatch.fnmatch(filename, ftype):
77 yield (filename, element[0])
79 def loadCpuInfos(path):
81 for definition in findDefinitions(const.CPU_DEFINITION, path):
82 cpuInfos.append(getInfos(definition))
85 def getInfos(definition):
87 D.update(const.CPU_DEF)
88 def include(filename, dict = D, directory=definition[1]):
89 execfile(directory + "/" + filename, {}, D)
90 D["include"] = include
91 include(definition[0], D)
92 D["CPU_NAME"] = definition[0].split(".")[0]
93 D["DEFINITION_PATH"] = definition[1] + "/" + definition[0]
97 def getDefinitionBlocks(text):
99 Take a text and return a list of tuple (description, name-value).
102 block_tmp = re.findall(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/\s*#define\s+((?:[^/]*?/?)+)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE)
103 for comment, define in block_tmp:
104 block.append((" ".join(re.findall(r"^\s*\*?\s*(.*?)\s*?(?:/{2}.*?)?$", comment, re.MULTILINE)).strip(), define))
105 block += re.findall(r"/{3}\s*([^<].*?)\s*#define\s+((?:[^/]*?/?)+)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE)
106 block += [(comment, define) for define, comment in re.findall(r"#define\s*(.*?)\s*/{3}<\s*(.+?)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE)]
109 def formatParamNameValue(text):
111 Take the given string and return a tuple with the name of the parameter in the first position
112 and the value in the second.
114 block = re.findall("\s*([^\s]+)\s*(.+?)\s*$", text, re.MULTILINE)
117 def getDescriptionInformations(text):
119 Take the doxygen comment and strip the wizard informations, returning the tuple
120 (comment, wizard_informations)
122 index = text.find("$WIZARD")
124 exec(text[index + 1:])
125 informations = WIZARD
126 return text[:index].strip(), informations
128 return text.strip(), {}
130 def loadConfigurationInfos(path):
132 Return the module configurations found in the given file as a dict with the
133 parameter name as key and a dict containig the fields above as value:
134 "value": the value of the parameter
135 "description": the description of the parameter
136 "informations": a dict containig optional informations:
137 "type": "int" | "boolean" | "enum"
138 "min": the minimum value for integer parameters
139 "max": the maximum value for integer parameters
140 "long": boolean indicating if the num is a long
141 "value_list": the name of the enum for enum parameters
143 configurationInfos = {}
144 for comment, define in getDefinitionBlocks(open(path, "r").read()):
145 name, value = formatParamNameValue(define)
146 description, informations = getDescriptionInformations(comment)
147 configurationInfos[name] = {}
148 configurationInfos[name]["value"] = value
149 configurationInfos[name]["informations"] = informations
150 configurationInfos[name]["description"] = description
151 return configurationInfos
153 def loadModuleInfos(path):
155 Return the module infos found in the given file as a dict with the module
156 name as key and a dict containig the fields above as value or an empty dict
157 if the given file is not a BeRTOS module:
158 "depends": a list of modules needed by this module
159 "configuration": the cfg_*.h with the module configurations
160 "description": a string containing the brief description of doxygen
161 "enabled": contains False but the wizard will change if the user select
165 string = open(path, "r").read()
166 commentList = re.findall(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/", string)
167 commentList = [" ".join(re.findall(r"^\s*\*?\s*(.*?)\s*?(?:/{2}.*?)?$", comment, re.MULTILINE)).strip() for comment in commentList]
168 for comment in commentList:
169 index = comment.find("$WIZARD_MODULE")
171 exec(comment[index + 1:])
172 moduleInfos[WIZARD_MODULE["name"]] = {"depends": WIZARD_MODULE["depends"],
173 "configuration": WIZARD_MODULE["configuration"],
179 def loadModuleInfosDict(path):
181 Return the dict containig all the modules
184 for filename, path in findDefinitions("*.h", path):
185 moduleInfosDict.update(loadModuleInfos(path + "/" + filename))
186 return moduleInfosDict
188 def loadDefineLists(path):
190 Return a dict with the name of the list as key and a list of string as value
192 string = open(path, "r").read()
193 commentList = re.findall(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/", string)
194 commentList = [" ".join(re.findall(r"^\s*\*?\s*(.*?)\s*?(?:/{2}.*?)?$", comment, re.MULTILINE)).strip() for comment in commentList]
196 for comment in commentList:
197 index = comment.find("$WIZARD_LIST")
199 exec(comment[index + 1:])
200 listDict.update(WIZARD_LIST)
203 def loadDefineListsDict(path):
205 Return the dict containing all the define lists
208 for filename, path in findDefinitions("*.h", path):
209 defineListsDict.update(loadDefineLists(path + "/" + filename))
210 return defineListsDict