int drew_loader_load_plugin(DrewLoader *ldr, const char *plugin,
const char *path)
{
int retval = 0, err = 0;
library_t *lib;
g_rw_lock_writer_lock(&ldr->lock);
if (plugin && !path) {
int npaths = drew_loader_get_search_path(ldr, 0, NULL), i;
if (npaths < 0) {
retval = npaths;
goto out;
}
for (i = 0; i < npaths; i++) {
drew_loader_get_search_path(ldr, i, &path);
if (!load_library(ldr, plugin, path, &lib))
break;
}
if (i == npaths) {
retval = -DREW_ERR_RESOLUTION;
goto out;
}
}
else if ((err = load_library(ldr, plugin, path, &lib))) {
retval = err;
goto out;
}
retval = load_library_info(ldr, lib);
out:
g_rw_lock_writer_unlock(&ldr->lock);
return retval;
}
/*
ANT_PLUGIN_MANAGER::LOAD()
--------------------------
*/
void ANT_plugin_manager::load()
{
if (loaded)
return;
char *name = 0;
for (int i = 0; i < num_of_plugins; i++)
{
name = plugin_names[i];
#ifdef _MSC_VER
char sep[] = { "\\" };
#else
char sep[] = { "/" };
#endif
size_t len = strlen(PLUGIN_DIRECTORY_NAME) + strlen(sep) + strlen(name);
char *name_with_plugin_path = new char[len + 1];
strcpy(name_with_plugin_path, PLUGIN_DIRECTORY_NAME);
strcat(name_with_plugin_path, sep);
strcat(name_with_plugin_path, name);
name_with_plugin_path[len] = '\0';
struct stat plugin_stat;
if (stat( name_with_plugin_path, &plugin_stat ) != -1)
load_library(name_with_plugin_path, i);
else
load_library(name, i);
// else
// fprintf(stderr, "no plugin found for : %s\n", name_with_plugin_path);
delete [] name_with_plugin_path;
}
loaded = true;
}
int lua_sandbox_init(lua_sandbox* lsb, const char* data_file)
{
if (lsb == NULL || lsb->m_lua != NULL) {
return 0;
}
if (lsb->m_lua_file == NULL) {
snprintf(lsb->m_error_message, ERROR_SIZE, "no Lua script provided");
sandbox_terminate(lsb);
return 1;
}
lsb->m_lua = lua_newstate(memory_manager, lsb);
if (lsb->m_lua == NULL) {
snprintf(lsb->m_error_message, ERROR_SIZE, "out of memory");
sandbox_terminate(lsb);
return 2;
}
load_library(lsb->m_lua, "", luaopen_base, disable_base_functions);
load_library(lsb->m_lua, LUA_MATHLIBNAME, luaopen_math, disable_none);
load_library(lsb->m_lua, LUA_OSLIBNAME, luaopen_os, disable_os_functions);
load_library(lsb->m_lua, LUA_STRLIBNAME, luaopen_string, disable_none);
load_library(lsb->m_lua, LUA_TABLIBNAME, luaopen_table, disable_none);
luaopen_circular_buffer(lsb->m_lua);
lua_pushlightuserdata(lsb->m_lua, (void*)lsb);
lua_pushcclosure(lsb->m_lua, &read_message, 1);
lua_setglobal(lsb->m_lua, "read_message");
lua_pushlightuserdata(lsb->m_lua, (void*)lsb);
lua_pushcclosure(lsb->m_lua, &output, 1);
lua_setglobal(lsb->m_lua, "output");
lua_pushlightuserdata(lsb->m_lua, (void*)lsb);
lua_pushcclosure(lsb->m_lua, &inject_message, 1);
lua_setglobal(lsb->m_lua, "inject_message");
lua_sethook(lsb->m_lua, instruction_manager, LUA_MASKCOUNT,
lsb->m_usage[USAGE_TYPE_INSTRUCTION][USAGE_STAT_LIMIT]);
if (luaL_dofile(lsb->m_lua, lsb->m_lua_file) != 0) {
snprintf(lsb->m_error_message, ERROR_SIZE, "%s",
lua_tostring(lsb->m_lua, -1));
sandbox_terminate(lsb);
return 3;
} else {
lua_gc(lsb->m_lua, LUA_GCCOLLECT, 0);
lsb->m_usage[USAGE_TYPE_INSTRUCTION][USAGE_STAT_CURRENT] =
instruction_usage(lsb);
if (lsb->m_usage[USAGE_TYPE_INSTRUCTION][USAGE_STAT_CURRENT]
> lsb->m_usage[USAGE_TYPE_INSTRUCTION][USAGE_STAT_MAXIMUM]) {
lsb->m_usage[USAGE_TYPE_INSTRUCTION][USAGE_STAT_MAXIMUM] =
lsb->m_usage[USAGE_TYPE_INSTRUCTION][USAGE_STAT_CURRENT];
}
lsb->m_status = STATUS_RUNNING;
if (data_file != NULL && strlen(data_file) > 0) {
return restore_global_data(lsb, data_file);
}
}
return 0;
}
static int bb_load(struct soap_session *ps, const char *so)
{
int stat=1;
/* Load hpmud manually with symbols exported. Otherwise the plugin will not find it. */
if ((ps->hpmud_handle = load_library("libhpmud.so.0")) == NULL)
{
if ((ps->hpmud_handle = load_library("libhpmud.so.0")) == NULL)
goto bugout;
}
/* Load math library manually with symbols exported (Ubuntu 8.04). Otherwise the plugin will not find it. */
if ((ps->math_handle = load_library("libm.so")) == NULL)
{
if ((ps->math_handle = load_library("libm.so.6")) == NULL)
goto bugout;
}
if ((ps->bb_handle = load_plugin_library(UTILS_SCAN_PLUGIN_LIBRARY, so)) == NULL)
{
SendScanEvent(ps->uri, EVENT_PLUGIN_FAIL);
goto bugout;
}
if ((ps->bb_open = get_library_symbol(ps->bb_handle, "bb_open")) == NULL)
goto bugout;
if ((ps->bb_close = get_library_symbol(ps->bb_handle, "bb_close")) == NULL)
goto bugout;
if ((ps->bb_get_parameters = get_library_symbol(ps->bb_handle, "bb_get_parameters")) == NULL)
goto bugout;
if ((ps->bb_is_paper_in_adf = get_library_symbol(ps->bb_handle, "bb_is_paper_in_adf")) == NULL)
goto bugout;
if ((ps->bb_start_scan = get_library_symbol(ps->bb_handle, "bb_start_scan")) == NULL)
goto bugout;
if ((ps->bb_end_scan = get_library_symbol(ps->bb_handle, "bb_end_scan")) == NULL)
goto bugout;
if ((ps->bb_get_image_data = get_library_symbol(ps->bb_handle, "bb_get_image_data")) == NULL)
goto bugout;
if ((ps->bb_end_page = get_library_symbol(ps->bb_handle, "bb_end_page")) == NULL)
goto bugout;
stat=0;
bugout:
return stat;
} /* bb_load */
int main(int argc, const char** argv) {
// check that the program name was specified
if (argc < 2) {
printf("ERROR: No program_name was specified\n");
usage();
return -1;
}
// attempt to lookup the location of the skia app
const char* appLocation = "/data/data/com.skia";
if (!file_exists(appLocation)) {
printf("ERROR: Unable to find the com.skia app on the device.\n");
return -1;
}
// load the local skia shared library
void* skiaLibrary = load_library(appLocation, "skia_android");
if (NULL == skiaLibrary)
{
return -1;
}
// load the appropriate library
void* appLibrary = load_library(appLocation, argv[1]);
if (NULL == appLibrary) {
return -1;
}
// find the address of the main function
int (*app_main)(int, const char**);
*(void **) (&app_main) = dlsym(appLibrary, "main");
if (!app_main) {
printf("ERROR: Unable to load the main function of the selected program.\n");
printf("ERROR: %s\n", dlerror());
return -1;
}
// find the address of the SkPrintToConsole function
void (*app_SkDebugToStdOut)(bool);
*(void **) (&app_SkDebugToStdOut) = dlsym(skiaLibrary, "AndroidSkDebugToStdOut");
if (app_SkDebugToStdOut) {
(*app_SkDebugToStdOut)(true);
} else {
printf("WARNING: Unable to redirect output to the console.\n");
printf("WARNING: %s\n", dlerror());
}
// pass all additional arguments to the main function
return launch_app(app_main, argc - 1, ++argv);
}
void configure_enchant_provider(EnchantProvider * me, const char *dir_name)
{
#if defined(_WIN32)
if(!load_library(me, dir_name, L"aspell-15.dll") &&
!load_library(me, dir_name, L"libaspell-15.dll"))
{
/* we can't seem to load aspell. Avoid late binding problems later */
g_warning("Unable to load library aspell-15.dll.");
me->request_dict = NULL;
me->dispose_dict = NULL;
me->list_dicts = NULL;
}
#endif
}
/**
* Open the named driver and find its bootstrap function: _eglMain().
*/
static _EGLMain_t
_eglOpenLibrary(const char *driverPath, lib_handle *handle)
{
lib_handle lib;
_EGLMain_t mainFunc = NULL;
const char *error = "unknown error";
assert(driverPath);
_eglLog(_EGL_DEBUG, "dlopen(%s)", driverPath);
lib = load_library(driverPath);
if (!lib) {
_eglLog(_EGL_WARNING, "Could not open driver %s (%s)",
driverPath, error);
return NULL;
}
mainFunc = (_EGLMain_t) get_proc_address(lib, "_eglMain");
if (!mainFunc) {
_eglLog(_EGL_WARNING, "_eglMain not found in %s (%s)",
driverPath, error);
return NULL;
}
*handle = lib;
return mainFunc;
}
dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
const char *pathname, FILE *fp)
{
void *p;
int lib;
char funcname[258];
if (Py_VerboseFlag)
printf("load_library %s\n", pathname);
lib = load_library(pathname, 0);
if (lib < 0) {
char buf[512];
if (Py_VerboseFlag)
perror(pathname);
PyOS_snprintf(buf, sizeof(buf), "Failed to load %.200s: %.200s",
pathname, strerror(errno));
PyErr_SetString(PyExc_ImportError, buf);
return NULL;
}
PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
if (Py_VerboseFlag)
printf("get_symbol_address %s\n", funcname);
if (get_symbol_address(lib, funcname, -1, &p) < 0) {
p = NULL;
if (Py_VerboseFlag)
perror(funcname);
}
return (dl_funcptr) p;
}
void *
__libc_dlopen_mode (const char *name, int mode)
{
int *dl, kernmode = 0;
if( name == NULL )
return NULL;
/* We can ignore the RTLD_LAZY and RTLD_NOW flags. Syllable always does the
equivilent of RTLD_NOW and the spec allows RTLD_LAZY to be implementation
dependent; so we let it be RTLD_NOW too */
/* Note that RTLD_GLOBAL and RTLD_LOCAL arn't exactly correct either. They're
probably close enough for now though. */
if( mode & RTLD_GLOBAL )
kernmode |= IM_APP_SPACE;
if( mode & RTLD_LOCAL )
kernmode |= IM_LIBRARY_SPACE;
dl = (int*)malloc( sizeof( int ) );
if( dl != NULL )
*dl = load_library( name, kernmode );
return (void*)dl;
}
WinLibrary *new_winlibrary_from_file(const char *fn, wres_error *err)
{
WinLibrary *fl = calloc(sizeof(WinLibrary), 1);
fl->name = strdup(fn);
if (!fl->name) {
if (err) *err = WRES_ERROR_OUTOFMEMORY;
free(fl);
return NULL;
}
/* open file */
fl->file = fopen(fl->name, "rb");
if (fl->file == NULL) {
if (err) *err = -errno;
free(fl->name);
free(fl);
return NULL;
}
/* identify file and find resource table */
wres_error e;
if ((e = load_library(fl))) {
/* error reported by load_library */
free_winlibrary(fl);
if (err) *err = e;
return NULL;
}
return fl;
}
void gks_qt_plugin(int fctid, int dx, int dy, int dimx, int *ia, int lr1, double *r1, int lr2, double *r2, int lc,
char *chars, void **ptr)
{
static const char *name = NULL;
static void (*entry)(ENTRY_ARGS) = NULL;
const char *qt_version_string;
int qt_major_version;
if (name == NULL)
{
qt_version_string = getenv("GKS_QT_VERSION");
if (!qt_version_string)
{
qt_version_string = get_qt_version_string();
}
if (qt_version_string != NULL)
{
qt_major_version = atoi(qt_version_string);
if (qt_major_version == 5) name = "qt5plugin";
}
if (name == NULL) name = "qtplugin";
*(void **)(&entry) = load_library(name);
}
if (entry != NULL) (*entry)(fctid, dx, dy, dimx, ia, lr1, r1, lr2, r2, lc, chars, ptr);
}
void *dlopen(const char *file, int mode)
{
int dl, kernmode = 0;
void *ret = NULL;
if( file == 0 )
{
__dl_set_errno( _DL_ENOGLOBAL );
return( ret );
}
/* We can ignore the RTLD_LAZY and RTLD_NOW flags. Syllable always does the
equivilent of RTLD_NOW and the spec allows RTLD_LAZY to be implementation
dependent; so we let it be RTLD_NOW too */
/* Note that RTLD_GLOBAL and RTLD_LOCAL arn't exactly correct either. They're
probably close enough for now though. */
if( mode & RTLD_GLOBAL )
kernmode |= IM_APP_SPACE;
if( mode & RTLD_LOCAL )
kernmode |= IM_LIBRARY_SPACE;
dl = load_library( file, kernmode );
if( dl >= 0 )
ret = (void*)dl;
else
__dl_set_errno( _DL_EBADLIBRARY );
return( ret );
}
int main (int argc, char *argv[])
{
void * lib = NULL;
int (*fun) ();
struct compiler * compiler;
int rc = EXIT_FAILURE;
char prog[] = "int foo () { return 42; }";
compiler = compiler_get_gcc ();
if (comp_failed == compile_from_string (compiler, prog, libname))
goto out;
if (! (lib = load_library (libname)))
goto out;
fun = (int (*) ()) get_function (lib, funcname);
if (!fun)
goto out;
printf ("function '%s' from '%s' returned '%d'\n", funcname, libname, fun ());
out:
if (lib)
if (close_library (lib))
rc = EXIT_SUCCESS;
return rc;
}
Named_interface*
Manager::new_interface_raw(const std::string& type_param,
const std::string& name ) {
// Look for the required manager and create the new interface without smart pointer.
// The memory allocated is not managed, it is the user to delete it when not needed
// If no factory method can be found to create the interface, look
// for a plugin that would provide a factory method.
Prefixed_name split = split_name(name);
if( split.second == "" ) {
// we're at the end of the path
//----------
// Extract the type of the object to be created
// and the parameters for the creation. These information are
// contained in string "type_param"
String_Op::string_pair split_params =
String_Op::split_string( type_param, "://", true );
std::string type = split_params.first;
std::string param = split_params.second;
CallBackMap::iterator it = factory_.find(type);
if( it == factory_.end() ) {
// No factory method found => try loading a plugin
bool loaded = load_library( type );
if( loaded )
it = factory_.find(type);
}
if( it == factory_.end() ) {
// No factory method could be found, and no plugin provides a
// suitable one
appli_warning( "No factory method to create type " << type << std::endl
<< "Interface ..." << name << " could not be created" << std::endl );
return 0;
}
// If we've reached this point, it means we have a factory method
// to create the requested interface.
std::pair<InterfaceMap::iterator, bool> pos;
return (it->second)( param );
}
else {
// we're not at the end of the path.
// go down one level of the tree, if it exists, and try again
SmartPtr<Directory> subdir = get_subdir( split.first );
if( subdir.raw_ptr() == 0 ) {
appli_warning( "Could not descend into directory " << split.first << std::endl );
return 0;
}
else
return subdir->new_interface_raw( type_param, split.second );
}
}
int
export_dl_open(char const *name, unsigned flags)
{
(void)(name);
(void)(flags);
return load_library(name);
}
int require_library(lua_State* lua)
{
const char* name = luaL_checkstring(lua, 1);
if (strcmp(name, LUA_LPEGLIBNAME) == 0) {
const char* disable[] = { NULL };
load_library(lua, name, luaopen_lpeg, disable);
} else if (strcmp(name, "cjson") == 0) {
const char* disable[] = { "encode", "encode_sparse_array",
"encode_max_depth", "encode_number_precision", "encode_keep_buffer",
"encode_invalid_numbers", NULL};
load_library(lua, name, luaopen_cjson_safe, disable);
lua_pushvalue(lua, -1);
lua_setglobal(lua, name);
} else {
luaL_error(lua, "library '%s' is not available", name);
}
return 1;
}
//pszFilename must have room for at least MaxPath+1 characters
static inline bool get_file_name_from_handle_function
(void * hFile, wchar_t *pszFilename, std::size_t length, std::size_t &out_length)
{
if(length <= MaxPath) {
return false;
}
void *hiPSAPI = load_library("PSAPI.DLL");
if (0 == hiPSAPI)
return 0;
class library_unloader
{
void *lib_;
public:
library_unloader(void *module) : lib_(module) {}
~library_unloader() {
free_library(lib_);
}
} unloader(hiPSAPI);
// Pointer to function getMappedFileName() in PSAPI.DLL
GetMappedFileName_t pfGMFN =
(GetMappedFileName_t)get_proc_address(hiPSAPI, "GetMappedFileNameW");
if (! pfGMFN) {
return 0; // Failed: unexpected error
}
bool bSuccess = false;
// Create a file mapping object.
void * hFileMap = create_file_mapping(hFile, page_readonly, 0, 1, 0);
if(hFileMap)
{
// Create a file mapping to get the file name.
void* pMem = map_view_of_file_ex(hFileMap, file_map_read, 0, 0, 1, 0);
if (pMem) {
out_length = pfGMFN(get_current_process(), pMem, pszFilename, MaxPath);
if(out_length) {
bSuccess = true;
}
unmap_view_of_file(pMem);
}
close_handle(hFileMap);
}
return(bSuccess);
}
void gks_video_plugin(int fctid, int dx, int dy, int dimx, int *ia, int lr1, double *r1, int lr2, double *r2, int lc,
char *chars, void **ptr)
{
static const char *name = NULL;
static void (*entry)(ENTRY_ARGS) = NULL;
if (name == NULL)
{
name = "videoplugin";
*(void **)(&entry) = load_library(name);
}
if (entry != NULL) (*entry)(fctid, dx, dy, dimx, ia, lr1, r1, lr2, r2, lc, chars, ptr);
}
int main(int argc, char** argv)
{
load_library(library_name);
void (*selfloaded_func)() = resolve_symbol(library_name, function_name);
if (!selfloaded_func)
{
fprintf(stderr, "failed to locate %s()\n", function_name);
return 1;
}
fprintf(stderr, "calling %s() by programically located pointer:\n", function_name);
selfloaded_func();
}
int kr_module_load(struct kr_module *module, const char *name, const char *path)
{
if (module == NULL || name == NULL) {
return kr_error(EINVAL);
}
/* Initialize, keep userdata */
void *data = module->data;
memset(module, 0, sizeof(struct kr_module));
module->data = data;
module->name = strdup(name);
if (module->name == NULL) {
return kr_error(ENOMEM);
}
/* Search for module library, use current namespace if not found. */
if (load_library(module, name, path) != 0) {
/* Expand HOME env variable, as the linker may not expand it. */
auto_free char *local_path = kr_strcatdup(2, getenv("HOME"), "/.local/lib/kdns_modules");
if (load_library(module, name, local_path) != 0) {
if (load_library(module, name, MODULEDIR) != 0) {
module->lib = RTLD_DEFAULT;
}
}
}
/* Try to load module ABI. */
int ret = load_sym_c(module, KR_MODULE_API);
if (ret == 0 && module->init) {
ret = module->init(module);
}
if (ret != 0) {
kr_module_unload(module);
}
return ret;
}
/*
* Load Scorpio bitbases from |egbb_dir|, with the specified cache size.
* We also need to find a compatible shared library in the directory.
*/
bool load_scorpio_bb(char* egbb_dir, int cache_size_bytes)
{
if (!cache_size_bytes) cache_size_bytes = EGBB_DEFAULT_CACHE_SIZE;
char path[1024];
egbb_is_loaded = false;
if (lib) unload_library(lib);
strncpy(path, egbb_dir, 1000);
strcat(path, EGBB_NAME);
lib = load_library(path);
if (!lib) {
strncpy(path, egbb_dir, 1000);
strcat(path, EGBB_NAME2);
lib = load_library(path);
}
if (!lib) {
strncpy(path, egbb_dir, 1000);
strcat(path, EGBB64_NAME);
lib = load_library(path);
}
if (!lib) {
strncpy(path, egbb_dir, 1000);
strcat(path, EGBB64_NAME2);
lib = load_library(path);
}
if (!lib) {
printf("info string Failed to load egbb from %s.\n", egbb_dir);
return false;
}
load_egbb_fn load_egbb = (load_egbb_fn)load_function(lib, "load_egbb_5men");
probe_egbb_internal = (probe_egbb_fn)load_function(lib, "probe_egbb_5men");
load_egbb(egbb_dir, cache_size_bytes, SMART_LOAD);
egbb_is_loaded = true;
return true;
}
void Disassembler::decode(nmethod* nm, outputStream* st) {
#ifndef CORE
st = st ? st : tty;
st->print_cr("Decoding compiled method " INTPTR_FORMAT ":", nm);
st->print("Code:");
st->cr();
if (!load_library()) {
st->print_cr("Could not load disassembler");
return;
}
sparc_env env(nm, st);
unsigned char* p = nm->instructions_begin();
unsigned char* end = nm->instructions_end();
assert ((((intptr_t)p | (intptr_t)end) % sizeof(int) == 0), "misaligned insn addr");
unsigned char *p1 = p;
int total_bucket_count = 0;
while (p1 < end && p1) {
unsigned char *p0 = p1;
++p1;
address bucket_pc = FlatProfiler::bucket_start_for(p1);
if (bucket_pc != NULL && bucket_pc > p0 && bucket_pc <= p1)
total_bucket_count += FlatProfiler::bucket_count_for(p0);
}
while (p < end && p) {
if (p == nm->entry_point()) st->print_cr("[Entry Point]");
if (p == nm->verified_entry_point()) st->print_cr("[Verified Entry Point]");
if (p == nm->exception_begin()) st->print_cr("[Exception Handler]");
if (p == nm->stub_begin()) st->print_cr("[Stub Code]");
if (p == nm->interpreter_entry_point_or_null()) st->print_cr("[Interpreter Entry Point]");
unsigned char* p0 = p;
st->print(" " INTPTR_FORMAT ": ", p);
p = decode_instruction(p, &env);
nm->print_code_comment_on(st, 40, p0, p);
st->cr();
// Output pc bucket ticks if we have any
address bucket_pc = FlatProfiler::bucket_start_for(p);
if (bucket_pc != NULL && bucket_pc > p0 && bucket_pc <= p) {
int bucket_count = FlatProfiler::bucket_count_for(p0);
tty->print_cr("%3.1f%% [%d]", bucket_count*100.0/total_bucket_count, bucket_count);
tty->cr();
}
}
#endif
}
int set_function_pointers(void)
{
if (FILTERING_ENABLED() && multi_get_opt_filterlibpath == NULL) {
// -x option was specified i.e. filtering was enabled but -y option i.e. filterlibpath was not specified.
fprintf(stderr, "-x <num> -y <filterlib-path>: -x and -y options must be used together\n");
return 1;
}
if (FILTERING_ENABLED()) {
// Filtering is enabled.
if (NULL == load_library(multi_get_opt_filterlib)) {
return 1;
}
}
return 0;
}
void *get_flib(char *flibname)
{
struct fliblist_s *flib = head;
if (strcmp(flibname, "default") == 0)
return head;
while (flib != NULL) {
if (strcmp(flib->flibname, flibname) == 0)
return flib;
flib = flib->next;
}
if (flib == NULL) {
flib = load_library(flibname);
}
return (void *) flib;
}
inline void get_shared_documents_folder(std::string &s)
{
s.clear();
void *hAdvapi = load_library("Advapi32.dll");
if (hAdvapi){
library_unloader unloader(hAdvapi);
// Pointer to function RegOpenKeyA
RegOpenKeyEx_t pRegOpenKey =
(RegOpenKeyEx_t)get_proc_address(hAdvapi, "RegOpenKeyExA");
if (pRegOpenKey){
// Pointer to function RegCloseKey
RegCloseKey_t pRegCloseKey =
(RegCloseKey_t)get_proc_address(hAdvapi, "RegCloseKey");
if (pRegCloseKey){
// Pointer to function RegQueryValueA
RegQueryValueEx_t pRegQueryValue =
(RegQueryValueEx_t)get_proc_address(hAdvapi, "RegQueryValueExA");
if (pRegQueryValue){
//Open the key
void *key;
if ((*pRegOpenKey)( hkey_local_machine
, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"
, 0
, key_query_value
, &key) == 0){
reg_closer key_closer(pRegCloseKey, key);
//Obtain the value
unsigned long size;
unsigned long type;
const char *const reg_value = "Common AppData";
long err = (*pRegQueryValue)( key, reg_value, 0, &type, 0, &size);
if(!err){
//Size includes terminating NULL
s.resize(size);
err = (*pRegQueryValue)( key, reg_value, 0, &type, (unsigned char*)(&s[0]), &size);
if(!err)
s.erase(s.end()-1);
(void)err;
}
}
}
}
}
}
}
void main() {
load_library("/lib/core");
get_lcd_lock();
get_keypad_lock();
screen = screen_allocate();
flush_keys();
main_menu();
initialize();
game_running = true;
while (1) {
draw();
update();
}
}
void gks_drv_plugin(int fctid, int dx, int dy, int dimx, int *ia, int lr1, double *r1, int lr2, double *r2, int lc,
char *chars, void **ptr)
{
static const char *name = NULL;
static void (*entry)(ENTRY_ARGS) = NULL;
const char *env;
if (name == NULL)
{
name = NAME;
if ((env = gks_getenv("GKS_PLUGIN")) != NULL) name = env;
*(void **)(&entry) = load_library(name);
}
if (entry != NULL) (*entry)(fctid, dx, dy, dimx, ia, lr1, r1, lr2, r2, lc, chars, ptr);
}
SmartPtr<X3aAnalyzer>
X3aAnalyzerLoader::load_dynamic_analyzer (SmartPtr<X3aAnalyzerLoader> &self)
{
XCAM_ASSERT (self.ptr () == this);
SmartPtr<X3aAnalyzer> analyzer;
XCam3ADescription *desc = (XCam3ADescription*)load_library (get_lib_path ());
analyzer = new DynamicAnalyzer (desc, self);
if (!analyzer.ptr ()) {
XCAM_LOG_WARNING ("create DynamicAnalyzer from lib failed");
close_handle ();
return NULL;
}
XCAM_LOG_INFO ("analyzer(%s) created from 3a lib", XCAM_STR (analyzer->get_name()));
return analyzer;
}
vanilla::native_library_cache::fptr vanilla::native_library_cache::get_function(
std::string const& library, std::string const& name)
{
// If the library is not already cached then try to load it.
auto iter = _cache.find(library);
if(iter == _cache.end())
iter = _cache.insert(std::make_pair(library, load_library(library))).first;
// Load the function from the library.
try
{
return retrieve_function_symbol(iter->second, name);
}
catch(error::native_symbol_not_found_error& e)
{
BOOST_THROW_EXCEPTION(e << error::native_library_name(library));
}
}
struct module *load_module(char *name)
//@ requires kernel_state() &*& [?f]string(name, ?cs);
//@ ensures kernel_state() &*& [f]string(name, cs) &*& kernel_module(result);
{
struct library *lib = load_library(name);
module_init *init = 0;
module_dispose *dispose = 0;
struct module *m;
if (lib == 0) abort();
init = library_lookup_symbol_module_init_func(lib);
if (init == 0) abort();
dispose = init();
m = malloc(sizeof(struct module));
if (m == 0) abort();
m->library = lib;
m->dispose = dispose;
//@ close kernel_module(m);
return m;
}