diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

clang indenting

Browse Source
This commit is contained in:
vscosta 2016-04-05 02:22:04 +01:00
parent d4a9f97cdd
commit 07f105dd80
1 changed files with 76 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
C/load_dl.c
View File

@ -14,51 +14,47 @@
*************************************************************************/ *************************************************************************/
#include "Yap.h" #include "Yap.h"
#include "Yatom.h"
#include "YapHeap.h" #include "YapHeap.h"
#include "Yatom.h"
#include "yapio.h" #include "yapio.h"
#include "Foreign.h" #include "Foreign.h"
#if LOAD_DL #if LOAD_DL
// use SWI-Prolog code if all else fails // use SWI-Prolog code if all else fails
char * char *findExecutable(const char *av0, char *buffer);
findExecutable(const char *av0, char *buffer);
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h> #include <dlfcn.h>
#include <string.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#if defined(__APPLE__) #if defined(__APPLE__)
#include <mach-o/dyld.h>
#include <dlfcn.h> #include <dlfcn.h>
#include <mach-o/dyld.h>
#endif #endif
typedef void (*prismf)(void); typedef void (*prismf)(void);
/* only works for dlls */ /* only works for dlls */
int int Yap_CallFunctionByName(const char *thing_string);
Yap_CallFunctionByName(const char *thing_string);
int int Yap_CallFunctionByName(const char *thing_string) {
Yap_CallFunctionByName(const char *thing_string) void *handle = dlopen(NULL, RTLD_LAZY
{
void * handle = dlopen(NULL, RTLD_LAZY
#ifndef __CYGWIN__ #ifndef __CYGWIN__
#ifdef RTLD_NOLOAD #ifdef RTLD_NOLOAD
| RTLD_NOLOAD | RTLD_NOLOAD
#endif #endif
#endif #endif
); );
// you could do RTLD_NOW as well. shouldn't matter // you could do RTLD_NOW as well. shouldn't matter
if (!handle) { if (!handle) {
CACHE_REGS CACHE_REGS
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "Dynamic linking on main module : %s\n", dlerror()); Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1,
"Dynamic linking on main module : %s\n", dlerror());
} }
prismf * addr = (prismf *)dlsym(handle, thing_string); prismf *addr = (prismf *)dlsym(handle, thing_string);
if (addr) if (addr)
(*addr)(); (*addr)();
dlclose(handle); dlclose(handle);
@ -69,9 +65,7 @@ Yap_CallFunctionByName(const char *thing_string)
* YAP_FindExecutable(argv[0]) should be called on yap initialization to * YAP_FindExecutable(argv[0]) should be called on yap initialization to
* locate the executable of Yap * locate the executable of Yap
*/ */
char * char *Yap_FindExecutable(void) {
Yap_FindExecutable(void)
{
#if HAVE_GETEXECNAME #if HAVE_GETEXECNAME
// Solaris // Solaris
return getexecname(); return getexecname();
@ -82,11 +76,11 @@ Yap_FindExecutable(void)
uint32_t size = sizeof(path); uint32_t size = sizeof(path);
if (!_NSGetExecutablePath(path, &size)) { if (!_NSGetExecutablePath(path, &size)) {
size_t sz = strlen(path); size_t sz = strlen(path);
buf = malloc(sz+1); buf = malloc(sz + 1);
strncpy(buf, path, sz); strncpy(buf, path, sz);
return buf; return buf;
} else { } else {
char *rc = malloc(size+1); char *rc = malloc(size + 1);
if (_NSGetExecutablePath(rc, &size) == 0) if (_NSGetExecutablePath(rc, &size) == 0)
return "yap"; return "yap";
return rc; return rc;
@ -94,18 +88,18 @@ Yap_FindExecutable(void)
#elif defined(__linux__) #elif defined(__linux__)
enum { BUFFERSIZE = 1024 }; enum { BUFFERSIZE = 1024 };
char *buf = malloc(BUFFERSIZE); char *buf = malloc(BUFFERSIZE);
ssize_t len = readlink("/proc/self/exe", buf, sizeof(buf)-1); ssize_t len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
if (len != -1) { if (len != -1) {
buf[len] = '\0'; buf[len] = '\0';
return buf; return buf;
} }
// follow through to standard method // follow through to standard method
#elif defined(__FreeBSD__) || defined(__DragonFly__) #elif defined(__FreeBSD__) || defined(__DragonFly__)
enum { BUFFERSIZE = 1024 }; enum { BUFFERSIZE = 1024 };
char *buf = malloc(BUFFERSIZE); char *buf = malloc(BUFFERSIZE);
ssize_t len = readlink("/proc/curproc/file", buf, sizeof(buf)-1); ssize_t len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
if (len != -1) { if (len != -1) {
buf[len] = '\0'; buf[len] = '\0';
return buf; return buf;
@ -117,41 +111,37 @@ Yap_FindExecutable(void)
mib[3] = -1; // current process mib[3] = -1; // current process
size_t cb = BUFFERSIZE; size_t cb = BUFFERSIZE;
sysctl(mib, 4, buf, &cb, NULL, 0); sysctl(mib, 4, buf, &cb, NULL, 0);
// follow through to standard method // follow through to standard method
#endif #endif
return return NULL;
NULL;
} }
void * void *Yap_LoadForeignFile(char *file, int flags) {
Yap_LoadForeignFile(char *file, int flags)
{
CACHE_REGS CACHE_REGS
int dlflag; int dlflag;
void *out; void *out;
if (flags & EAGER_LOADING) if (flags & EAGER_LOADING)
dlflag = RTLD_NOW; dlflag = RTLD_NOW;
else else
dlflag = RTLD_LAZY; dlflag = RTLD_LAZY;
if (flags & GLOBAL_LOADING) if (flags & GLOBAL_LOADING)
dlflag |= RTLD_GLOBAL; dlflag |= RTLD_GLOBAL;
#ifndef __CYGWIN__ #ifndef __CYGWIN__
else else
dlflag |= RTLD_LOCAL; dlflag |= RTLD_LOCAL;
#endif #endif
if (!Yap_locateFile(file, LOCAL_FileNameBuf, true)){ if (!Yap_locateFile(file, LOCAL_FileNameBuf, true)) {
/* use LD_LIBRARY_PATH */ /* use LD_LIBRARY_PATH */
strncpy(LOCAL_FileNameBuf,file, YAP_FILENAME_MAX-1); strncpy(LOCAL_FileNameBuf, file, YAP_FILENAME_MAX - 1);
strncat(LOCAL_FileNameBuf,".", YAP_FILENAME_MAX-1); strncat(LOCAL_FileNameBuf, ".", YAP_FILENAME_MAX - 1);
strncat(LOCAL_FileNameBuf, "SO_EXT", YAP_FILENAME_MAX-1); strncat(LOCAL_FileNameBuf, "SO_EXT", YAP_FILENAME_MAX - 1);
} }
out = (void *)dlopen(LOCAL_FileNameBuf, flags); out = (void *)dlopen(LOCAL_FileNameBuf, flags);
if (out == NULL) { if (out == NULL) {
char *m_os = dlerror(); const char *m_os = dlerror();
if (m_os) { if (m_os) {
LOCAL_ErrorMessage = dlerror(); strncpy(LOCAL_ErrorSay, m_os, MAX_ERROR_MSG_SIZE - 1);
} else { } else {
LOCAL_ErrorMessage = "dlopen failed"; LOCAL_ErrorMessage = "dlopen failed";
} }
@ -159,22 +149,18 @@ Yap_LoadForeignFile(char *file, int flags)
return out; return out;
} }
int int Yap_CallForeignFile(void *handle, char *f) {
Yap_CallForeignFile(void *handle, char *f) YapInitProc proc = (YapInitProc)dlsym(handle, f);
{
YapInitProc proc = (YapInitProc) dlsym(handle, f);
if (!proc) { if (!proc) {
/* Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "dlsym error %s\n", dlerror());*/ /* Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "dlsym error %s\n", dlerror());*/
return FALSE; return FALSE;
} }
(*proc) (); (*proc)();
return TRUE; return TRUE;
} }
int int Yap_CloseForeignFile(void *handle) {
Yap_CloseForeignFile(void *handle) if (dlclose(handle) < 0) {
{
if ( dlclose(handle) < 0) {
CACHE_REGS CACHE_REGS
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "dlclose error %s\n", dlerror()); Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "dlclose error %s\n", dlerror());
return -1; return -1;
@ -182,30 +168,30 @@ Yap_CloseForeignFile(void *handle)
return 0; return 0;
} }
/* /*
* LoadForeign(ofiles,libs,proc_name,init_proc) dynamically loads foreign * LoadForeign(ofiles,libs,proc_name,init_proc) dynamically loads foreign
* code files and libraries and locates an initialization routine * code files and libraries and locates an initialization routine
*/ */
static Int static Int LoadForeign(StringList ofiles, StringList libs, char *proc_name,
LoadForeign(StringList ofiles, StringList libs, YapInitProc *init_proc) {
char *proc_name, YapInitProc *init_proc)
{
CACHE_REGS CACHE_REGS
while (libs) { while (libs) {
if (!Yap_locateFile((char *)AtomName(libs->name), LOCAL_FileNameBuf, true)) { if (!Yap_locateFile((char *)AtomName(libs->name), LOCAL_FileNameBuf,
true)) {
/* use LD_LIBRARY_PATH */ /* use LD_LIBRARY_PATH */
strncpy(LOCAL_FileNameBuf, (char *)AtomName(libs->name), YAP_FILENAME_MAX); strncpy(LOCAL_FileNameBuf, (char *)AtomName(libs->name),
YAP_FILENAME_MAX);
} }
#ifdef __osf__ #ifdef __osf__
if((libs->handle=dlopen(LOCAL_FileNameBuf,RTLD_LAZY)) == NULL) if ((libs->handle = dlopen(LOCAL_FileNameBuf, RTLD_LAZY)) == NULL)
#else #else
if((libs->handle=dlopen(LOCAL_FileNameBuf,RTLD_LAZY|RTLD_GLOBAL)) == NULL) if ((libs->handle = dlopen(LOCAL_FileNameBuf, RTLD_LAZY | RTLD_GLOBAL)) ==
NULL)
#endif #endif
{ {
strcpy(LOCAL_ErrorSay,dlerror()); strcpy(LOCAL_ErrorSay, dlerror());
return LOAD_FAILLED; return LOAD_FAILLED;
} }
libs = libs->next; libs = libs->next;
@ -214,51 +200,50 @@ LoadForeign(StringList ofiles, StringList libs,
while (ofiles) { while (ofiles) {
void *handle; void *handle;
/* load libraries first so that their symbols are available to /* load libraries first so that their symbols are available to
other routines */ other routines */
/* dlopen wants to follow the LD_CONFIG_PATH */ /* dlopen wants to follow the LD_CONFIG_PATH */
if (!Yap_locateFile((char *)AtomName(ofiles->name), LOCAL_FileNameBuf, TRUE)) { if (!Yap_locateFile((char *)AtomName(ofiles->name), LOCAL_FileNameBuf,
strcpy(LOCAL_ErrorSay, "%% Trying to open unexisting file in LoadForeign"); TRUE)) {
strcpy(LOCAL_ErrorSay,
"%% Trying to open unexisting file in LoadForeign");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
#ifdef __osf__ #ifdef __osf__
if((handle=dlopen(LOCAL_FileNameBuf,RTLD_LAZY)) == 0) if ((handle = dlopen(LOCAL_FileNameBuf, RTLD_LAZY)) == 0)
#else #else
if((handle=dlopen(LOCAL_FileNameBuf,RTLD_LAZY|RTLD_GLOBAL)) == 0) if ((handle = dlopen(LOCAL_FileNameBuf, RTLD_LAZY | RTLD_GLOBAL)) == 0)
#endif #endif
{ {
fprintf(stderr,"dlopen of image %s failed: %s\n", LOCAL_FileNameBuf, dlerror()); fprintf(stderr, "dlopen of image %s failed: %s\n", LOCAL_FileNameBuf,
/* strcpy(LOCAL_ErrorSay,dlerror());*/ dlerror());
/* strcpy(LOCAL_ErrorSay,dlerror());*/
return LOAD_FAILLED; return LOAD_FAILLED;
} }
ofiles->handle = handle; ofiles->handle = handle;
if (proc_name && !*init_proc) if (proc_name && !*init_proc)
*init_proc = (YapInitProc) dlsym(handle,proc_name); *init_proc = (YapInitProc)dlsym(handle, proc_name);
ofiles = ofiles->next; ofiles = ofiles->next;
} }
if(! *init_proc) { if (!*init_proc) {
strcpy(LOCAL_ErrorSay,"Could not locate initialization routine"); strcpy(LOCAL_ErrorSay, "Could not locate initialization routine");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
return LOAD_SUCCEEDED; return LOAD_SUCCEEDED;
} }
Int Int Yap_LoadForeign(StringList ofiles, StringList libs, char *proc_name,
Yap_LoadForeign(StringList ofiles, StringList libs, YapInitProc *init_proc) {
char *proc_name, YapInitProc *init_proc)
{
return LoadForeign(ofiles, libs, proc_name, init_proc); return LoadForeign(ofiles, libs, proc_name, init_proc);
} }
void void Yap_ShutdownLoadForeign(void) {
Yap_ShutdownLoadForeign(void)
{
ForeignObj *f_code; ForeignObj *f_code;
f_code = ForeignCodeLoaded; f_code = ForeignCodeLoaded;
@ -270,7 +255,7 @@ Yap_ShutdownLoadForeign(void)
while (objs != NULL) { while (objs != NULL) {
old = objs; old = objs;
if (dlclose(objs->handle) != 0) if (dlclose(objs->handle) != 0)
return; /* ERROR */ return; /* ERROR */
objs = objs->next; objs = objs->next;
Yap_FreeCodeSpace((ADDR)old); Yap_FreeCodeSpace((ADDR)old);
} }
@ -278,7 +263,7 @@ Yap_ShutdownLoadForeign(void)
while (libs != NULL) { while (libs != NULL) {
old = libs; old = libs;
if (dlclose(libs->handle) != 0) if (dlclose(libs->handle) != 0)
return; /* ERROR */ return; /* ERROR */
libs = libs->next; libs = libs->next;
Yap_FreeCodeSpace((ADDR)old); Yap_FreeCodeSpace((ADDR)old);
} }
@ -292,30 +277,19 @@ Yap_ShutdownLoadForeign(void)
ForeignCodeLoaded = NULL; ForeignCodeLoaded = NULL;
} }
Int Int Yap_ReLoadForeign(StringList ofiles, StringList libs, char *proc_name,
Yap_ReLoadForeign(StringList ofiles, StringList libs, YapInitProc *init_proc) {
char *proc_name, YapInitProc *init_proc) return (LoadForeign(ofiles, libs, proc_name, init_proc));
{
return(LoadForeign(ofiles,libs, proc_name, init_proc));
} }
#endif #endif
#if SIMICS #if SIMICS
void dlopen(void) void dlopen(void) {}
{
}
void dlclose(void) void dlclose(void) {}
{
}
void dlsym(void) void dlsym(void) {}
{
}
#endif #endif