gecko-dev/gfx/gl/GLLibraryLoader.cpp

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "GLLibraryLoader.h"

#include "nsDebug.h"

#ifdef WIN32
#include <windows.h>
#endif

namespace mozilla {
namespace gl {

bool
GLLibraryLoader::OpenLibrary(const char* library)
{
    PRLibSpec lspec;
    lspec.type = PR_LibSpec_Pathname;
    lspec.value.pathname = library;

    mLibrary = PR_LoadLibraryWithFlags(lspec, PR_LD_LAZY | PR_LD_LOCAL);
    if (!mLibrary)
        return false;

    return true;
}

bool
GLLibraryLoader::LoadSymbols(const SymLoadStruct* firstStruct,
                             bool tryplatform,
                             const char* prefix,
                             bool warnOnFailure)
{
    return LoadSymbols(mLibrary,
                       firstStruct,
                       tryplatform ? mLookupFunc : nullptr,
                       prefix,
                       warnOnFailure);
}

PRFuncPtr
GLLibraryLoader::LookupSymbol(const char* sym)
{
    return LookupSymbol(mLibrary, sym, mLookupFunc);
}

PRFuncPtr
GLLibraryLoader::LookupSymbol(PRLibrary* lib,
                              const char* sym,
                              PlatformLookupFunction lookupFunction)
{
    PRFuncPtr res = 0;

    // try finding it in the library directly, if we have one
    if (lib) {
        res = PR_FindFunctionSymbol(lib, sym);
    }

    // then try looking it up via the lookup symbol
    if (!res && lookupFunction) {
        res = lookupFunction(sym);
    }

    // finally just try finding it in the process
    if (!res) {
        PRLibrary* leakedLibRef;
        res = PR_FindFunctionSymbolAndLibrary(sym, &leakedLibRef);
    }

    return res;
}

bool
GLLibraryLoader::LoadSymbols(PRLibrary* lib,
                             const SymLoadStruct* firstStruct,
                             PlatformLookupFunction lookupFunction,
                             const char* prefix,
                             bool warnOnFailure)
{
    char sbuf[MAX_SYMBOL_LENGTH * 2];
    int failCount = 0;

    const SymLoadStruct* ss = firstStruct;
    while (ss->symPointer) {
        *ss->symPointer = 0;

        for (int i = 0; i < MAX_SYMBOL_NAMES; i++) {
            if (ss->symNames[i] == nullptr)
                break;

            const char* s = ss->symNames[i];
            if (prefix && *prefix != 0) {
                strcpy(sbuf, prefix);
                strcat(sbuf, ss->symNames[i]);
                s = sbuf;
            }

            PRFuncPtr p = LookupSymbol(lib, s, lookupFunction);
            if (p) {
                *ss->symPointer = p;
                break;
            }
        }

        if (*ss->symPointer == 0) {
            if (warnOnFailure) {
                printf_stderr("Can't find symbol '%s'.\n", ss->symNames[0]);
            }

            failCount++;
        }

        ss++;
    }

    return failCount == 0 ? true : false;
}

/*static*/ void
GLLibraryLoader::ClearSymbols(const SymLoadStruct* const firstStruct)
{
    for (auto cur = firstStruct; cur->symPointer; ++cur) {
        *cur->symPointer = nullptr;
    }
}

} /* namespace gl */
} /* namespace mozilla */