General Class for interfacing with Windows .DLLs (Python recipe) by Larry Bates

ActiveState Code (http://code.activestate.com/recipes/146847/)

# CLASS NAME: DLLInterface
#
# Author: Larry Bates
#
# Written: 08/14/2002
#
# Description: This is a base class for implementing a class interface
# to call general DLL libraries.  You should build your class using
# this class as the base class.  Define methods for each function of
# the DLL that you wish to implement.
#
import os, sys
import calldll
from dynwin.windll import cstring, membuf

class DLLInterface:
    '''
    class DLLInterface is used as a base class as a general interface class to
    Microsoft Windows DLLs.  None  of the methods of this class should be
    called directly.  Subclass this class and have subclass' methods
    make calls to _dllcall to call functions from the DLL.
    '''

    #--------------------------------------------------------------------------------------------
    # Example usage:
    #
    # class anydll(DLLInterface):
    #    def function1 (self, arg1, arg2, ..., argn)
    #        #
    #        # code goes here to implement function1 from the DLL
    #        # as a method of anydll class.
    #        #
    #        # Syntax of _dllcall function is (function in .DLL,
    #        #                                 argument types,    ['llh' is long, long, short]
    #        #                                 return code type,  ['h' is short]
    #        #                                 arguments in a tuple)              
    #        #
    #        result=self._dllcall('function1',
    #                             'lll',
    #                             'h',
    #                             (arg1,
    #                              arg2,
    #                              arg3,
    #                               .
    #                               .
    #                               .
    #                              argn))
    #        return result
    #
    # this would then be executed using:
    #
    # D=anydll(DLLPath)
    # result=d.function(arg1, arg2, ..., argn)
    #
    # argument types = 'h'-short, 'l'-long, 's'-string (null terminated using helper function
    #                                                   cstring in dynwin)
    #--------------------------------------------------------------------------------------------
       
    def __init__(self, DLLPath, ext='.dll'):
        self._debug=0
        self._trace=0
        self._loaded=0
        self._funcs={}
        self._DLLName=os.path.split(DLLPath)[1]+ext  # Save DLL filename
        if self._trace: print "creating _handle"
        #
        # Load the DLL library (if not already loaded) and save a
        # handle to it in self._handle
        #
        if not self._loaded:
            self._handle=calldll.load_library(DLLPath+ext)
            #
            # If I didn't get a handle, DLL wasn't loaded
            #
            if not self._handle:
                raise SystemError, "couldn't load module '%s'" % self._DLLName
            else:
                self._loaded=1
            
        if self._trace: print "handle=",self._handle

        if self._trace: print "Leaving __init__"
        return

    def unload(self):
        if self._loaded and self._handle:
            calldll.free_library(self._handle)
            
        self._loaded=0
        self._handle=0
        self._funcs={}
        return

    def _dlladdr(self, func_name):
        #
        # This method uses the function name (func_name) and looks into the .DLL
        # to find the address that should be used to call that function.
        #
        if self._trace: print "self._handle=",self._handle
        if self._trace: print "_dlladdr to get address of %s func" % func_name
        if not self._handle:
            raise SystemError, "No handle found for %s" % self._DLLName
        #
        # See if I've called this func_name before.  If I have, I have saved
        # the address in self._funcs dictionary object so I don't have to call
        # calldll.get_proc_address repeatedly.  A method of "caching" the addresses.
        # to hopefully speed things up a little.
        #
        try:
            addr=self._funcs[func_name]
        except:
            addr=calldll.get_proc_address(self._handle, func_name)
            self._funcs[func_name]=addr
            
        if self._trace:
            print "leaving _dlladdr, function %s has calling address=%i" % (func_name, addr)
            print ""
        #
        # Return the address of this function so it can be called by calldll
        #
        if addr: return addr
        else:    raise SystemError, "%s has no function named '%s'" % (self._DLLName, func_name)

    def _dllcall(self, function_name,arg_format_string, result_format_string, args):
        #
        # This method is used to make the call to the DLL function
        # Arguments are:
        #
        # function_name - String containing the name of the function to call
        # arg_format_string - this is a string that contains the format of the
        #                     arguments that are to be passed to the function.
        #                     These can be one of:
        #                     l - long integer (or address)
        #                     h - short integer (half)
        #                     s - string
        #
        #                     Example: "lllh"
        #
        # result_format_string - The result will be either l or h, returned by
        #                        function
        # args - This is a tuple (even if there is only one argument)
        #
        #                     Example: (x,) or (a,b,c,d)
        #
        if self._trace: print "Entering _dllcall to call function=",function_name
        result=calldll.call_foreign_function(self._dlladdr(function_name),
                                                           arg_format_string,
                                                           result_format_string,
                                                           args)
        #
        # If result_format_string is "h" mask out high bits of result
        #
        if result_format_string in ('h','H'):
            result=result & 0xffff
            
        #
        # If result_format_string is "s", strip off trailing null character
        #
        if result_format_string in ('s','S'):
            result=result[:-1]

        return result