"""Base class for platform implementations
"""
import ctypes
from OpenGL.platform import ctypesloader
import sys
import OpenGL as top_level_module
from OpenGL import logs
class _CheckContext( object ):
    def __init__( self, func, ccisvalid ):
        self.func = func 
        self.ccisvalid = ccisvalid
    def __setattr__( self, key, value ):
        if key not in ('func','ccisvalid'):
            return setattr( self.func, key, value )
        else:
            self.__dict__[key] = value 
    def __getattr__( self, key ):
        if key != 'func':
            return getattr(self.func, key )
        raise AttributeError( key )
    def __call__( self, *args, **named ):
        if not self.ccisvalid():
            from OpenGL import error
            raise error.NoContext( self.func, args, named )
        return self.func( *args, **named )
class BasePlatform( object ):
    """Base class for per-platform implementations
    
    Attributes of note:
    
        EXPORTED_NAMES -- set of names exported via the platform 
            module's namespace...
    
        GL, GLU, GLUT, GLE, OpenGL -- ctypes libraries
    
        DEFAULT_FUNCTION_TYPE -- used as the default function 
            type for functions unless overridden on a per-DLL
            basis with a "FunctionType" member
        
        GLUT_GUARD_CALLBACKS -- if True, the GLUT wrappers 
            will provide guarding wrappers to prevent GLUT 
            errors with uninitialised GLUT.
        
        EXTENSIONS_USE_BASE_FUNCTIONS -- if True, uses regular
            dll attribute-based lookup to retrieve extension 
            function pointers.
    """
    
    EXPORTED_NAMES = [
        'GetCurrentContext','CurrentContextIsValid','safeGetError',
        'createBaseFunction', 'createExtensionFunction', 'copyBaseFunction',
        'GL','GLU','GLUT','GLE','OpenGL',
        'getGLUTFontPointer',
        'GLUT_GUARD_CALLBACKS',
    ]
    
    DEFAULT_FUNCTION_TYPE = None
    GLUT_GUARD_CALLBACKS = False
    EXTENSIONS_USE_BASE_FUNCTIONS = False
    
    def install( self, namespace ):
        """Install this platform instance into the platform module"""
        for name in self.EXPORTED_NAMES:
            namespace[ name ] = getattr(self,name)
        namespace['PLATFORM'] = self
        return self
    
    def functionTypeFor( self, dll ):
        """Given a DLL, determine appropriate function type..."""
        if hasattr( dll, 'FunctionType' ):
            return dll.FunctionType
        else:
            return self.DEFAULT_FUNCTION_TYPE
    
    def errorChecking( self, func, dll ):
        """Add error checking to the function if appropriate"""
        from OpenGL import error
        if top_level_module.ERROR_CHECKING:
            if dll not in (self.GLUT,):
                #GLUT spec says error-checking is basically undefined...
                # there *may* be GL errors on GLUT calls that e.g. render 
                # geometry, but that's all basically "maybe" stuff...
                func.errcheck = error.glCheckError
        return func
    def wrapContextCheck( self, func, dll ):
        """Wrap function with context-checking if appropriate"""
        if top_level_module.CONTEXT_CHECKING and dll is not self.GLUT:
            return _CheckContext( func, self.CurrentContextIsValid )
        return func 
    def wrapLogging( self, func ):
        """Wrap function with logging operations if appropriate"""
        return logs.logOnFail( func, logs.getLog( 'OpenGL.errors' ))
    
    def finalArgType( self, typ ):
        """Retrieve a final type for arg-type"""
        if typ == ctypes.POINTER( None ) and not getattr( typ, 'final',False):
            from OpenGL.arrays import ArrayDatatype
            return ArrayDatatype
        else:
            return typ
    def constructFunction( 
        self,
        functionName, dll, 
        resultType=ctypes.c_int, argTypes=(),
        doc = None, argNames = (),
        extension = None,
        deprecated = False,
    ):
        """Core operation to create a new base ctypes function
        
        raises AttributeError if can't find the procedure...
        """
        if extension and not self.checkExtension( extension ):
            raise AttributeError( """Extension not available""" )
        argTypes = [ self.finalArgType( t ) for t in argTypes ]
        if extension and not self.EXTENSIONS_USE_BASE_FUNCTIONS:
            # what about the VERSION values???
            if self.checkExtension( extension ):
                pointer = self.getExtensionProcedure( functionName )
                if pointer:
                    func = self.functionTypeFor( dll )(
                        resultType,
                        *argTypes
                    )(
                        pointer
                    )
                else:
                    raise AttributeError( """Extension %r available, but no pointer for function %r"""%(extension,functionName))
            else:
                raise AttributeError( """No extension %r"""%(extension,))
        else:
            func = ctypesloader.buildFunction(
                self.functionTypeFor( dll )(
                    resultType,
                    *argTypes
                ),
                functionName,
                dll,
            )
        func.__doc__ = doc 
        func.argNames = list(argNames or ())
        func.__name__ = functionName
        func.DLL = dll
        func.extension = extension
        func.deprecated = deprecated
        func = self.wrapLogging( 
            self.wrapContextCheck(
                self.errorChecking( func, dll ),
                dll,
            )
        )
        return func
    def createBaseFunction( 
        self,
        functionName, dll, 
        resultType=ctypes.c_int, argTypes=(),
        doc = None, argNames = (),
        extension = None,
        deprecated = False,
    ):
        """Create a base function for given name
        
        Normally you can just use the dll.name hook to get the object,
        but we want to be able to create different bindings for the 
        same function, so we do the work manually here to produce a
        base function from a DLL.
        """
        from OpenGL import wrapper
        try:
            if top_level_module.FORWARD_COMPATIBLE_ONLY and dll is self.GL:
                if deprecated:
                    return self.nullFunction(
                        functionName, dll=dll,
                        resultType=resultType, 
                        argTypes=argTypes,
                        doc = doc, argNames = argNames,
                        extension = extension,
                        deprecated = deprecated,
                    )
            return self.constructFunction(
                functionName, dll, 
                resultType=resultType, argTypes=argTypes,
                doc = doc, argNames = argNames,
                extension = extension,
            )
        except AttributeError, err:
            return self.nullFunction( 
                functionName, dll=dll,
                resultType=resultType, 
                argTypes=argTypes,
                doc = doc, argNames = argNames,
                extension = extension,
            )
    def checkExtension( self, name ):
        """Check whether the given extension is supported by current context"""
        if not name:
            return True
        context = self.GetCurrentContext()
        if context:
            from OpenGL import contextdata
            from OpenGL.raw.GL import GL_EXTENSIONS
            set = contextdata.getValue( GL_EXTENSIONS, context=context )
            if set is None:
                set = {}
                contextdata.setValue( 
                    GL_EXTENSIONS, set, context=context, weak=False 
                )
            current = set.get( name )
            if current is None:
                from OpenGL import extensions
                result = extensions.hasGLExtension( name )
                set[name] = result 
                return result
            return current
        else:
            return False
    createExtensionFunction = createBaseFunction
    def copyBaseFunction( self, original ):
        """Create a new base function based on an already-created function
        
        This is normally used to provide type-specific convenience versions of
        a definition created by the automated generator.
        """
        from OpenGL import wrapper, error
        if isinstance( original, _NullFunctionPointer ):
            return self.nullFunction(
                original.__name__,
                original.DLL,
                resultType = original.restype,
                argTypes= original.argtypes,
                doc = original.__doc__,
                argNames = original.argNames,
                extension = original.extension,
                deprecated = original.deprecated,
            )


Answer:         elif hasattr( original, 'originalFunction' ):