AutoDLL

[FoxyBrown via Digitalmars-d-learn]

A DLL Loader prototype that loads DLL's, just specify the 
declaration. Probably should be worked up so it is easy to load 
DLL's.

Example:



import portaudio;
import std.conv, std.stdio;
import core.stdc.stdio;

//pragma(lib, "portaudio_x86.lib"); // Doesn't work because libs 
are invalid



alias BOOL = ubyte;
alias DWORD = uint;

struct dllimport
{
  string dllName;
}

template hasAttribute(alias sym, T)
{
        static bool helper()
        {
                foreach(a; __traits(getAttributes, sym))
                {
			if(is(a == T) || __traits(compiles, typeof(a)) && is(typeof(a) 
== T))
                                return true;
                }
                return false;
        }
        enum bool hasAttribute = helper();
}

template getAttribute(alias sym, T)
{
        static T helper()
        {
                foreach(a; __traits(getAttributes, sym))
                {
			static if(is(a == T) || __traits(compiles, typeof(a)) && 
is(typeof(a) == T))
                                return a;
                }
                assert(0, "attribute " ~ T.stringof ~ " not found");
        }
        enum T getAttribute = helper();
}

void doImport(alias T)()
{
        import core.sys.windows.windows, std.conv;
        bool isDLLLoaded = false;
        HINSTANCE dll;
        foreach(m; __traits(allMembers, T))
        {               
                static if(__traits(compiles, typeof(__traits(getMember, T, m))))
                {                       
                        static if(hasAttribute!(__traits(getMember, T, m), 
dllimport))
                        {
				auto dllName =  getAttribute!(__traits(getMember, T, m), 
dllimport).dllName;
                                if (!isDLLLoaded)
                                {
                                        writeln("Loading DLL `"~dllName~"'...");
                                        isDLLLoaded = true;
                                        dll = 
LoadLibrary(to!wstring(dllName~"\0").ptr);
                                        if (dll == null)
                                        {
                                                // ERROR, handle
                                                writeln("Error, aborting!");
                                                return;
                                        }

                                }
                                auto q = GetProcAddress(dll, m);
                                mixin(m~" = cast(typeof("~m~"))q;");

				//func(m, getAttribute!(__traits(getMember, T, m), 
dllimport).dllName, cast(void**)&__traits(getMember, T, m));
                        }
                }
        }
}

mixin template DllImportFunctions()
{
        struct DllImporter
        {
                shared static this()
                {
                        doImport!(__traits(parent, DllImporter))();
                }

		static loadFunction(string name, const(char)[] dllName, void** 
addr)
                {
			printf("import %.*s from %.*s into %llx\n", name.length, 
name.ptr, dllName.length, dllName.ptr, addr);
                }
        }
}

extern(Windows) @dllimport("portaudio_x86.dll") __gshared
{
        PaError function() Pa_Initialize;
        PaError function() Pa_Terminate;
        PaHostApiIndex function() Pa_GetHostApiCount;
        PaHostApiIndex function() Pa_GetDefaultHostApi;
        PaDeviceIndex function() Pa_GetDefaultOutputDevice;
        PaDeviceIndex function() Pa_GetDefaultInputDevice;
        PaDeviceIndex function() Pa_GetDeviceCount;
        const(PaHostErrorInfo)* function() Pa_GetLastHostErrorInfo;
	PaDeviceIndex function(PaHostApiIndex hostApi, int 
hostApiDeviceIndex ) Pa_HostApiDeviceIndexToDeviceIndex;
	PaHostApiIndex function(PaHostApiTypeId type) 
Pa_HostApiTypeIdToHostApiIndex;
	const(PaHostApiInfo)* function(PaHostApiIndex hostApi) 
Pa_GetHostApiInfo;
	PaError function(PaStream *stream, PaStreamFinishedCallback 
streamFinishedCallback) Pa_SetStreamFinishedCallback;
        PaError function(PaStream *stream) Pa_CloseStream;
	PaError function(PaStream** stream, int numInputChannels, int 
numOutputChannels, PaSampleFormat sampleFormat, double 
sampleRate, ulong framesPerBuffer, PaStreamCallback 
streamCallback, void *userData) Pa_OpenDefaultStream;
	PaError function(PaStream** stream, const PaStreamParameters 
*inputParameters, const PaStreamParameters *outputParameters, 
double sampleRate, ulong framesPerBuffer, PaStreamFlags 
streamFlags, PaStreamCallback streamCallback, void *userData) 
Pa_OpenStream;
	PaError function(const PaStreamParameters *inputParameters, 
const PaStreamParameters *outputParameters, double sampleRate) 
Pa_IsFormatSupported;
	const(PaDeviceInfo)* function(PaDeviceIndex device) 
Pa_GetDeviceInfo;
        PaError function(PaStream *stream) Pa_StartStream;
        PaError function(PaStream *stream) Pa_StopStream;
        PaError function(PaStream *stream) Pa_AbortStream;
        PaError function(PaStream *stream) Pa_IsStreamStopped;
        void function(long msec) Pa_Sleep;
        PaError function(PaSampleFormat format) Pa_GetSampleSize;
        long function(PaStream* stream) Pa_GetStreamWriteAvailable;
        long function(PaStream* stream) Pa_GetStreamReadAvailable;
	PaError function(PaStream* stream, const void *buffer, ulong 
frames) Pa_WriteStream;
	PaError function(PaStream* stream, void *buffer, ulong frames) 
Pa_ReadStream;
        double function(PaStream* stream) Pa_GetStreamCpuLoad;
        PaTime function(PaStream *stream) Pa_GetStreamTime;
        const(PaStreamInfo)* function(PaStream *stream) Pa_GetStreamInfo;
        PaError function(PaStream *stream) Pa_IsStreamActive;

}

mixin DllImportFunctions;



struct Phase
{
    float left=0, right=0;
}

extern(C) int sawtooth(const(void)* inputBuffer, void* 
outputBuffer, size_t framesPerBuffer, 
const(PaStreamCallbackTimeInfo)* timeInfo, PaStreamCallbackFlags 
statusFlags, void *userData)
{
    auto phase = cast(Phase*)userData;

    auto pout = cast(float*)outputBuffer;

    enum vol = 0.2f;

    foreach(i; 0 .. framesPerBuffer)
    {
        *pout++ = vol * phase.left;
        *pout++ = vol * phase.right;

        phase.left += 0.01f;
        if (phase.left >= 1.0f) phase.left -= 2.0f;

        phase.right += 0.03f;
        if (phase.right >= 1.0f) phase.right -= 2.0f;
    }
    return 0;
}

int main()
{
    enum SAMPLE_RATE = 44100;
    enum NUM_SECONDS = 15;

    PaStream* stream;
    PaError err;
    Phase phase_data;

        auto x = Pa_Initialize;

    if ((err = Pa_Initialize()) != paNoError) goto Lerror;

    if ((err = Pa_OpenDefaultStream(&stream, 0, 2, paFloat32, 
SAMPLE_RATE, paFramesPerBufferUnspecified, &sawtooth, 
&phase_data)) != paNoError) goto Lerror;

    if ((err = Pa_StartStream(stream)) != paNoError) goto Lerror;

    Pa_Sleep(NUM_SECONDS * 1000);

    if ((err = Pa_StopStream(stream)) != paNoError) goto Lerror;
    if ((err = Pa_CloseStream(stream)) != paNoError) goto Lerror;
    if ((err = Pa_Terminate()) != paNoError) goto Lerror;

    return 0;
 Lerror:
    //stderr.writefln("error %s", 
to!string(Pa_GetErrorText(err)));
    return 1;
}