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))