+
+def getCommentList(string):
+ comment_list = re.findall(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/", string)
+ comment_list = [re.findall(r"^\s*\* *(.*?)$", comment, re.MULTILINE) for comment in comment_list]
+ return comment_list
+
+def loadModuleDefinition(first_comment):
+ to_be_parsed = False
+ module_definition = {}
+ for num, line in enumerate(first_comment):
+ index = line.find("$WIZ$")
+ if index != -1:
+ to_be_parsed = True
+ try:
+ exec line[index + len("$WIZ$ "):] in {}, module_definition
+ except:
+ raise ParseError(num, line[index:])
+ elif line.find("\\brief") != -1:
+ module_definition["module_description"] = line[line.find("\\brief") + len("\\brief "):]
+ module_dict = {}
+ if "module_name" in module_definition:
+ module_name = module_definition[const.MODULE_DEFINITION["module_name"]]
+ del module_definition[const.MODULE_DEFINITION["module_name"]]
+ module_dict[module_name] = {}
+ if const.MODULE_DEFINITION["module_depends"] in module_definition:
+ depends = module_definition[const.MODULE_DEFINITION["module_depends"]]
+ del module_definition[const.MODULE_DEFINITION["module_depends"]]
+ if type(depends) == str:
+ depends = (depends,)
+ module_dict[module_name]["depends"] = depends
+ else:
+ module_dict[module_name]["depends"] = ()
+ if const.MODULE_DEFINITION["module_configuration"] in module_definition:
+ module_dict[module_name]["configuration"] = module_definition[const.MODULE_DEFINITION["module_configuration"]]
+ del module_definition[const.MODULE_DEFINITION["module_configuration"]]
+ else:
+ module_dict[module_name]["configuration"] = ""
+ if "module_description" in module_definition:
+ module_dict[module_name]["description"] = module_definition["module_description"]
+ 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
+ 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"]]
+ del module_definition[const.MODULE_DEFINITION["module_hw"]]
+ if type(hw) == str:
+ hw = (hw, )
+ module_dict[module_name]["hw"] = hw
+ else:
+ module_dict[module_name]["hw"] = ()
+ if const.MODULE_DEFINITION["module_supports"] in module_definition:
+ supports = module_definition[const.MODULE_DEFINITION["module_supports"]]
+ del module_definition[const.MODULE_DEFINITION["module_supports"]]
+ module_dict[module_name]["supports"] = supports
+ module_dict[module_name]["constants"] = module_definition
+ module_dict[module_name]["enabled"] = False
+ return to_be_parsed, module_dict
+
+def isSupported(project, module=None, property_id=None):
+ if not module and property_id:
+ item = project.info("CONFIGURATIONS")[property_id[0]][property_id[1]]["informations"]
+ else:
+ item = project.info("MODULES")[module]
+ tag_dict = project.info("ALL_CPU_TAGS")
+ if "supports" in item:
+ support_string = item["supports"]
+ supported = {}
+ try:
+ exec "supported = " + support_string in tag_dict, supported
+ except:
+ raise SupportedException(support_string)
+ return supported["supported"]
+ else:
+ return True
+
+def loadDefineLists(comment_list):
+ define_list = {}
+ for comment in comment_list:
+ for num, line in enumerate(comment):
+ index = line.find("$WIZ$")
+ if index != -1:
+ try:
+ exec line[index + len("$WIZ$ "):] in {}, define_list
+ except:
+ raise ParseError(num, line[index:])
+ for key, value in define_list.items():
+ if type(value) == str:
+ define_list[key] = (value,)
+ return define_list
+
+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).
+ """
+ block = []
+ block_tmp = re.finditer(r"/\*{2}\s*([^*]*\*(?:[^/*][^*]*\*+)*)/\s*#define\s+((?:[^/]*?/?)+)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE)
+ for match in block_tmp:
+ # Only the first element is needed
+ comment = match.group(1)
+ define = match.group(2)
+ start = match.start()
+ block.append(([re.findall(r"^\s*\* *(.*?)$", line, re.MULTILINE)[0] for line in comment.splitlines()], define, start))
+ for match in re.finditer(r"/{3}\s*([^<].*?)\s*#define\s+((?:[^/]*?/?)+)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE):
+ comment = match.group(1)
+ define = match.group(2)
+ start = match.start()
+ block.append(([comment], define, start))
+ for match in re.finditer(r"#define\s*(.*?)\s*/{3}<\s*(.+?)\s*?(?:/{2,3}[^<].*?)?$", text, re.MULTILINE):
+ comment = match.group(2)
+ define = match.group(1)
+ start = match.start()
+ block.append(([comment], define, start))
+ return block
+
+def loadModuleData(project):
+ module_info_dict = {}
+ list_info_dict = {}
+ configuration_info_dict = {}
+ file_dict = {}
+ for filename, path in findDefinitions("*.h", project) + findDefinitions("*.c", project) + findDefinitions("*.s", project) + findDefinitions("*.S", project):
+ comment_list = getCommentList(open(path + "/" + filename, "r").read())
+ if len(comment_list) > 0:
+ module_info = {}
+ configuration_info = {}
+ try:
+ to_be_parsed, module_dict = loadModuleDefinition(comment_list[0])
+ except ParseError, err:
+ raise DefineException.ModuleDefineException(path, err.line_number, err.line)
+ for module, information in module_dict.items():
+ if "depends" not in information:
+ information["depends"] = ()
+ information["depends"] += (filename.split(".")[0],)
+ information["category"] = os.path.basename(path)
+ if "configuration" in information and len(information["configuration"]):
+ configuration = module_dict[module]["configuration"]
+ try:
+ 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)
+ module_info_dict.update(module_dict)
+ configuration_info_dict.update(configuration_info)
+ if to_be_parsed:
+ try:
+ list_dict = loadDefineLists(comment_list[1:])
+ list_info_dict.update(list_dict)
+ except ParseError, err:
+ raise DefineException.EnumDefineException(path, err.line_number, err.line)
+ for filename, path in findDefinitions("*_" + project.info("CPU_INFOS")["TOOLCHAIN"] + ".h", project):
+ comment_list = getCommentList(open(path + "/" + filename, "r").read())
+ list_info_dict.update(loadDefineLists(comment_list))
+ for tag in project.info("CPU_INFOS")["CPU_TAGS"]:
+ for filename, path in findDefinitions("*_" + tag + ".h", project):
+ comment_list = getCommentList(open(path + "/" + filename, "r").read())
+ list_info_dict.update(loadDefineLists(comment_list))
+ project.setInfo("MODULES", module_info_dict)
+ project.setInfo("LISTS", list_info_dict)
+ project.setInfo("CONFIGURATIONS", configuration_info_dict)
+ project.setInfo("FILES", file_dict)
+
+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 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
+ "unsigned": boolean indicating if the num is an unsigned
+ "value_list": the name of the enum for enum parameters
+ """
+ configuration_infos = {}
+ configuration_infos["paramlist"] = []
+ for comment, define, start in getDefinitionBlocks(open(path, "r").read()):
+ name, value = formatParamNameValue(define)
+ brief, description, informations = getDescriptionInformations(comment)
+ configuration_infos["paramlist"].append((start, name))
+ configuration_infos[name] = {}
+ configuration_infos[name]["value"] = value
+ configuration_infos[name]["informations"] = informations
+ if not "type" in configuration_infos[name]["informations"]:
+ configuration_infos[name]["informations"]["type"] = findParameterType(configuration_infos[name])
+ if ("type" in configuration_infos[name]["informations"] and
+ configuration_infos[name]["informations"]["type"] == "int" and
+ configuration_infos[name]["value"].find("L") != -1):
+ configuration_infos[name]["informations"]["long"] = True
+ configuration_infos[name]["value"] = configuration_infos[name]["value"].replace("L", "")
+ if ("type" in configuration_infos[name]["informations"] and
+ configuration_infos[name]["informations"]["type"] == "int" and
+ configuration_infos[name]["value"].find("U") != -1):
+ configuration_infos[name]["informations"]["unsigned"] = True
+ configuration_infos[name]["value"] = configuration_infos[name]["value"].replace("U", "")
+ configuration_infos[name]["description"] = description
+ configuration_infos[name]["brief"] = brief
+ return configuration_infos
+
+def findParameterType(parameter):
+ if "value_list" in parameter["informations"]:
+ return "enum"
+ if "min" in parameter["informations"] or "max" in parameter["informations"] or re.match(r"^\d+U?L?$", parameter["value"]) != None:
+ return "int"
+
+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)
+
+def isInt(informations):
+ """
+ Return True if the value is a simple int.
+ """
+ if ("long" not in informatios or not informations["long"]) and ("unsigned" not in informations or informations["unsigned"]):
+ return True
+ else:
+ return False
+
+def isLong(informations):
+ """
+ Return True if the value is a long.
+ """
+ if "long" in informations and informations["long"] and "unsigned" not in informations:
+ return True
+ else:
+ return False
+
+def isUnsigned(informations):
+ """
+ Return True if the value is an unsigned.
+ """
+ if "unsigned" in informations and informations["unsigned"] and "long" not in informations:
+ return True
+ else:
+ return False
+
+def isUnsignedLong(informations):
+ """
+ Return True if the value is an unsigned long.
+ """
+ if "unsigned" in informations and "long" in informations and informations["unsigned"] and informations["long"]:
+ return True
+ else:
+ return False
+
+class ParseError(Exception):
+ def __init__(self, line_number, line):
+ Exception.__init__(self)
+ self.line_number = line_number
+ self.line = line
+
+class SupportedException(Exception):
+ def __init__(self, support_string):
+ Exception.__init__(self)
+ self.support_string = support_string
\ No newline at end of file