397 lines
18 KiB
Python
Executable File
397 lines
18 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# coding=utf-8
|
|
|
|
#===============================================================================
|
|
# @brief XML tools
|
|
# Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd.
|
|
#===============================================================================
|
|
import ctypes
|
|
import sys
|
|
import inspect
|
|
import os
|
|
import re
|
|
from xml.etree import ElementTree
|
|
from xml.dom import minidom
|
|
|
|
sys.path.append(os.path.join("build", "script", "hdbxml_custom", "parse"))
|
|
import parse_msgdefs
|
|
|
|
|
|
def isStackmessage(id, core):
|
|
if (core in ['protocol_core']) and ((id >> 26) != 0x10):
|
|
return True
|
|
return False
|
|
|
|
def swap16(x):
|
|
return (((x << 8) & 0xFF00) |
|
|
((x >> 8) & 0x00FF))
|
|
|
|
def swap32(x):
|
|
return (((x << 24) & 0xFF000000) |
|
|
((x << 8) & 0x00FF0000) |
|
|
((x >> 8) & 0x0000FF00) |
|
|
((x >> 24) & 0x000000FF))
|
|
|
|
def getIdFromParts(core, msg_class, msg_module, msg_id):
|
|
return (((core << 30) & 0xC0000000) | ((msg_class << 29) & 0x20000000) | ((msg_module << 16) & 0x00FF0000) | (swap16(msg_id) & 0x0000FFFF))
|
|
|
|
def getIdForMessage(id, core):
|
|
if isStackmessage(id, core):
|
|
# A stack message needs to be dissasembled and put back together
|
|
msg_module = (((id) >> 24) & 0xFF)
|
|
msg_log = (((id) >> 21) & 0x1)
|
|
msg_verbosity = (((id) >> 22) & 0x3)
|
|
msg_id = (((id) & 0x3ff) | (msg_log << 13) | (msg_verbosity << 14))
|
|
messageIDOut = getIdFromParts(1, 1, msg_module, msg_id)
|
|
else:
|
|
# All other messages need their low two bytes swapped
|
|
messageIDOut = ((id) & 0xFFFF0000) | (((id) & 0x0000FF00) >> 8) | (((id) & 0x000000FF) << 8)
|
|
|
|
messageIDOut = swap32(messageIDOut)
|
|
|
|
return messageIDOut
|
|
|
|
def getFirmwareVersion():
|
|
versionfile = os.path.join("build_scons", "VERSION_STRING")
|
|
if os.path.exists(versionfile):
|
|
with open(versionfile) as f:
|
|
firmware_version = f.read().strip()
|
|
else:
|
|
# This can happen when the messagexml generation is used outside the build.
|
|
# The DSP build uses this via tools/scripts/messagesxml.bat
|
|
firmware_version = "UNKNOWN"
|
|
return firmware_version
|
|
|
|
# just used to include comments from rules files.
|
|
class CommentedTreeBuilder(ElementTree.TreeBuilder):
|
|
def __init__(self, *args, **kwargs):
|
|
super(CommentedTreeBuilder, self).__init__(*args, **kwargs)
|
|
|
|
def comment(self, data):
|
|
self.start(ElementTree.Comment, {})
|
|
self.data(data)
|
|
self.end(ElementTree.Comment)
|
|
|
|
class messageTree(object):
|
|
def __init__(self, distribution, firmware_version, coreName, imageName):
|
|
self.parser = ElementTree.XMLParser(target=CommentedTreeBuilder())
|
|
ElementTree.register_namespace("","http://tempuri.org/xmlDefinition.xsd" )
|
|
debugInformationAttributes = { \
|
|
'Distribution': distribution, \
|
|
'FirmwareVersion':firmware_version, \
|
|
'MulticoreLoggingSupported':"true", \
|
|
'SocXMLVersion':"2", \
|
|
'SequenceNumbersSupported':"true", \
|
|
'xmlns':"http://tempuri.org/xmlDefinition.xsd", \
|
|
}
|
|
if imageName in ['SEBoot', 'SERecovery', 'updater']:
|
|
isBootImage = 'true'
|
|
else:
|
|
isBootImage = 'false'
|
|
coreAttributes = { \
|
|
'CoreName': str(coreName), \
|
|
'ImageName': str(imageName), \
|
|
'BootImage': isBootImage, \
|
|
}
|
|
|
|
self.top = ElementTree.Element('DebugInformation', debugInformationAttributes)
|
|
self.tree = ElementTree.ElementTree(element=self.top, file=None)
|
|
loghdr = ElementTree.SubElement(self.top, 'CommonLogHeader', {'LogIndexMask': '0x0000001F'})
|
|
coreEntry = ElementTree.SubElement(self.top, 'Core', coreAttributes)
|
|
|
|
self.messages = ElementTree.SubElement(coreEntry, 'Messages')
|
|
self.structs_dict = ElementTree.SubElement(coreEntry, 'StructureDictionary')
|
|
self.enums_dict = ElementTree.SubElement(coreEntry, 'EnumsDictionary')
|
|
|
|
def addMessageHeader(self, messageEnumName, messageId, core, elemName):
|
|
messageAttributes = { \
|
|
'Name': messageEnumName, \
|
|
'MessageID': "0x"+str(hex(messageId))[2:].zfill(8), \
|
|
'Type': 'structure', \
|
|
}
|
|
if isStackmessage(messageId, core):
|
|
messageAttributes['MessageType'] = 'StackMessage'
|
|
message = ElementTree.SubElement(self.messages, "Message",messageAttributes)
|
|
return message
|
|
|
|
def addStructure(self, nodeTypeName, fieldElementType, elementSize):
|
|
structureAttributes = { \
|
|
'Type': nodeTypeName, \
|
|
'FieldType': fieldElementType, \
|
|
}
|
|
fieldEntry = ElementTree.SubElement(self.structs_dict, 'Structure', structureAttributes)
|
|
return fieldEntry
|
|
|
|
def structureInDictionary(self, structName):
|
|
found = False
|
|
for i in self.structs_dict:
|
|
nameEntry = i.attrib["Type"]
|
|
if structName == nameEntry:
|
|
found = True
|
|
return found
|
|
|
|
def addField(self, parent, fieldName, nodeTypeName, fieldElementType, elementSize, length, enumName):
|
|
fieldAttributes = { \
|
|
'FieldName': fieldName, \
|
|
'Type': nodeTypeName, \
|
|
'FieldType': fieldElementType, \
|
|
'Size': str(elementSize), \
|
|
'Length': str(length), \
|
|
}
|
|
if enumName is not None:
|
|
fieldAttributes['Enum'] = enumName
|
|
fieldSubEntry = ElementTree.SubElement(parent, 'Field', fieldAttributes)
|
|
return fieldSubEntry
|
|
|
|
def addEnum(self, enum_type_name, enumList):
|
|
found = False
|
|
for i in self.enums_dict:
|
|
nameEntry = i.find("Name").text
|
|
if enum_type_name == nameEntry:
|
|
found = True
|
|
|
|
if not found:
|
|
enumsEntry = ElementTree.SubElement(self.enums_dict, 'EnumsEntry')
|
|
enumName = ElementTree.SubElement(enumsEntry, 'Name')
|
|
enumName.text = enum_type_name
|
|
#enumsArray = ElementTree.SubElement(enumsEntry, 'Enums')
|
|
for name, val in enumList:
|
|
self.addEnumEntry(enumsEntry, name, val)
|
|
|
|
def addEnumEntry(self, parent, name, val):
|
|
enumAttributes = { \
|
|
'Name': name, \
|
|
'Value': str(val), \
|
|
}
|
|
enumValueEntry = ElementTree.SubElement(parent, 'Enum', enumAttributes)
|
|
|
|
def dump(self):
|
|
return ElementTree.dump(self.top)
|
|
|
|
def prettify(self, elem, encoding = 'utf-8'):
|
|
"""Return a pretty-printed XML string for the Element.
|
|
"""
|
|
initial_string = ElementTree.tostring(elem, encoding=encoding, method='xml')
|
|
reparsed_string = minidom.parseString(initial_string)
|
|
return reparsed_string.toprettyxml(indent=" ")
|
|
|
|
def write_xml_file (self, file, xml_root_element, xml_declaration=False, pretty_print=False, encoding='unicode', indent='\t'):
|
|
if xml_declaration:
|
|
file.write('<?xml version="1.0" encoding="utf-8" ?>')
|
|
pretty_printed_xml = self.prettify(xml_root_element, encoding = 'utf-8')
|
|
file.write(pretty_printed_xml)
|
|
|
|
def outputMessageTree(self, regexp, rulesfilename, outfilename):
|
|
if regexp:
|
|
matcher = re.compile(regexp)
|
|
|
|
# Filter out any messages we don't want to publish, then add the rules and write it out
|
|
internal_message_list = []
|
|
for message in self.messages:
|
|
name = message.attrib['Name']
|
|
internal = regexp and matcher.search(name) is not None
|
|
if internal:
|
|
internal_message_list.append(message)
|
|
|
|
for message in internal_message_list:
|
|
name = message.attrib['Name']
|
|
self.messages.remove(message)
|
|
|
|
if rulesfilename != None:
|
|
rules_data = ElementTree.parse(rulesfilename, self.parser)
|
|
if rules_data is None:
|
|
raise SystemExit('Error: failed to parse %s' % rulesfilename)
|
|
rules_root = rules_data.getroot()
|
|
if rules_root is None:
|
|
raise SystemExit('Error: failed to find root section in %s' % rulesfilename)
|
|
rulesEntry = self.top.find('Core')
|
|
if rulesEntry is None:
|
|
raise SystemExit('Error: failed to find "Core" section')
|
|
rulesEntry.extend(rules_root)
|
|
|
|
with open(outfilename, 'w') as outfile:
|
|
self.write_xml_file(outfile, self.top, xml_declaration=False, pretty_print=True, encoding='unicode', indent='\t')
|
|
|
|
|
|
# Taking some ctypes element, recursively analyse it, and build a tree of nodes representing it
|
|
def buildTree(xmlTree, message_fields, elem):
|
|
if hasattr(elem, "_fields_"):
|
|
for field in elem._fields_:
|
|
structAlreadyPopulated = False
|
|
current_message_fields = message_fields
|
|
fieldType = field[1]
|
|
arrayItemNamePostfix=''
|
|
|
|
# This is potentiallay a multi-dimensional array that must be descended into so do so until an actual type is encountered
|
|
while True:
|
|
# If this is an array there will be some kind of length
|
|
length = fieldType._length_ if hasattr(fieldType, "_length_") else 1
|
|
# This size includes all the different elements (if this is an array) or just the size of the single field if not
|
|
size = ctypes.sizeof(fieldType)
|
|
# Deduce the size of a single element
|
|
elementSize = size // length
|
|
# Pointers have a "contents" attribute
|
|
isPointer = hasattr(fieldType, "contents")
|
|
|
|
# Simple single dimension arrays can be handled using the length
|
|
isSomeKindOfArray = issubclass(fieldType, ctypes.Array)
|
|
if isSomeKindOfArray:
|
|
# This is some kind of array so get the element within the array - the fieldType from now onwards is within the array
|
|
fieldType = fieldType._type_
|
|
|
|
# Base types have no fields in their "type" (note - arrays of base types are considered to be base types)
|
|
isBaseType = not hasattr(fieldType, "_fields_")
|
|
isUnion = isinstance(fieldType, ctypes.Union)
|
|
isEnum = hasattr(fieldType, "members")
|
|
|
|
if isEnum:
|
|
for class_ in inspect.getmro(fieldType):
|
|
if issubclass(class_, ctypes._SimpleCData) and class_ is not fieldType:
|
|
fullTypeName = class_
|
|
break
|
|
else:
|
|
raise TypeError("Can't find a ctypes class to use for enum %s" % fieldType)
|
|
else:
|
|
fullTypeName = fieldType
|
|
|
|
# Extract a useful type name from the verbose name in CTypes
|
|
(junk, separator, fullTypeName) = str(fullTypeName).partition(".")
|
|
(fullTypeName, separator, junk) = fullTypeName.partition("'")
|
|
|
|
# Check to see if there are further array dimensions that need to be unwrapped and if not exit to actually
|
|
if not issubclass(fieldType, ctypes.Array):
|
|
break
|
|
|
|
# This is a multi-dimensional array so use a fake struct here to hold the next dimensionality
|
|
arrayItemNamePostfix='_item'
|
|
nodeTypeName = ''.join(["struct_", fullTypeName])
|
|
fieldEntry = xmlTree.addField(current_message_fields, field[0], nodeTypeName, 'struct', elementSize, length, enum_type_name)
|
|
|
|
# If the fake structure has already been populated then stop here
|
|
if xmlTree.structureInDictionary(nodeTypeName):
|
|
structAlreadyPopulated = True
|
|
break
|
|
|
|
# Add the fake struct definition and start populating it during the next iteration
|
|
current_message_fields = xmlTree.addStructure(nodeTypeName, 'struct', elementSize)
|
|
|
|
# Only need to do anything if a struct has not already been populated
|
|
if not structAlreadyPopulated:
|
|
# Now dealing with something that is not an array
|
|
(friendlyTypeName, separator, junk) = fullTypeName.partition("_Array_")
|
|
nodeTypeName = friendlyTypeName
|
|
if 'struct' in nodeTypeName and not isPointer:
|
|
fieldElementType = 'struct'
|
|
elif 'union' in nodeTypeName:
|
|
fieldElementType = 'union'
|
|
else:
|
|
fieldElementType = 'base'
|
|
|
|
if isEnum:
|
|
enum_type_name = inspect.getmro(fieldType)[0].__name__
|
|
xmlTree.addEnum(enum_type_name, sorted(fieldType.members.items()))
|
|
else:
|
|
enum_type_name = None
|
|
|
|
# write the message entry in all cases.
|
|
fieldEntry = xmlTree.addField(current_message_fields, field[0] + arrayItemNamePostfix, nodeTypeName, fieldElementType, elementSize, length, enum_type_name)
|
|
|
|
# if it's a structure add to structure dict etc, if not it's a base type and go to the next one
|
|
if fieldElementType == 'struct':
|
|
if not xmlTree.structureInDictionary(nodeTypeName):
|
|
fields_SubEntry = xmlTree.addStructure(nodeTypeName, fieldElementType, elementSize)
|
|
buildTree(xmlTree, fields_SubEntry, fieldType)
|
|
else:
|
|
if not isBaseType and not isPointer:
|
|
buildTree(xmlTree, fieldEntry, fieldType)
|
|
|
|
|
|
def xml_gen_main(outputBasepath, source, cfgfilename, core, image, rulesfilename):
|
|
messages = parse_msgdefs.parse_preprocessed_headers(source, core)
|
|
# Load the configuration file
|
|
with open(cfgfilename) as cfgfile:
|
|
if cfgfile == None:
|
|
raise SystemExit("Error: Could not find configuration file %s." % cfgfilename)
|
|
|
|
# Load the core
|
|
if core not in ['acore', 'protocol_core', 'security_core']:
|
|
raise SystemExit("Error: Invalid core %s." % core)
|
|
|
|
if rulesfilename is not None:
|
|
with open(rulesfilename) as rulesfile:
|
|
if rulesfile == None:
|
|
raise SystemExit("Error: Could not find rules file %s." %rulesfilename)
|
|
|
|
# List of filenames and regular expressions
|
|
if not os.path.isdir(outputBasepath):
|
|
# If given an output filename rather than base directory,
|
|
# strip off the filename and keep the path
|
|
outputBasepath = os.path.dirname(outputBasepath)
|
|
|
|
outputs = []
|
|
|
|
# Parse the pairs of filenames and regular expressions
|
|
for line in cfgfile.readlines():
|
|
if not line.startswith("#"): # Exclude comments
|
|
if line.strip() != "": # Exclude empty lines
|
|
# Format is: filename , regexp
|
|
distribution, filename, regexp = line.split(",", 2)
|
|
# Remove regexp whitespace
|
|
regexp = regexp.strip()
|
|
# Remove whitespace and add base path
|
|
filename = filename.strip()
|
|
filename = os.path.join(outputBasepath, filename)
|
|
outputs.append((distribution, filename, regexp))
|
|
|
|
firmware_version = getFirmwareVersion()
|
|
|
|
for distribution, outfilename, regexp in outputs:
|
|
#with messageTree(distribution, firmware_version, core) as xmlTree:
|
|
xmlTree = None
|
|
xmlTree = messageTree(distribution, firmware_version, core, image)
|
|
|
|
# And a list of message IDs already used
|
|
# (These should ideally be stored in a tree for scalable search speed, but the number of messages is small so the wasted time isn't a problem)
|
|
messageIdList = []
|
|
|
|
for messageEnumName, structname, messageId, struct in messages:
|
|
# If not a stack xml then convert the IDs to the log IDs
|
|
#
|
|
# if distribution != "stack":
|
|
# messageId = getIdForMessage(messageId, core)
|
|
fieldsEntry = xmlTree.addMessageHeader(messageEnumName, messageId, core, structname)
|
|
buildTree(xmlTree, fieldsEntry, struct)
|
|
|
|
xmlTree.outputMessageTree(regexp, rulesfilename, outfilename)
|
|
del xmlTree
|
|
|
|
|
|
if len(sys.argv) < 6:
|
|
raise SystemExit("Usage: python MessageXmlGen.py <ctypes_library> <output_dir> <configuration_file> <corename> <imagename> [<rules_file>]")
|
|
|
|
source = sys.argv[1]
|
|
outputBasepath = sys.argv[2]
|
|
cfgfilename = sys.argv[3]
|
|
corename = sys.argv[4]
|
|
imagename = sys.argv[5]
|
|
|
|
# Optional Rules File
|
|
if len(sys.argv) == 7:
|
|
rulesfilename = sys.argv[6]
|
|
else:
|
|
rulesfilename = None
|
|
|
|
# 删除.i文件中的#pragma预编译指令
|
|
with open(source, "rb+") as f:
|
|
write_lines = []
|
|
for line in f.readlines():
|
|
if not re.match("#pragma", line.decode("utf-8", errors="replace").strip()):
|
|
write_lines.append(line)
|
|
f.seek(0, 0)
|
|
f.truncate()
|
|
|
|
for line in write_lines:
|
|
f.write(line)
|
|
|
|
xml_gen_main(outputBasepath, source, cfgfilename, corename, imagename, rulesfilename)
|