def process(self, fileName, includeMacros = False):
"""
Process the macro declarations present in a file and return the resulting string.
@param fileName: Name of file to parse
@param includeMacros: Pass True to include the preprocessor macros in the output
"""
cmd = [self.binary]
if self.arguments:
cmd.append(self.arguments)
if includeMacros:
cmd.append("-dD")
# Don't include predefined macros
cmd.append("-undef")
for macro, value in self.config.get("macros", {}).items():
cmd.append("-D%s=%s" % (macro, value))
if self.platform.name in self.config:
plat = self.config[self.platform.name]
for lib in plat.get("includedirs", []):
cmd.append("-I")
cmd.append(lib)
for macro, value in plat.get("macros", {}).items():
cmd.append("-D%s=%s" % (macro, value))
cmd.append(fileName)
if self.options.verbose:
Log.debug("Running preprocessor: " + " ".join(cmd))
p = subprocess.Popen(cmd, stdout = subprocess.PIPE)
return p.stdout.read()
def loadHooks(self):
target = self.target
config = self.target.config
lib = self.target.library
platform = self.target.project.platform
# Collect hooks in various locations
for fileName in config.get("hooks", []):
Log.notice("Parsing hooks from '%s'." % fileName)
source = self.readSource(fileName)
functions = Parser.parseSource(source).functions.values()
if not functions:
Log.warn("No hooks found.")
for f in functions:
Log.debug("%s %s(%s)" % (f.type, f.name, ", ".join(["%s %s" % (t.type, p) for p, t in f.parameters.items()])))
for function in functions:
if not function.body:
Log.warn("Hook function '%s' has no body." % function.name)
continue
if function.name.startswith("@"):
lib.hooks[function.name] = function.body
continue
else:
try:
name, hookName = function.name.split(".", 1)
if not name in lib.functions:
target.fail("Function '%s' referred by hook function '%s' does not exist." % (name, function.name))
if not hookName.startswith("@") and not hookName in lib.functions[name].parameters:
target.fail("Parameter '%s' referred by hook function '%s' does not exist." % (hookName, function.name))
lib.functions[name].hooks[hookName] = function.body
except ValueError:
target.fail("Hook function name '%s' is not valid." % function.name)
def loadHooks(self):
target = self.target
config = self.target.config
lib = self.target.library
platform = self.target.project.platform
# Collect hooks in various locations
for fileName in config.get("hooks", []):
Log.notice("Parsing hooks from '%s'." % fileName)
source = self.readSource(fileName)
functions = Parser.parseSource(source).functions.values()
if not functions:
Log.warn("No hooks found.")
for f in functions:
Log.debug("%s %s(%s)" % (f.type, f.name, ", ".join(
["%s %s" % (t.type, p) for p, t in f.parameters.items()])))
for function in functions:
if not function.body:
Log.warn("Hook function '%s' has no body." % function.name)
continue
if function.name.startswith("@"):
lib.hooks[function.name] = function.body
continue
else:
try:
name, hookName = function.name.split(".", 1)
if not name in lib.functions:
target.fail(
"Function '%s' referred by hook function '%s' does not exist."
% (name, function.name))
if not hookName.startswith(
"@"
) and not hookName in lib.functions[name].parameters:
target.fail(
"Parameter '%s' referred by hook function '%s' does not exist."
% (hookName, function.name))
lib.functions[name].hooks[hookName] = function.body
except ValueError:
target.fail("Hook function name '%s' is not valid." %
function.name)
def reportDebug(self, msg):
for line in str(msg).rstrip().split("\n"):
Log.debug(line)
conflicts = self._file_conflicts(torrent_id,
deluge_movements,
filebot_results[2])
if conflicts:
log.warning('Rename unsafe for torrent {0}, conflicting files:{1}'.format(
torrent_id, conflicts))
log.warning('Rolling back torrent {0}.'.format(torrent_id))
self._rollback(filebot_results, torrent_id)
defer.returnValue((False, "Rename is not safe on torrent {0}.\n"
"The following files already exsist:\n"
"{1}"
"Rolling Back and recheking.".format(torrent_id,
''.join(' ' + f + '\n' for f in conflicts))))
log.debug("Attempting to re-reoute torrent: {00}".format(
deluge_movements))
self._redirect_torrent_paths(torrent_id, deluge_movements,
original_state=original_torrent_state)
defer.returnValue((True, None))
@export
def save_rename_dialog_settings(self, new_settings):
log.debug("recieved settings from client: {0}".format(new_settings))
for setting in DEFAULT_PREFS["rename_dialog_last_settings"]:
try:
if new_settings[setting] is not None:
self.config["rename_dialog_last_settings"][setting] = (
new_settings[setting])
try:
log.debug("setting saved: {0} : {1}".format(
setting, new_settings[setting]))
def prepare(self):
# Shorthand for various objects
config = self.config
lib = self.library
# Parse the sources
for fileName in config.get("apiheaders", []):
Log.notice("Parsing functions from '%s'." % fileName)
source = self.parserTool.readSource(fileName)
newLib = Parser.parseSource(source)
for f in newLib.functions.values():
f.headerName = fileName
for f in newLib.functions.values():
Log.debug("%s %s(%s)" % (f.type, f.name, ", ".join(["%s %s" % (t.type, p) for p, t in f.parameters.items()])))
if not newLib.functions:
Log.warn("No new functions found.")
else:
Log.notice("%d functions found." % len(newLib.functions))
lib.merge(newLib)
# Load the hooks
self.parserTool.loadHooks()
def parseBool(s):
return bool(int(s))
# Read the typemap
for typeDecl, mapping in self.config.types.items():
attrs = self.config.types[typeDecl].attrs
name, type = Parser.parseVariableDeclaration(typeDecl + " dummy")
assert name == "dummy"
# If this is a class mapping, create the class if it doesn't already exist
if mapping == "object":
if not mapping in self.library.classes:
cls = Library.Class(type)
if "namespace" in attrs:
cls.namespacePath = attrs["namespace"].split(".")
self.library.classes[type] = cls
# Patch the default decoration hint into all matching types
if "decorationhint" in attrs:
for function in self.library.functions.values():
for t in [p.type for p in function.parameters.values()] + [function.type]:
if t == type:
t.decorationHint = attrs["decorationhint"]
self.library.typeMap[type] = str(mapping)
# Patch in some function-specific attributes
for function in config.functions.keys():
if not function in lib.functions:
self.fail("Attributes specified for non-existent function '%s'." % function)
attrs = config.functions[function].attrs
if "terminator" in attrs:
lib.functions[function].isTerminator = parseBool(attrs["terminator"])
if "generate" in attrs:
lib.functions[function].generate = parseBool(attrs["generate"])
if "runtimestate" in attrs:
lib.functions[function].runtimeStateTracking = parseBool(attrs["runtimestate"])
if "framemarker" in attrs:
lib.functions[function].isFrameMarker = parseBool(attrs["framemarker"])
if "staticlinkage" in attrs:
lib.functions[function].staticLinkage = parseBool(attrs["staticlinkage"])
if "rendercall" in attrs:
lib.functions[function].isRenderCall = parseBool(attrs["rendercall"])
if "passthrough" in attrs:
lib.functions[function].passthrough = parseBool(attrs["passthrough"])
if not isinstance(config.functions[function], Config.Group):
self.fail("Syntax error: State map definition for function '%s' is missing braces." % function)
# Argument to state mapping
reservedNames = ["@return", "@modify", "@set", "@get", "@copy"]
funcAttrs = attrs
for arg, parameter in config.functions[function].items():
# Check that this is a valid parameter
if not arg in reservedNames and not arg in lib.functions[function].parameters:
self.fail("State mapping for nonexistent parameter '%s' of function '%s' specified." % (arg, function))
if arg in ["@copy"] and parseBool(funcAttrs.get("runtimestate", "0")):
Log.warn("Function %s state relation %s not implemented for runtime state tracking." % (function, arg))
# Read the parameter-specific attributes
attrs = config.functions[function][arg].attrs
if "decoration" in attrs:
lib.functions[function].parameters[arg].decoration = attrs["decoration"]
if "decorationhint" in attrs:
lib.functions[function].parameters[arg].decorationHint = attrs["decorationhint"]
if "out" in attrs:
lib.functions[function].parameters[arg].isOut = parseBool(attrs["out"])
if "object_class" in attrs:
# Create a function-local type so that this parameter type is an object only for this function
if arg == "@return":
type = lib.functions[function].type
else:
type = lib.functions[function].parameters[arg].type
# Override the type's name so that it will refer to the new object class
# while still using the original C type under the hood
newType = copy.deepcopy(type)
newType.isObject = True
newType.name = attrs["object_class"]
if arg == "@return":
lib.functions[function].type = newType
else:
lib.functions[function].parameters[arg].type = newType
# Check that this class exists
classType = Library.Type(attrs["object_class"])
if not classType in self.library.classes:
self.fail("Undefined object class '%s'." % classType)
# Do we have a meta type?
if "metatype" in config.functions[function][arg]:
metaGroup = config.functions[function][arg].metatype
try:
metaType = Library.MetaType(metaGroup.attrs["class"])
except KeyError:
self.fail("Meta type for parameter '%s' does not define class." % arg)
# Is this an array parameter?
if metaType.name == "array":
metaType.values["size"] = Library.MetaValue("size", metaGroup.attrs.get("size", 1))
if "type" in metaGroup.attrs:
metaType.values["type"] = Library.MetaValue("type", metaGroup.attrs["type"])
if metaGroup.attrs["type"] == "object":
if not "object_class" in metaGroup.attrs:
self.fail("Required metatype attribute object_class missing")
metaType.values["object_class"] = Library.MetaValue("object_class", metaGroup.attrs["object_class"])
# How about an image parameter?
elif metaType.name == "image":
metaType.values["stride"] = Library.MetaValue("stride", metaGroup.attrs.get("stride", "width"))
metaType.values["height"] = Library.MetaValue("height", metaGroup.attrs.get("height", "height"))
metaType.values["components"] = Library.MetaValue("components", metaGroup.attrs.get("components", "1"))
metaType.values["type"] = Library.MetaValue("type", metaGroup.attrs.get("type", "byte"))
else:
self.fail("Unknown meta type class '%s'." % metaclass)
Log.debug("Meta type: %s.%s: %s" % (function, arg, metaType.name))
# Get the conditions for different meta values
if isinstance(metaGroup, Config.List):
for item in metaGroup:
predicate = item.attrs["condition"]
predicateValue = item.attrs["value"]
result = item.attrs["result"]
metaType.values[item].addPredicate(predicate, predicateValue, result)
Log.debug("Meta type condition: If %s is %s, then %s = %s" % (predicate, predicateValue, item, result))
elif isinstance(metaGroup, Config.Group):
Log.error("Meta type variations for parameter '%s' represented in a group instead of a list." % arg)
# Record the meta type
lib.functions[function].parameters[arg].metaType = metaType
# Is this a short-hand state mapping?
try:
path = parameter.split(".")
except AttributeError:
# Try the expanded form of a nested attribute set
try:
path = (config.functions[function][arg].state).split(".")
except AttributeError:
path = []
# Check that we even have a state structure
if path and not "state" in config:
Log.warn("State structure not defined.")
continue
# Parse special state mapping relations
relation = None
checkPaths = []
if arg == "@copy":
relation = Library.StateRelationCopy(attrs["src"].split("."), attrs["dest"].split("."))
checkPaths = [relation.sourcePath, relation.destPath]
elif arg == "@get":
relation = Library.StateRelationGet(path)
checkPaths = [relation.path]
elif arg == "@set":
relation = Library.StateRelationSet(path)
checkPaths = [relation.path]
elif arg == "@modify":
relation = Library.StateRelationModify(path)
checkPaths = [relation.path]
# Empty mapping?
elif not "".join(path):
continue
if relation:
for path in checkPaths:
if traverseStatePath(config, path) is None:
self.fail("Relation state path '%s' for function '%s' does not exist." % (".".join(path), function))
Log.debug("State relation: %s %s" % (function, relation))
lib.functions[function].stateRelations.append(relation)
continue
Log.debug("State mapping: %s.%s -> %s" % (function, arg, ".".join(path)))
# Determine the parameter type
type = None
if arg == "@return":
type = lib.functions[function].type
else:
type = lib.functions[function].parameters[arg].type
# If this is a runtime mapping, check that the parameter is of a supported type
if lib.functions[function].runtimeStateTracking and type and \
lib.getNativeType(type) in ["float", "double"]:
self.fail("Values of type '%s' can not be saved to the runtime state tree" % type)
continue
node = traverseStatePath(config, path)
if node is None:
self.fail("State path '%s' for function '%s' does not exist." % (".".join(path), function))
# Save the mapping
if arg == "@return":
lib.functions[function].retStateRelation = Library.StateRelationSet(path)
else:
lib.functions[function].parameters[arg].stateRelation = Library.StateRelationSet(path)
def loadSymbolMap(self):
config = self.config
lib = self.library
demangler = Tools.SymbolDecoder(config)
# Set default library name
if "library" in config:
for function in lib.functions.values():
function.libName = config.library
# Read in the export ordinals
if "deffiles" in config:
for defFile in config.deffiles:
for function, ordinal in Parser.parseDefFile(open(config.getRelativePath(defFile)).read()):
if function in lib.functions:
lib.functions[function].exportOrdinal = ordinal
Log.debug("%s is exported at %d" % (function, ordinal))
# The function was not found in the library, so let's check whether it is a C++ symbol
elif demangler.isMangled(function):
function = demangler.decode(function)
if function in lib.functions:
# Save the ordinal and mark the function as C++
lib.functions[function].exportOrdinal = ordinal
lib.functions[function].language = "c++"
Log.debug("%s is exported at %d" % (function, ordinal))
# Read the link ordinals and DLL information
if "symbol_map" in config:
defaultLibName = None
for fileName, libName in config.symbol_map.items():
if fileName == "default":
defaultLibName = libName
continue
# Is it a .DEF file
if fileName.endswith(".def"):
for function, ordinal in Parser.parseDefFile(open(config.getRelativePath(fileName)).read()):
if function in lib.functions:
lib.functions[function].ordinal = ordinal
lib.functions[function].libName = libName
Log.debug("%s is at %s:%d" % (function, libName, ordinal))
# The function was not found in the library, so let's check whether it is a C++ symbol
elif demangler.isMangled(function):
function = demangler.decode(function)
if function in lib.functions:
# Save the ordinal and mark the function as C++
lib.functions[function].ordinal = ordinal
lib.functions[function].libName = libName
lib.functions[function].language = "c++"
Log.debug("%s is at %s:%d" % (function, libName, ordinal))
else: # it's a header file
assert fileName.endswith(".h")
for function in lib.functions.values():
if function.headerName == fileName:
function.libName = libName
# Generate passthrough functions for internal symbols
if defaultLibName:
assert self.project.platform.requireOrdinals, "Default symbol mapping can only be used in platforms that use symbol ordinals"
assert "max_internal_ordinal" in config, "max_internal_ordinal must be defined when using a default symbol mapping"
ordinals = range(1, int(config["max_internal_ordinal"]) + 1)
for function in lib.functions.values():
if function.exportOrdinal in ordinals:
ordinals.remove(function.exportOrdinal)
for ordinal in ordinals:
name = "_trInternal%d" % ordinal
f = Library.Function(name, Library.Type("void"))
f.language = "c"
f.ordinal = ordinal
f.exportOrdinal = ordinal
f.libName = defaultLibName
lib.functions[name] = f
Log.debug("%s is at %s:%d" % (name, defaultLibName, ordinal))
def generate(templatePath, outputPath):
Log.debug("Generating %s" % (outputPath[-1]))
Generator.generate(templates = [Resource.getPath(*templatePath)],
namespace = namespace,
outputFile = open(os.path.join(*outputPath), "w"))
def prepare(self):
# Shorthand for various objects
config = self.config
lib = self.library
# Parse the sources
for fileName in config.get("apiheaders", []):
Log.notice("Parsing functions from '%s'." % fileName)
source = self.parserTool.readSource(fileName)
newLib = Parser.parseSource(source)
for f in newLib.functions.values():
f.headerName = fileName
for f in newLib.functions.values():
Log.debug("%s %s(%s)" % (f.type, f.name, ", ".join(
["%s %s" % (t.type, p) for p, t in f.parameters.items()])))
if not newLib.functions:
Log.warn("No new functions found.")
else:
Log.notice("%d functions found." % len(newLib.functions))
lib.merge(newLib)
# Load the hooks
self.parserTool.loadHooks()
def parseBool(s):
return bool(int(s))
# Read the typemap
for typeDecl, mapping in self.config.types.items():
attrs = self.config.types[typeDecl].attrs
name, type = Parser.parseVariableDeclaration(typeDecl + " dummy")
assert name == "dummy"
# If this is a class mapping, create the class if it doesn't already exist
if mapping == "object":
if not mapping in self.library.classes:
cls = Library.Class(type)
if "namespace" in attrs:
cls.namespacePath = attrs["namespace"].split(".")
self.library.classes[type] = cls
# Patch the default decoration hint into all matching types
if "decorationhint" in attrs:
for function in self.library.functions.values():
for t in [p.type for p in function.parameters.values()
] + [function.type]:
if t == type:
t.decorationHint = attrs["decorationhint"]
self.library.typeMap[type] = str(mapping)
# Patch in some function-specific attributes
for function in config.functions.keys():
if not function in lib.functions:
self.fail(
"Attributes specified for non-existent function '%s'." %
function)
attrs = config.functions[function].attrs
if "terminator" in attrs:
lib.functions[function].isTerminator = parseBool(
attrs["terminator"])
if "generate" in attrs:
lib.functions[function].generate = parseBool(attrs["generate"])
if "runtimestate" in attrs:
lib.functions[function].runtimeStateTracking = parseBool(
attrs["runtimestate"])
if "framemarker" in attrs:
lib.functions[function].isFrameMarker = parseBool(
attrs["framemarker"])
if "staticlinkage" in attrs:
lib.functions[function].staticLinkage = parseBool(
attrs["staticlinkage"])
if "rendercall" in attrs:
lib.functions[function].isRenderCall = parseBool(
attrs["rendercall"])
if "passthrough" in attrs:
lib.functions[function].passthrough = parseBool(
attrs["passthrough"])
if not isinstance(config.functions[function], Config.Group):
self.fail(
"Syntax error: State map definition for function '%s' is missing braces."
% function)
# Argument to state mapping
reservedNames = ["@return", "@modify", "@set", "@get", "@copy"]
funcAttrs = attrs
for arg, parameter in config.functions[function].items():
# Check that this is a valid parameter
if not arg in reservedNames and not arg in lib.functions[
function].parameters:
self.fail(
"State mapping for nonexistent parameter '%s' of function '%s' specified."
% (arg, function))
if arg in ["@copy"] and parseBool(
funcAttrs.get("runtimestate", "0")):
Log.warn(
"Function %s state relation %s not implemented for runtime state tracking."
% (function, arg))
# Read the parameter-specific attributes
attrs = config.functions[function][arg].attrs
if "decoration" in attrs:
lib.functions[function].parameters[arg].decoration = attrs[
"decoration"]
if "decorationhint" in attrs:
lib.functions[function].parameters[
arg].decorationHint = attrs["decorationhint"]
if "out" in attrs:
lib.functions[function].parameters[arg].isOut = parseBool(
attrs["out"])
if "object_class" in attrs:
# Create a function-local type so that this parameter type is an object only for this function
if arg == "@return":
type = lib.functions[function].type
else:
type = lib.functions[function].parameters[arg].type
# Override the type's name so that it will refer to the new object class
# while still using the original C type under the hood
newType = copy.deepcopy(type)
newType.isObject = True
newType.name = attrs["object_class"]
if arg == "@return":
lib.functions[function].type = newType
else:
lib.functions[function].parameters[arg].type = newType
# Check that this class exists
classType = Library.Type(attrs["object_class"])
if not classType in self.library.classes:
self.fail("Undefined object class '%s'." % classType)
# Do we have a meta type?
if "metatype" in config.functions[function][arg]:
metaGroup = config.functions[function][arg].metatype
try:
metaType = Library.MetaType(metaGroup.attrs["class"])
except KeyError:
self.fail(
"Meta type for parameter '%s' does not define class."
% arg)
# Is this an array parameter?
if metaType.name == "array":
metaType.values["size"] = Library.MetaValue(
"size", metaGroup.attrs.get("size", 1))
if "type" in metaGroup.attrs:
metaType.values["type"] = Library.MetaValue(
"type", metaGroup.attrs["type"])
if metaGroup.attrs["type"] == "object":
if not "object_class" in metaGroup.attrs:
self.fail(
"Required metatype attribute object_class missing"
)
metaType.values[
"object_class"] = Library.MetaValue(
"object_class",
metaGroup.attrs["object_class"])
# How about an image parameter?
elif metaType.name == "image":
metaType.values["stride"] = Library.MetaValue(
"stride", metaGroup.attrs.get("stride", "width"))
metaType.values["height"] = Library.MetaValue(
"height", metaGroup.attrs.get("height", "height"))
metaType.values["components"] = Library.MetaValue(
"components",
metaGroup.attrs.get("components", "1"))
metaType.values["type"] = Library.MetaValue(
"type", metaGroup.attrs.get("type", "byte"))
else:
self.fail("Unknown meta type class '%s'." % metaclass)
Log.debug("Meta type: %s.%s: %s" %
(function, arg, metaType.name))
# Get the conditions for different meta values
if isinstance(metaGroup, Config.List):
for item in metaGroup:
predicate = item.attrs["condition"]
predicateValue = item.attrs["value"]
result = item.attrs["result"]
metaType.values[item].addPredicate(
predicate, predicateValue, result)
Log.debug(
"Meta type condition: If %s is %s, then %s = %s"
% (predicate, predicateValue, item, result))
elif isinstance(metaGroup, Config.Group):
Log.error(
"Meta type variations for parameter '%s' represented in a group instead of a list."
% arg)
# Record the meta type
lib.functions[function].parameters[arg].metaType = metaType
# Is this a short-hand state mapping?
try:
path = parameter.split(".")
except AttributeError:
# Try the expanded form of a nested attribute set
try:
path = (
config.functions[function][arg].state).split(".")
except AttributeError:
path = []
# Check that we even have a state structure
if path and not "state" in config:
Log.warn("State structure not defined.")
continue
# Parse special state mapping relations
relation = None
checkPaths = []
if arg == "@copy":
relation = Library.StateRelationCopy(
attrs["src"].split("."), attrs["dest"].split("."))
checkPaths = [relation.sourcePath, relation.destPath]
elif arg == "@get":
relation = Library.StateRelationGet(path)
checkPaths = [relation.path]
elif arg == "@set":
relation = Library.StateRelationSet(path)
checkPaths = [relation.path]
elif arg == "@modify":
relation = Library.StateRelationModify(path)
checkPaths = [relation.path]
# Empty mapping?
elif not "".join(path):
continue
if relation:
for path in checkPaths:
if traverseStatePath(config, path) is None:
self.fail(
"Relation state path '%s' for function '%s' does not exist."
% (".".join(path), function))
Log.debug("State relation: %s %s" % (function, relation))
lib.functions[function].stateRelations.append(relation)
continue
Log.debug("State mapping: %s.%s -> %s" %
(function, arg, ".".join(path)))
# Determine the parameter type
type = None
if arg == "@return":
type = lib.functions[function].type
else:
type = lib.functions[function].parameters[arg].type
# If this is a runtime mapping, check that the parameter is of a supported type
if lib.functions[function].runtimeStateTracking and type and \
lib.getNativeType(type) in ["float", "double"]:
self.fail(
"Values of type '%s' can not be saved to the runtime state tree"
% type)
continue
node = traverseStatePath(config, path)
if node is None:
self.fail(
"State path '%s' for function '%s' does not exist." %
(".".join(path), function))
# Save the mapping
if arg == "@return":
lib.functions[
function].retStateRelation = Library.StateRelationSet(
path)
else:
lib.functions[function].parameters[
arg].stateRelation = Library.StateRelationSet(path)
def loadSymbolMap(self):
config = self.config
lib = self.library
demangler = Tools.SymbolDecoder(config)
# Set default library name
if "library" in config:
for function in lib.functions.values():
function.libName = config.library
# Read in the export ordinals
if "deffiles" in config:
for defFile in config.deffiles:
for function, ordinal in Parser.parseDefFile(
open(config.getRelativePath(defFile)).read()):
if function in lib.functions:
lib.functions[function].exportOrdinal = ordinal
Log.debug("%s is exported at %d" % (function, ordinal))
# The function was not found in the library, so let's check whether it is a C++ symbol
elif demangler.isMangled(function):
function = demangler.decode(function)
if function in lib.functions:
# Save the ordinal and mark the function as C++
lib.functions[function].exportOrdinal = ordinal
lib.functions[function].language = "c++"
Log.debug("%s is exported at %d" %
(function, ordinal))
# Read the link ordinals and DLL information
if "symbol_map" in config:
defaultLibName = None
for fileName, libName in config.symbol_map.items():
if fileName == "default":
defaultLibName = libName
continue
# Is it a .DEF file
if fileName.endswith(".def"):
for function, ordinal in Parser.parseDefFile(
open(config.getRelativePath(fileName)).read()):
if function in lib.functions:
lib.functions[function].ordinal = ordinal
lib.functions[function].libName = libName
Log.debug("%s is at %s:%d" %
(function, libName, ordinal))
# The function was not found in the library, so let's check whether it is a C++ symbol
elif demangler.isMangled(function):
function = demangler.decode(function)
if function in lib.functions:
# Save the ordinal and mark the function as C++
lib.functions[function].ordinal = ordinal
lib.functions[function].libName = libName
lib.functions[function].language = "c++"
Log.debug("%s is at %s:%d" %
(function, libName, ordinal))
else: # it's a header file
assert fileName.endswith(".h")
for function in lib.functions.values():
if function.headerName == fileName:
function.libName = libName
# Generate passthrough functions for internal symbols
if defaultLibName:
assert self.project.platform.requireOrdinals, "Default symbol mapping can only be used in platforms that use symbol ordinals"
assert "max_internal_ordinal" in config, "max_internal_ordinal must be defined when using a default symbol mapping"
ordinals = range(1, int(config["max_internal_ordinal"]) + 1)
for function in lib.functions.values():
if function.exportOrdinal in ordinals:
ordinals.remove(function.exportOrdinal)
for ordinal in ordinals:
name = "_trInternal%d" % ordinal
f = Library.Function(name, Library.Type("void"))
f.language = "c"
f.ordinal = ordinal
f.exportOrdinal = ordinal
f.libName = defaultLibName
lib.functions[name] = f
Log.debug("%s is at %s:%d" %
(name, defaultLibName, ordinal))
