Initial stub for filesystem query cache.
[bertos.git] / wizard / bertos_utils.py
1 #!/usr/bin/env python
2 # encoding: utf-8
3 #
4 # This file is part of BeRTOS.
5 #
6 # Bertos is free software; you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation; either version 2 of the License, or
9 # (at your option) any later version.
10 #
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 # GNU General Public License for more details.
15 #
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write to the Free Software
18 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19 #
20 # As a special exception, you may use this file as part of a free software
21 # library without restriction.  Specifically, if other files instantiate
22 # templates or use macros or inline functions from this file, or you compile
23 # this file and link it with other files to produce an executable, this
24 # file does not by itself cause the resulting executable to be covered by
25 # the GNU General Public License.  This exception does not however
26 # invalidate any other reasons why the executable file might be covered by
27 # the GNU General Public License.
28 #
29 # Copyright 2008 Develer S.r.l. (http://www.develer.com/)
30 #
31 # $Id$
32 #
33 # Author: Lorenzo Berni <duplo@develer.com>
34 #
35
36 import os
37 import fnmatch
38 import glob
39 import re
40 import shutil
41 # Use custom copytree function
42 import copytree
43 import pickle
44
45 import const
46 import plugins
47 import DefineException
48 import BProject
49
50 from _wizard_version import WIZARD_VERSION
51
52 from LoadException import VersionException, ToolchainException
53
54 def isBertosDir(directory):
55    return os.path.exists(directory + "/VERSION")
56
57 def bertosVersion(directory):
58    return open(directory + "/VERSION").readline().strip()
59
60 def loadBertosProject(project_file, info_dict):
61     project_dir = os.path.dirname(project_file)
62     project_data = pickle.loads(open(project_file, "r").read())
63     project_info = BProject.BProject()
64     project_info.setInfo("PROJECT_PATH", os.path.dirname(project_file))
65     # Check for the Wizard version
66     wizard_version = project_data.get("WIZARD_VERSION", 0)
67     if not wizard_version:
68         project_data["SOURCES_PATH"] = project_dir
69     if "SOURCES_PATH" in info_dict:
70         project_data["SOURCES_PATH"] = info_dict["SOURCES_PATH"]
71     if os.path.exists(project_data["SOURCES_PATH"]):
72         project_info.setInfo("SOURCES_PATH", project_data["SOURCES_PATH"])
73     else:
74         raise VersionException(project_info)
75     if not isBertosDir(os.path.dirname(project_file)):
76         version_file = open(os.path.join(const.DATA_DIR, "vtemplates/VERSION"), "r").read()
77         open(os.path.join(project_dir, "VERSION"), "w").write(version_file.replace("$version", "").strip())
78     loadSourceTree(project_info)
79     cpu_name = project_data["CPU_NAME"]
80     project_info.setInfo("CPU_NAME", cpu_name)
81     cpu_info = loadCpuInfos(project_info)
82     for cpu in cpu_info:
83         if cpu["CPU_NAME"] == cpu_name:
84             project_info.setInfo("CPU_INFOS", cpu)
85             break
86     tag_list = getTagSet(cpu_info)
87     # Create, fill and store the dict with the tags
88     tag_dict = {}
89     for element in tag_list:
90         tag_dict[element] = False
91     infos = project_info.info("CPU_INFOS")
92     for tag in tag_dict:
93         if tag in infos["CPU_TAGS"] + [infos["CPU_NAME"], infos["TOOLCHAIN"]]:
94             tag_dict[tag] = True
95         else:
96             tag_dict[tag] = False
97     project_info.setInfo("ALL_CPU_TAGS", tag_dict)
98     if "TOOLCHAIN" in info_dict:
99         project_data["TOOLCHAIN"] = info_dict["TOOLCHAIN"]
100     if os.path.exists(project_data["TOOLCHAIN"]["path"]):
101         project_info.setInfo("TOOLCHAIN", project_data["TOOLCHAIN"])
102     else:
103         raise ToolchainException(project_info)
104     project_info.setInfo("SELECTED_FREQ", project_data["SELECTED_FREQ"])
105     project_info.setInfo("OUTPUT", project_data["OUTPUT"])
106     loadModuleData(project_info, True)
107     setEnabledModules(project_info, project_data["ENABLED_MODULES"])
108     return project_info
109
110 def setEnabledModules(project_info, enabled_modules):
111     modules = project_info.info("MODULES")
112     files = {}
113     for module, information in modules.items():
114         information["enabled"] = module in enabled_modules
115         for dependency in information["depends"]:
116             if not dependency in modules:
117                 if dependency in files:
118                     files[dependency] += 1
119                 else:
120                     files[dependency] = 1
121     project_info.setInfo("MODULES", modules)
122     project_info.setInfo("FILES", files)
123
124 def enabledModules(project_info):
125     enabled_modules = []
126     for name, module in project_info.info("MODULES").items():
127         if module["enabled"]:
128             enabled_modules.append(name)
129     return enabled_modules
130
131 def mergeSources(srcdir, new_sources, old_sources):
132     # The current mergeSources function provide only a raw copy of the sources in the
133     # created project.
134     #
135     # TODO: implement the three way merge algorithm
136     #
137     shutil.rmtree(srcdir, True)
138     copytree.copytree(os.path.join(new_sources, "bertos"), srcdir, ignore_list=const.IGNORE_LIST)
139
140 def projectFileGenerator(project_info):
141     directory = project_info.info("PROJECT_PATH")
142     project_data = {}
143     enabled_modules = []
144     for module, information in project_info.info("MODULES").items():
145         if information["enabled"]:
146             enabled_modules.append(module)
147     project_data["ENABLED_MODULES"] = enabled_modules
148     # Use the local BeRTOS version instead of the original one
149     # project_data["SOURCES_PATH"] = project_info.info("SOURCES_PATH")
150     project_data["SOURCES_PATH"] = directory
151     project_data["TOOLCHAIN"] = project_info.info("TOOLCHAIN")
152     project_data["CPU_NAME"] = project_info.info("CPU_NAME")
153     project_data["SELECTED_FREQ"] = project_info.info("SELECTED_FREQ")
154     project_data["OUTPUT"] = project_info.info("OUTPUT")
155     project_data["WIZARD_VERSION"] = WIZARD_VERSION
156     return pickle.dumps(project_data)
157
158 def createBertosProject(project_info, edit=False):
159     directory = project_info.info("PROJECT_PATH")
160     sources_dir = project_info.info("SOURCES_PATH")
161     old_sources_dir = project_info.info("OLD_SOURCES_PATH")
162     if not edit:
163         if os.path.isdir(directory):
164             shutil.rmtree(directory, True)        
165         os.makedirs(directory)
166     # Write the project file
167     f = open(directory + "/project.bertos", "w")
168     f.write(projectFileGenerator(project_info))
169     f.close()
170     # VERSION file
171     version_file = open(os.path.join(const.DATA_DIR, "vtemplates/VERSION"), "r").read()
172     open(directory + "/VERSION", "w").write(versionFileGenerator(project_info, version_file))
173     # Destination source dir
174     srcdir = directory + "/bertos"
175     if not edit:
176         # If not in editing mode it copies all the bertos sources in the /bertos subdirectory of the project
177         shutil.rmtree(srcdir, True)
178         copytree.copytree(sources_dir + "/bertos", srcdir, ignore_list=const.IGNORE_LIST)
179     elif old_sources_dir:
180         # If in editing mode it merges the current bertos sources with the selected ones
181         # TODO: implement the three way merge algotihm
182         #
183         mergeSources(srcdir, sources_dir, old_sources_dir)
184     # Destination makefile
185     makefile = directory + "/Makefile"
186     makefile = open(os.path.join(const.DATA_DIR, "mktemplates/Makefile"), 'r').read()
187     makefile = makefileGenerator(project_info, makefile)
188     open(directory + "/Makefile", "w").write(makefile)
189     # Destination project dir
190     prjdir = directory + "/" + os.path.basename(directory)
191     if not edit:
192         shutil.rmtree(prjdir, True)
193         os.mkdir(prjdir)
194     # Destination hw files
195     hwdir = prjdir + "/hw"
196     if not edit:
197         shutil.rmtree(hwdir, True)
198         os.mkdir(hwdir)
199     # Copy all the hw files
200     for module, information in project_info.info("MODULES").items():
201         for hwfile in information["hw"]:
202             string = open(sources_dir + "/" + hwfile, "r").read()
203             hwfile_path = hwdir + "/" + os.path.basename(hwfile)
204             if not edit or not os.path.exists(hwfile_path):
205                 # If not in editing mode it copies all the hw files. If in
206                 # editing mode it copies only the files that don't exist yet
207                 open(hwdir + "/" + os.path.basename(hwfile), "w").write(string)
208     # Destination configurations files
209     cfgdir = prjdir + "/cfg"
210     if not edit:
211         shutil.rmtree(cfgdir, True)
212         os.mkdir(cfgdir)
213     # Set properly the autoenabled parameters
214     for module, information in project_info.info("MODULES").items():
215         if "configuration" in information and information["configuration"] != "":
216             configurations = project_info.info("CONFIGURATIONS")
217             configuration = configurations[information["configuration"]]
218             for start, parameter in configuration["paramlist"]:
219                 if "type" in configuration[parameter]["informations"] and configuration[parameter]["informations"]["type"] == "autoenabled":
220                     configuration[parameter]["value"] = "1" if information["enabled"] else "0"
221             project_info.setInfo("CONFIGURATIONS", configurations)
222     # Copy all the configuration files
223     for configuration, information in project_info.info("CONFIGURATIONS").items():
224         string = open(sources_dir + "/" + configuration, "r").read()
225         for start, parameter in information["paramlist"]:
226             infos = information[parameter]
227             value = infos["value"]
228             if "unsigned" in infos["informations"] and infos["informations"]["unsigned"]:
229                 value += "U"
230             if "long" in infos["informations"] and infos["informations"]["long"]:
231                 value += "L"
232             string = sub(string, parameter, value)
233         f = open(cfgdir + "/" + os.path.basename(configuration), "w")
234         f.write(string)
235         f.close()
236     if not edit:
237         # Destination user mk file (only on project creation)
238         makefile = open(os.path.join(const.DATA_DIR, "mktemplates/template.mk"), "r").read()
239         # Deadly performances loss was here :(
240         makefile = userMkGenerator(project_info, makefile)
241         open(prjdir + "/" + os.path.basename(prjdir) + ".mk", "w").write(makefile)
242     # Destination wizard mk file
243     makefile = open(os.path.join(const.DATA_DIR, "mktemplates/template_wiz.mk"), "r").read()
244     makefile = mkGenerator(project_info, makefile)
245     open(prjdir + "/" + os.path.basename(prjdir) + "_wiz.mk", "w").write(makefile)
246     # Destination main.c file
247     if not edit:
248         main = open(os.path.join(const.DATA_DIR, "srctemplates/main.c"), "r").read()
249         open(prjdir + "/main.c", "w").write(main)
250     # Files for selected plugins
251     relevants_files = {}
252     for plugin in project_info.info("OUTPUT"):
253         module = loadPlugin(plugin)
254         relevants_files[plugin] = module.createProject(project_info)
255     project_info.setInfo("RELEVANT_FILES", relevants_files)
256
257 def loadPlugin(plugin):
258     """
259     Returns the given plugin module.
260     """
261     return getattr(__import__("plugins", {}, {}, [plugin]), plugin)
262
263 def versionFileGenerator(project_info, version_file):
264     version = bertosVersion(project_info.info("SOURCES_PATH"))
265     return version_file.replace('$version', version)
266
267 def userMkGenerator(project_info, makefile):
268     mk_data = {}
269     mk_data["$pname"] = os.path.basename(project_info.info("PROJECT_PATH"))
270     for key in mk_data:
271         while makefile.find(key) != -1:
272             makefile = makefile.replace(key, mk_data[key])
273     return makefile
274
275 def mkGenerator(project_info, makefile):
276     """
277     Generates the mk file for the current project.
278     """
279     mk_data = {}
280     mk_data["$pname"] = os.path.basename(project_info.info("PROJECT_PATH"))
281     mk_data["$cpuclockfreq"] = project_info.info("SELECTED_FREQ")
282     cpu_mk_parameters = []
283     for key, value in project_info.info("CPU_INFOS").items():
284         if key.startswith(const.MK_PARAM_ID):
285             cpu_mk_parameters.append("%s = %s" %(key.replace("MK", mk_data["$pname"]), value))
286     mk_data["$cpuparameters"] = "\n".join(cpu_mk_parameters)
287     mk_data["$csrc"], mk_data["$pcsrc"], mk_data["$cppasrc"], mk_data["$cxxsrc"], mk_data["$asrc"], mk_data["$constants"] = csrcGenerator(project_info)
288     mk_data["$prefix"] = replaceSeparators(project_info.info("TOOLCHAIN")["path"].split("gcc")[0])
289     mk_data["$suffix"] = replaceSeparators(project_info.info("TOOLCHAIN")["path"].split("gcc")[1])
290     mk_data["$main"] = os.path.basename(project_info.info("PROJECT_PATH")) + "/main.c"
291     for key in mk_data:
292         while makefile.find(key) != -1:
293             makefile = makefile.replace(key, mk_data[key])
294     return makefile
295
296 def makefileGenerator(project_info, makefile):
297     """
298     Generate the Makefile for the current project.
299     """
300     # TODO write a general function that works for both the mk file and the Makefile
301     while makefile.find("$pname") != -1:
302         makefile = makefile.replace("$pname", os.path.basename(project_info.info("PROJECT_PATH")))
303     return makefile
304
305 def csrcGenerator(project_info):
306     modules = project_info.info("MODULES")
307     files = project_info.info("FILES")
308     if "harvard" in project_info.info("CPU_INFOS")["CPU_TAGS"]:
309         harvard = True
310     else:
311         harvard = False
312     # file to be included in CSRC variable
313     csrc = []
314     # file to be included in PCSRC variable
315     pcsrc = []
316     # files to be included in CPPASRC variable
317     cppasrc = []
318     # files to be included in CXXSRC variable
319     cxxsrc = []
320     # files to be included in ASRC variable
321     asrc = []
322     # constants to be included at the beginning of the makefile
323     constants = {}
324     for module, information in modules.items():
325         module_files = set([])
326         dependency_files = set([])
327         # assembly sources
328         asm_files = set([])
329         hwdir = os.path.basename(project_info.info("PROJECT_PATH")) + "/hw" 
330         if information["enabled"]:
331             if "constants" in information:
332                 constants.update(information["constants"])
333             cfiles, sfiles = findModuleFiles(module, project_info)
334             module_files |= set(cfiles)
335             asm_files |= set(sfiles)
336             for file in information["hw"]:
337                 if file.endswith(".c"):
338                     module_files |= set([hwdir + "/" + os.path.basename(file)])
339             for file_dependency in information["depends"] + tuple(files.keys()):
340                     dependencyCFiles, dependencySFiles = findModuleFiles(file_dependency, project_info)
341                     dependency_files |= set(dependencyCFiles)
342                     asm_files |= set(dependencySFiles)
343             for file in module_files:
344                 if not harvard or information.get("harvard", "both") == "both":
345                     csrc.append(file)
346                 if harvard and "harvard" in information:
347                     pcsrc.append(file)
348             for file in dependency_files:
349                 csrc.append(file)
350             for file in project_info.info("CPU_INFOS")["C_SRC"]:
351                 csrc.append(file)
352             for file in project_info.info("CPU_INFOS")["PC_SRC"]:
353                 pcsrc.append(file)
354             for file in asm_files:
355                 cppasrc.append(file)
356     for file in project_info.info("CPU_INFOS")["CPPA_SRC"]:
357         cppasrc.append(file)
358     for file in project_info.info("CPU_INFOS")["CXX_SRC"]:
359         cxxsrc.append(file)
360     for file in project_info.info("CPU_INFOS")["ASRC"]:
361         asrc.append(file)
362     csrc = set(csrc)
363     csrc = " \\\n\t".join(csrc) + " \\"
364     pcsrc = set(pcsrc)
365     pcsrc = " \\\n\t".join(pcsrc) + " \\"
366     cppasrc = set(cppasrc)
367     cppasrc = " \\\n\t".join(cppasrc) + " \\"
368     cxxsrc = set(cxxsrc)
369     cxxsrc = " \\\n\t".join(cxxsrc) + " \\"
370     asrc = set(asrc)
371     asrc = " \\\n\t".join(asrc) + " \\"
372     constants = "\n".join([os.path.basename(project_info.info("PROJECT_PATH")) + "_" + key + " = " + unicode(value) for key, value in constants.items()])
373     return csrc, pcsrc, cppasrc, cxxsrc, asrc, constants
374
375 def findModuleFiles(module, project_info):
376     # Find the files related to the selected module
377     cfiles = []
378     sfiles = []
379     # .c files related to the module and the cpu architecture
380     for filename, path in findDefinitions(module + ".c", project_info) + \
381             findDefinitions(module + "_" + project_info.info("CPU_INFOS")["TOOLCHAIN"] + ".c", project_info):
382         path = path.replace(project_info.info("SOURCES_PATH") + os.sep, "")
383         path = replaceSeparators(path)
384         cfiles.append(path + "/" + filename)
385     # .s files related to the module and the cpu architecture
386     for filename, path in findDefinitions(module + ".s", project_info) + \
387             findDefinitions(module + "_" + project_info.info("CPU_INFOS")["TOOLCHAIN"] + ".s", project_info) + \
388             findDefinitions(module + ".S", project_info) + \
389             findDefinitions(module + "_" + project_info.info("CPU_INFOS")["TOOLCHAIN"] + ".S", project_info):
390         path = path.replace(project_info.info("SOURCES_PATH") + os.sep, "")
391         path = replaceSeparators(path)
392         sfiles.append(path + "/" + filename)
393     # .c and .s files related to the module and the cpu tags
394     for tag in project_info.info("CPU_INFOS")["CPU_TAGS"]:
395         for filename, path in findDefinitions(module + "_" + tag + ".c", project_info):
396             path = path.replace(project_info.info("SOURCES_PATH") + os.sep, "")
397             if os.sep != "/":
398                 path = replaceSeparators(path)
399             cfiles.append(path + "/" + filename)
400         for filename, path in findDefinitions(module + "_" + tag + ".s", project_info) + \
401                 findDefinitions(module + "_" + tag + ".S", project_info):
402             path = path.replace(project_info.info("SOURCES_PATH") + os.sep, "")
403             path = replaceSeparators(path)
404             sfiles.append(path + "/" + filename)
405     return cfiles, sfiles
406
407 def replaceSeparators(path):
408     """
409     Replace the separators in the given path with unix standard separator.
410     """
411     if os.sep != "/":
412         while path.find(os.sep) != -1:
413             path = path.replace(os.sep, "/")
414     return path
415
416 def getSystemPath():
417     path = os.environ["PATH"]
418     if os.name == "nt":
419         path = path.split(";")
420     else:
421         path = path.split(":")
422     return path
423
424 def findToolchains(path_list):
425     toolchains = []
426     for element in path_list:
427         for toolchain in glob.glob(element+ "/" + const.GCC_NAME):
428             toolchains.append(toolchain)
429     return list(set(toolchains))
430
431 def getToolchainInfo(output):
432     info = {}
433     expr = re.compile("Target: .*")
434     target = expr.findall(output)
435     if len(target) == 1:
436         info["target"] = target[0].split("Target: ")[1]
437     expr = re.compile("gcc version [0-9,.]*")
438     version = expr.findall(output)
439     if len(version) == 1:
440         info["version"] = version[0].split("gcc version ")[1]
441     expr = re.compile("gcc version [0-9,.]* \(.*\)")
442     build = expr.findall(output)
443     if len(build) == 1:
444         build = build[0].split("gcc version ")[1]
445         build = build[build.find("(") + 1 : build.find(")")]
446         info["build"] = build
447     expr = re.compile("Configured with: .*")
448     configured = expr.findall(output)
449     if len(configured) == 1:
450         info["configured"] = configured[0].split("Configured with: ")[1]
451     expr = re.compile("Thread model: .*")
452     thread = expr.findall(output)
453     if len(thread) == 1:
454         info["thread"] = thread[0].split("Thread model: ")[1]
455     return info
456
457 def getToolchainName(toolchain_info):
458     name = "GCC " + toolchain_info["version"] + " - " + toolchain_info["target"].strip()
459     return name
460
461 def loadSourceTree(project):
462     # Index only the SOURCES_PATH/bertos content
463     bertos_sources_dir = os.path.join(project.info("SOURCES_PATH"), 'bertos')
464     if os.path.exists(bertos_sources_dir):
465         fileList = [f for f in os.walk(bertos_sources_dir)]
466     else:
467         fileList = []
468     project.setInfo("FILE_LIST", fileList)
469
470 _cached_queries = {}
471
472 def findDefinitions(ftype, project):
473     definitions = _cached_queries.get(ftype, None)
474     if definitions is not None:
475         return definitions
476     L = project.info("FILE_LIST")
477     definitions = []
478     for element in L:
479         for filename in element[2]:
480             if fnmatch.fnmatch(filename, ftype):
481                 definitions.append((filename, element[0]))
482     _cached_queries[ftype] = definitions
483     return definitions
484
485 def loadCpuInfos(project):
486     cpuInfos = []
487     for definition in findDefinitions(const.CPU_DEFINITION, project):
488         cpuInfos.append(getInfos(definition))
489     return cpuInfos
490
491 def getTagSet(cpu_info):
492     tag_set = set([])
493     for cpu in cpu_info:
494         tag_set |= set([cpu["CPU_NAME"]])
495         tag_set |= set(cpu["CPU_TAGS"])
496         tag_set |= set([cpu["TOOLCHAIN"]])
497     return tag_set
498         
499
500 def getInfos(definition):
501     D = {}
502     D.update(const.CPU_DEF)
503     def include(filename, dict = D, directory=definition[1]):
504         execfile(directory + "/" + filename, {}, D)
505     D["include"] = include
506     include(definition[0], D)
507     D["CPU_NAME"] = definition[0].split(".")[0]
508     D["DEFINITION_PATH"] = definition[1] + "/" + definition[0]
509     del D["include"]
510     return D
511
512 def getCommentList(string):
513     comment_list = re.findall(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/", string)
514     comment_list = [re.findall(r"^\s*\* *(.*?)$", comment, re.MULTILINE) for comment in comment_list]
515     return comment_list
516
517 def loadModuleDefinition(first_comment):
518     to_be_parsed = False
519     module_definition = {}
520     for num, line in enumerate(first_comment):
521         index = line.find("$WIZ$")
522         if index != -1:
523             to_be_parsed = True
524             try:
525                 exec line[index + len("$WIZ$ "):] in {}, module_definition
526             except:
527                 raise ParseError(num, line[index:])
528         elif line.find("\\brief") != -1:
529             module_definition["module_description"] = line[line.find("\\brief") + len("\\brief "):]
530     module_dict = {}
531     if "module_name" in module_definition:
532         module_name = module_definition[const.MODULE_DEFINITION["module_name"]]
533         del module_definition[const.MODULE_DEFINITION["module_name"]]
534         module_dict[module_name] = {}
535         if const.MODULE_DEFINITION["module_depends"] in module_definition:
536             depends = module_definition[const.MODULE_DEFINITION["module_depends"]]
537             del module_definition[const.MODULE_DEFINITION["module_depends"]]
538             if type(depends) == str:
539                 depends = (depends,)
540             module_dict[module_name]["depends"] = depends
541         else:
542             module_dict[module_name]["depends"] = ()
543         if const.MODULE_DEFINITION["module_configuration"] in module_definition:
544             module_dict[module_name]["configuration"] = module_definition[const.MODULE_DEFINITION["module_configuration"]]
545             del module_definition[const.MODULE_DEFINITION["module_configuration"]]
546         else:
547             module_dict[module_name]["configuration"] = ""
548         if "module_description" in module_definition:
549             module_dict[module_name]["description"] = module_definition["module_description"]
550             del module_definition["module_description"]
551         if const.MODULE_DEFINITION["module_harvard"] in module_definition:
552             harvard = module_definition[const.MODULE_DEFINITION["module_harvard"]]
553             module_dict[module_name]["harvard"] = harvard
554             del module_definition[const.MODULE_DEFINITION["module_harvard"]]
555         if const.MODULE_DEFINITION["module_hw"] in module_definition:
556             hw = module_definition[const.MODULE_DEFINITION["module_hw"]]
557             del module_definition[const.MODULE_DEFINITION["module_hw"]]
558             if type(hw) == str:
559                 hw = (hw, )
560             module_dict[module_name]["hw"] = hw
561         else:
562             module_dict[module_name]["hw"] = ()
563         if const.MODULE_DEFINITION["module_supports"] in module_definition:
564             supports = module_definition[const.MODULE_DEFINITION["module_supports"]]
565             del module_definition[const.MODULE_DEFINITION["module_supports"]]
566             module_dict[module_name]["supports"] = supports
567         module_dict[module_name]["constants"] = module_definition
568         module_dict[module_name]["enabled"] = False
569     return to_be_parsed, module_dict
570
571 def isSupported(project, module=None, property_id=None):
572     if not module and property_id:
573         item = project.info("CONFIGURATIONS")[property_id[0]][property_id[1]]["informations"]
574     else:
575         item = project.info("MODULES")[module]
576     tag_dict = project.info("ALL_CPU_TAGS")
577     if "supports" in item:
578         support_string = item["supports"]
579         supported = {}
580         try:
581             exec "supported = " + support_string in tag_dict, supported
582         except:
583             raise SupportedException(support_string)
584         return supported["supported"]
585     else:
586         return True
587
588 def loadDefineLists(comment_list):
589     define_list = {}
590     for comment in comment_list:
591         for num, line in enumerate(comment):
592             index = line.find("$WIZ$")
593             if index != -1:
594                 try:
595                     exec line[index + len("$WIZ$ "):] in {}, define_list
596                 except:
597                     raise ParseError(num, line[index:])
598     for key, value in define_list.items():
599         if type(value) == str:
600             define_list[key] = (value,)
601     return define_list
602
603 def getDescriptionInformations(comment):
604     """
605     Take the doxygen comment and strip the wizard informations, returning the tuple
606     (comment, wizard_information)
607     """
608     brief = ""
609     description = ""
610     information = {}
611     for num, line in enumerate(comment):
612         index = line.find("$WIZ$")
613         if index != -1:
614             if len(brief) == 0:
615                 brief += line[:index].strip()
616             else:
617                 description += " " + line[:index]
618             try:
619                 exec line[index + len("$WIZ$ "):] in {}, information
620             except:
621                 raise ParseError(num, line[index:])
622         else:
623             if len(brief) == 0:
624                 brief += line.strip()
625             else:
626                 description += " " + line
627                 description = description.strip()
628     return brief.strip(), description.strip(), information
629
630 def getDefinitionBlocks(text):
631     """
632     Take a text and return a list of tuple (description, name-value).
633     """
634     block = []
635     block_tmp = re.finditer(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/\s*#define\s+((?:[^/]*?/?)+)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE)
636     for match in block_tmp:
637         # Only the first element is needed
638         comment = match.group(1)
639         define = match.group(2)
640         start = match.start()
641         block.append(([re.findall(r"^\s*\* *(.*?)$", line, re.MULTILINE)[0] for line in comment.splitlines()], define, start))
642     for match in re.finditer(r"/{3}\s*([^<].*?)\s*#define\s+((?:[^/]*?/?)+)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE):
643         comment = match.group(1)
644         define = match.group(2)
645         start = match.start()
646         block.append(([comment], define, start))
647     for match in re.finditer(r"#define\s*(.*?)\s*/{3}<\s*(.+?)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE):
648         comment = match.group(2)
649         define = match.group(1)
650         start = match.start()
651         block.append(([comment], define, start))
652     return block
653
654 def loadModuleData(project, edit=False):
655     module_info_dict = {}
656     list_info_dict = {}
657     configuration_info_dict = {}
658     file_dict = {}
659     for filename, path in findDefinitions("*.h", project) + findDefinitions("*.c", project) + findDefinitions("*.s", project) + findDefinitions("*.S", project):
660         comment_list = getCommentList(open(path + "/" + filename, "r").read())
661         if len(comment_list) > 0:
662             module_info = {}
663             configuration_info = {}
664             try:
665                 to_be_parsed, module_dict = loadModuleDefinition(comment_list[0])
666             except ParseError, err:
667                 raise DefineException.ModuleDefineException(path, err.line_number, err.line)
668             for module, information in module_dict.items():
669                 if "depends" not in information:
670                     information["depends"] = ()
671                 information["depends"] += (filename.split(".")[0],)
672                 information["category"] = os.path.basename(path)
673                 if "configuration" in information and len(information["configuration"]):
674                     configuration = module_dict[module]["configuration"]
675                     try:
676                         configuration_info[configuration] = loadConfigurationInfos(project.info("SOURCES_PATH") + "/" + configuration)
677                     except ParseError, err:
678                         raise DefineException.ConfigurationDefineException(project.info("SOURCES_PATH") + "/" + configuration, err.line_number, err.line)
679                     if edit:
680                         try:
681                             path = os.path.basename(project.info("PROJECT_PATH"))
682                             directory = project.info("PROJECT_PATH")
683                             user_configuration = loadConfigurationInfos(directory + "/" + configuration.replace("bertos", path))
684                             configuration_info[configuration] = updateConfigurationValues(configuration_info[configuration], user_configuration)
685                         except ParseError, err:
686                             raise DefineException.ConfigurationDefineException(directory + "/" + configuration.replace("bertos", path))
687             module_info_dict.update(module_dict)
688             configuration_info_dict.update(configuration_info)
689             if to_be_parsed:
690                 try:
691                     list_dict = loadDefineLists(comment_list[1:])
692                     list_info_dict.update(list_dict)
693                 except ParseError, err:
694                     raise DefineException.EnumDefineException(path, err.line_number, err.line)
695     for filename, path in findDefinitions("*_" + project.info("CPU_INFOS")["TOOLCHAIN"] + ".h", project):
696         comment_list = getCommentList(open(path + "/" + filename, "r").read())
697         list_info_dict.update(loadDefineLists(comment_list))
698     for tag in project.info("CPU_INFOS")["CPU_TAGS"]:
699         for filename, path in findDefinitions("*_" + tag + ".h", project):
700             comment_list = getCommentList(open(path + "/" + filename, "r").read())
701             list_info_dict.update(loadDefineLists(comment_list))
702     project.setInfo("MODULES", module_info_dict)
703     project.setInfo("LISTS", list_info_dict)
704     project.setInfo("CONFIGURATIONS", configuration_info_dict)
705     project.setInfo("FILES", file_dict)
706
707 def formatParamNameValue(text):
708     """
709     Take the given string and return a tuple with the name of the parameter in the first position
710     and the value in the second.
711     """
712     block = re.findall("\s*([^\s]+)\s*(.+?)\s*$", text, re.MULTILINE)
713     return block[0]
714
715 def loadConfigurationInfos(path):
716     """
717     Return the module configurations found in the given file as a dict with the
718     parameter name as key and a dict containig the fields above as value:
719         "value": the value of the parameter
720         "description": the description of the parameter
721         "informations": a dict containig optional informations:
722             "type": "int" | "boolean" | "enum"
723             "min": the minimum value for integer parameters
724             "max": the maximum value for integer parameters
725             "long": boolean indicating if the num is a long
726             "unsigned": boolean indicating if the num is an unsigned
727             "value_list": the name of the enum for enum parameters
728             "conditional_deps": the list of conditional dependencies for boolean parameters
729     """
730     configuration_infos = {}
731     configuration_infos["paramlist"] = []
732     for comment, define, start in getDefinitionBlocks(open(path, "r").read()):
733         name, value = formatParamNameValue(define)
734         brief, description, informations = getDescriptionInformations(comment)
735         configuration_infos["paramlist"].append((start, name))
736         configuration_infos[name] = {}
737         configuration_infos[name]["value"] = value
738         configuration_infos[name]["informations"] = informations
739         if not "type" in configuration_infos[name]["informations"]:
740             configuration_infos[name]["informations"]["type"] = findParameterType(configuration_infos[name])
741         if ("type" in configuration_infos[name]["informations"] and
742                 configuration_infos[name]["informations"]["type"] == "int" and
743                 configuration_infos[name]["value"].find("L") != -1):
744             configuration_infos[name]["informations"]["long"] = True
745             configuration_infos[name]["value"] = configuration_infos[name]["value"].replace("L", "")
746         if ("type" in configuration_infos[name]["informations"] and
747                 configuration_infos[name]["informations"]["type"] == "int" and
748                 configuration_infos[name]["value"].find("U") != -1):
749             configuration_infos[name]["informations"]["unsigned"] = True
750             configuration_infos[name]["value"] = configuration_infos[name]["value"].replace("U", "")
751         if "conditional_deps" in configuration_infos[name]["informations"]:
752             if (type(configuration_infos[name]["informations"]["conditional_deps"]) == str or
753                     type(configuration_infos[name]["informations"]["conditional_deps"]) == unicode):
754                 configuration_infos[name]["informations"]["conditional_deps"] = (configuration_infos[name]["informations"]["conditional_deps"], )
755             elif type(configuration_infos[name]["informations"]["conditional_deps"]) == tuple:
756                 pass
757             else:
758                 configuration_infos[name]["informations"]["conditional_deps"] = ()
759         configuration_infos[name]["description"] = description
760         configuration_infos[name]["brief"] = brief
761     return configuration_infos
762
763 def updateConfigurationValues(def_conf, user_conf):
764     for param in def_conf["paramlist"]:
765         if param[1] in user_conf and "value" in user_conf[param[1]]:
766             def_conf[param[1]]["value"] = user_conf[param[1]]["value"]
767     return def_conf
768
769 def findParameterType(parameter):
770     if "value_list" in parameter["informations"]:
771         return "enum"
772     if "min" in parameter["informations"] or "max" in parameter["informations"] or re.match(r"^\d+U?L?$", parameter["value"]) != None:
773         return "int"
774
775 def sub(string, parameter, value):
776     """
777     Substitute the given value at the given parameter define in the given string
778     """
779     return re.sub(r"(?P<define>#define\s+" + parameter + r"\s+)([^\s]+)", r"\g<define>" + value, string)
780
781 def isInt(informations):
782     """
783     Return True if the value is a simple int.
784     """
785     if ("long" not in informatios or not informations["long"]) and ("unsigned" not in informations or informations["unsigned"]):
786         return True
787     else:
788         return False
789
790 def isLong(informations):
791     """
792     Return True if the value is a long.
793     """
794     if "long" in informations and informations["long"] and "unsigned" not in informations:
795         return True
796     else:
797         return False
798
799 def isUnsigned(informations):
800     """
801     Return True if the value is an unsigned.
802     """
803     if "unsigned" in informations and informations["unsigned"] and "long" not in informations:
804         return True
805     else:
806         return False
807
808 def isUnsignedLong(informations):
809     """
810     Return True if the value is an unsigned long.
811     """
812     if "unsigned" in informations and "long" in informations and informations["unsigned"] and informations["long"]:
813         return True
814     else:
815         return False
816
817 class ParseError(Exception):
818     def __init__(self, line_number, line):
819         Exception.__init__(self)
820         self.line_number = line_number
821         self.line = line
822
823 class SupportedException(Exception):
824     def __init__(self, support_string):
825         Exception.__init__(self)
826         self.support_string = support_string