14 #define dln_notimplement rb_notimplement
15 #define dln_memerror rb_memerror
16 #define dln_exit rb_exit
17 #define dln_loaderror rb_loaderror
19 #define dln_notimplement --->>> dln not implemented <<<---
20 #define dln_memerror abort
34 #if defined(HAVE_ALLOCA_H)
50 #define free(x) xfree(x)
56 #include <sys/types.h>
60 # define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
63 #ifdef HAVE_SYS_PARAM_H
64 # include <sys/param.h>
67 # define MAXPATHLEN 1024
78 #if defined(__APPLE__) && defined(__MACH__)
79 # if defined(HAVE_DLOPEN)
81 # define MACOSX_DLOPEN
87 #if defined(__BEOS__) || defined(__HAIKU__)
97 vfprintf(stderr, format, ap);
103 #if defined(HAVE_DLOPEN) && !defined(USE_DLN_A_OUT) && !defined(_AIX) && !defined(MACOSX_DYLD) && !defined(_UNICOSMP)
105 # define USE_DLN_DLOPEN
108 #ifndef FUNCNAME_PATTERN
109 # if defined(__hp9000s300) || ((defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)) && !defined(__ELF__)) || defined(__BORLANDC__) || defined(NeXT) || defined(__WATCOMC__) || defined(MACOSX_DYLD)
110 # define FUNCNAME_PREFIX "_Init_"
112 # define FUNCNAME_PREFIX "Init_"
116 #if defined __CYGWIN__ || defined DOSISH
117 #define isdirsep(x) ((x) == '/' || (x) == '\\')
119 #define isdirsep(x) ((x) == '/')
125 const char *
p = *file, *base, *dot =
NULL;
128 for (base = p; *
p; p++) {
129 if (*p ==
'.' && !dot) dot =
p;
134 return (dot ? dot : p) - base;
139 #define init_funcname(buf, file) do {\
140 const char *base = (file);\
141 const size_t flen = init_funcname_len(&base);\
142 const size_t plen = sizeof(funcname_prefix);\
143 char *const tmp = ALLOCA_N(char, plen+flen+1);\
147 memcpy(tmp, funcname_prefix, plen);\
148 memcpy(tmp+plen, base, flen);\
149 tmp[plen+flen] = '\0';\
156 # define LIBC_NAME "libc.a"
159 #ifndef DLN_DEFAULT_LIB_PATH
160 # define DLN_DEFAULT_LIB_PATH "/lib:/usr/lib:/usr/local/lib:."
165 static int dln_errno;
167 #define DLN_ENOEXEC ENOEXEC
168 #define DLN_ECONFL 1201
169 #define DLN_ENOINIT 1202
170 #define DLN_EUNDEF 1203
171 #define DLN_ENOTLIB 1204
172 #define DLN_EBADLIB 1205
173 #define DLN_EINIT 1206
175 static int dln_init_p = 0;
183 # define N_MAGIC(x) (x).a_magic
186 #define INVALID_OBJECT(h) (N_MAGIC(h) != OMAGIC)
194 static int load_lib();
197 load_header(
int fd,
struct exec *hdrp,
long disp)
202 size = read(fd, hdrp,
sizeof(
struct exec));
207 if (size !=
sizeof(
struct exec) || N_BADMAG(*hdrp)) {
208 dln_errno = DLN_ENOEXEC;
215 #define RELOC_SYMBOL(r) ((r)->r_symbolnum)
216 #define RELOC_MEMORY_SUB_P(r) ((r)->r_bsr)
217 #define RELOC_PCREL_P(r) ((r)->r_pcrel || (r)->r_bsr)
218 #define RELOC_TARGET_SIZE(r) ((r)->r_length)
222 #ifndef RELOC_ADDRESS
223 #define RELOC_ADDRESS(r) ((r)->r_address)
224 #define RELOC_EXTERN_P(r) ((r)->r_extern)
225 #define RELOC_SYMBOL(r) ((r)->r_symbolnum)
226 #define RELOC_MEMORY_SUB_P(r) 0
227 #define RELOC_PCREL_P(r) ((r)->r_pcrel)
228 #define RELOC_TARGET_SIZE(r) ((r)->r_length)
231 #if defined(sun) && defined(sparc)
233 # undef relocation_info
234 # define relocation_info reloc_info_sparc
235 # define R_RIGHTSHIFT(r) (reloc_r_rightshift[(r)->r_type])
236 # define R_BITSIZE(r) (reloc_r_bitsize[(r)->r_type])
237 # define R_LENGTH(r) (reloc_r_length[(r)->r_type])
238 static int reloc_r_rightshift[] = {
239 0, 0, 0, 0, 0, 0, 2, 2, 10, 0, 0, 0, 0, 0, 0,
241 static int reloc_r_bitsize[] = {
242 8, 16, 32, 8, 16, 32, 30, 22, 22, 22, 13, 10, 32, 32, 16,
244 static int reloc_r_length[] = {
245 0, 1, 2, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
247 # define R_PCREL(r) \
248 ((r)->r_type >= RELOC_DISP8 && (r)->r_type <= RELOC_WDISP22)
249 # define R_SYMBOL(r) ((r)->r_index)
253 #define R_SYMBOL(r) ((r)->r_symbolnum)
254 #define R_MEMORY_SUB(r) ((r)->r_bsr)
255 #define R_PCREL(r) ((r)->r_pcrel || (r)->r_bsr)
256 #define R_LENGTH(r) ((r)->r_length)
260 # define R_SYMBOL(r) ((r)->r_symbolnum)
261 # define R_MEMORY_SUB(r) 0
262 # define R_PCREL(r) ((r)->r_pcrel)
263 # define R_LENGTH(r) ((r)->r_length)
266 static struct relocation_info *
267 load_reloc(
int fd,
struct exec *hdrp,
long disp)
269 struct relocation_info *reloc;
272 lseek(fd, disp + N_TXTOFF(*hdrp) + hdrp->a_text + hdrp->a_data, 0);
273 size = hdrp->a_trsize + hdrp->a_drsize;
274 reloc = (
struct relocation_info*)
xmalloc(size);
280 if (read(fd, reloc, size) !=
size) {
289 static struct nlist *
290 load_sym(
int fd,
struct exec *hdrp,
long disp)
292 struct nlist * buffer;
298 lseek(fd, N_SYMOFF(*hdrp) + hdrp->a_syms + disp, 0);
299 if (read(fd, &size,
sizeof(
int)) !=
sizeof(
int)) {
303 buffer = (
struct nlist*)
xmalloc(hdrp->a_syms + size);
304 if (buffer ==
NULL) {
309 lseek(fd, disp + N_SYMOFF(*hdrp), 0);
310 if (read(fd, buffer, hdrp->a_syms + size) != hdrp->a_syms + size) {
316 end = sym + hdrp->a_syms /
sizeof(
struct nlist);
317 displ = (
long)buffer + (
long)(hdrp->a_syms);
320 sym->n_un.n_name = (
char*)sym->n_un.n_strx + displ;
326 dln_errno = DLN_ENOEXEC;
331 sym_hash(
struct exec *hdrp,
struct nlist *syms)
334 struct nlist *sym = syms;
335 struct nlist *end = syms + (hdrp->a_syms /
sizeof(
struct nlist));
351 dln_init(
const char *prog)
358 if (dln_init_p == 1)
return 0;
361 if (file ==
NULL || (fd = open(file, O_RDONLY)) < 0) {
366 if (load_header(fd, &hdr, 0) == -1)
return -1;
367 syms = load_sym(fd, &hdr, 0);
372 sym_tbl = sym_hash(&hdr, syms);
373 if (sym_tbl ==
NULL) {
380 if (read(fd, &c, 1) == -1) {
384 if (c !=
'#')
goto err_noexec;
385 if (read(fd, &c, 1) == -1) {
389 if (c !=
'!')
goto err_noexec;
393 while (read(fd, &c, 1) == 1) {
394 if (c ==
'\n')
goto err_noexec;
395 if (c !=
'\t' && c !=
' ') {
401 while (read(fd, p, 1) == 1) {
402 if (*p ==
'\n' || *p ==
'\t' || *p ==
' ')
break;
405 dln_errno = ENAMETOOLONG;
411 return dln_init(buf);
420 dln_errno = DLN_ENOEXEC;
425 load_text_data(
int fd,
struct exec *hdrp,
int bss,
long disp)
430 lseek(fd, disp + N_TXTOFF(*hdrp), 0);
431 size = hdrp->a_text + hdrp->a_data;
433 if (bss == -1) size += hdrp->a_bss;
434 else if (bss > 1) size += bss;
436 addr = (
unsigned char*)
xmalloc(size);
442 if (read(fd, addr, size) !=
size) {
449 memset(addr + hdrp->a_text + hdrp->a_data, 0, hdrp->a_bss);
452 memset(addr + hdrp->a_text + hdrp->a_data, 0, bss);
461 fprintf(stderr,
" %s\n", key);
466 dln_print_undef(
void)
468 fprintf(stderr,
" Undefined symbols:\n");
476 fprintf(stderr,
"dln: Calling undefined function\n");
484 struct relocation_info reloc;
496 link_undef(
const char *
name,
long base,
struct relocation_info *reloc)
500 char *addr = (
char*)(reloc->r_address + base);
502 obj = (
struct undef*)
xmalloc(
sizeof(
struct undef));
506 switch (R_LENGTH(reloc)) {
511 obj->u.s = *(
short*)addr;
514 obj->u.l = *(
long*)addr;
517 if (reloc_tbl ==
NULL) {
529 reloc_undef(
int no,
struct undef *undef,
struct reloc_arg *
arg)
533 #if defined(sun) && defined(sparc)
534 unsigned int mask = 0;
537 if (strcmp(arg->name, undef->name) != 0)
return ST_CONTINUE;
538 address = (
char*)(undef->base + undef->reloc.r_address);
541 if (R_PCREL(&(undef->reloc))) datum -= undef->base;
542 #
if defined(sun) && defined(sparc)
543 datum += undef->reloc.r_addend;
544 datum >>= R_RIGHTSHIFT(&(undef->reloc));
545 mask = (1 << R_BITSIZE(&(undef->reloc))) - 1;
548 switch (R_LENGTH(&(undef->reloc))) {
550 *address = undef->u.c;
555 *(
short *)address = undef->u.s;
556 *(
short *)address &= ~mask;
557 *(
short *)address |= datum;
560 *(
long *)address = undef->u.l;
561 *(
long *)address &= ~mask;
562 *(
long *)address |= datum;
566 switch (R_LENGTH(&(undef->reloc))) {
568 if (R_MEMORY_SUB(&(undef->reloc)))
569 *address = datum - *address;
570 else *address = undef->u.c + datum;
573 if (R_MEMORY_SUB(&(undef->reloc)))
574 *(
short*)address = datum - *(
short*)address;
575 else *(
short*)address = undef->u.s + datum;
578 if (R_MEMORY_SUB(&(undef->reloc)))
579 *(
long*)address = datum - *(
long*)address;
580 else *(
long*)address = undef->u.l + datum;
590 unlink_undef(
const char *name,
long value)
592 struct reloc_arg arg;
605 reloc_repl(
int no,
struct undef *undef,
struct indr_data *
data)
607 if (strcmp(data->name0, undef->name) == 0) {
609 undef->name =
strdup(data->name1);
616 load_1(
int fd,
long disp,
const char *need_init)
618 static const char *libc = LIBC_NAME;
620 struct relocation_info *reloc =
NULL;
623 struct nlist *syms =
NULL;
628 if (load_header(fd, &hdr, disp) == -1)
return -1;
629 if (INVALID_OBJECT(hdr)) {
630 dln_errno = DLN_ENOEXEC;
633 reloc = load_reloc(fd, &hdr, disp);
634 if (reloc ==
NULL)
return -1;
636 syms = load_sym(fd, &hdr, disp);
643 end = syms + (hdr.a_syms /
sizeof(
struct nlist));
645 struct nlist *old_sym;
646 int value = sym->n_value;
649 if (sym->n_type == (N_INDR | N_EXT)) {
650 char *
key = sym->n_un.n_name;
652 if (
st_lookup(sym_tbl, sym[1].n_un.n_name, &old_sym)) {
654 unlink_undef(key, old_sym->n_value);
659 struct indr_data data;
661 data.name0 = sym->n_un.n_name;
662 data.name1 = sym[1].n_un.n_name;
674 if (sym->n_type == (N_UNDF | N_EXT)) {
675 if (
st_lookup(sym_tbl, sym->n_un.n_name, &old_sym) == 0) {
681 sym->n_type = N_EXT | N_COMM;
682 sym->n_value = old_sym->n_value;
686 value >=
sizeof(double) ?
sizeof(
double) - 1
687 : value >=
sizeof(
long) ?
sizeof(
long) - 1
690 sym->n_type = N_COMM;
692 new_common &= ~(
long)rnd;
693 sym->n_value = new_common;
699 sym->n_type = N_EXT | N_COMM;
700 sym->n_value = old_sym->n_value;
703 sym->n_value = (
long)dln_undefined;
711 block = load_text_data(fd, &hdr, hdr.a_bss + new_common, disp);
712 if (block == 0)
goto err_exit;
716 struct nlist *new_sym;
719 switch (sym->n_type) {
721 sym->n_value += hdr.a_text + hdr.a_data;
725 sym->n_value +=
block;
727 if (
st_lookup(sym_tbl, sym->n_un.n_name, &new_sym) != 0
728 && new_sym->n_value != (
long)dln_undefined) {
729 dln_errno = DLN_ECONFL;
733 key = sym->n_un.n_name;
735 unlink_undef(key, sym->n_value);
739 new_sym = (
struct nlist*)
xmalloc(
sizeof(
struct nlist));
741 new_sym->n_un.n_name =
strdup(sym->n_un.n_name);
742 st_insert(sym_tbl, new_sym->n_un.n_name, new_sym);
747 sym->n_value +=
block;
757 struct relocation_info * rel = reloc;
758 struct relocation_info * rel_beg = reloc +
759 (hdr.a_trsize/
sizeof(
struct relocation_info));
760 struct relocation_info * rel_end = reloc +
761 (hdr.a_trsize+hdr.a_drsize)/
sizeof(
struct relocation_info);
763 while (rel < rel_end) {
764 char *address = (
char*)(rel->r_address + block);
766 #if defined(sun) && defined(sparc)
767 unsigned int mask = 0;
771 address += hdr.a_text;
774 sym = &(syms[R_SYMBOL(rel)]);
775 switch (sym->n_type) {
777 link_undef(sym->n_un.n_name, block, rel);
780 datum = sym->n_value;
787 switch (R_SYMBOL(rel)) {
793 datum = block + new_common;
799 if (R_PCREL(rel)) datum -=
block;
801 #if defined(sun) && defined(sparc)
802 datum += rel->r_addend;
803 datum >>= R_RIGHTSHIFT(rel);
804 mask = (1 << R_BITSIZE(rel)) - 1;
808 switch (R_LENGTH(rel)) {
814 *(
short *)address &= ~mask;
815 *(
short *)address |= datum;
818 *(
long *)address &= ~mask;
819 *(
long *)address |= datum;
823 switch (R_LENGTH(rel)) {
829 *(
short *)address += datum;
832 *(
long *)address += datum;
842 char **libs_to_be_linked = 0;
846 if (load_lib(libc) == -1)
goto err_exit;
852 for (sym = syms; sym<
end; sym++) {
853 char *name = sym->n_un.n_name;
854 if (name[0] ==
'_' && sym->n_value >= block) {
855 if (strcmp(name+1,
"dln_libs_to_be_linked") == 0) {
856 libs_to_be_linked = (
char**)sym->n_value;
858 else if (strcmp(name+1, buf) == 0) {
860 ((
int (*)())sym->n_value)();
864 if (libs_to_be_linked && undef_tbl->
num_entries > 0) {
865 while (*libs_to_be_linked) {
866 load_lib(*libs_to_be_linked);
875 dln_errno = DLN_ENOINIT;
879 if (load_lib(libc) == -1)
goto err_exit;
881 dln_errno = DLN_EUNDEF;
889 if (syms)
free(syms);
890 if (reloc)
free(reloc);
891 if (block)
free((
char*)block);
895 static int target_offset;
897 search_undef(
const char *key,
int value,
st_table *lib_tbl)
902 target_offset = offset;
911 const char *dln_librrb_ary_path = DLN_DEFAULT_LIB_PATH;
914 load_lib(
const char *lib)
918 char armagic[SARMAG];
926 if (dln_init_p == 0) {
927 dln_errno = DLN_ENOINIT;
932 dln_errno = DLN_EBADLIB;
934 if (lib[0] ==
'-' && lib[1] ==
'l') {
935 long len =
strlen(lib) + 4;
945 path =
getenv(
"DLN_LIBRARY_PATH");
946 if (path ==
NULL) path = dln_librrb_ary_path;
947 else path = envpath =
strdup(path);
950 if (envpath)
free(envpath);
951 fd = open(file, O_RDONLY);
952 if (fd == -1)
goto syserr;
953 size = read(fd, armagic, SARMAG);
954 if (size == -1)
goto syserr;
956 if (size != SARMAG) {
957 dln_errno = DLN_ENOTLIB;
960 size = read(fd, &ahdr,
sizeof(ahdr));
961 if (size == -1)
goto syserr;
962 if (size !=
sizeof(ahdr) || sscanf(ahdr.ar_size,
"%d", &size) != 1) {
966 if (strncmp(ahdr.ar_name,
"__.SYMDEF", 9) == 0) {
971 if (data ==
NULL)
goto syserr;
972 size = read(fd, data, size);
973 nsym = *data /
sizeof(
struct symdef);
974 base = (
struct symdef*)(data + 1);
975 name_base = (
char*)(base + nsym) +
sizeof(
int);
977 char *name = name_base + base->rb_str_index;
979 st_insert(lib_tbl, name, base->lib_offset +
sizeof(ahdr));
986 if (target_offset == -1)
break;
987 if (load_1(fd, target_offset, 0) == -1) {
1001 int offset = SARMAG;
1004 struct nlist *syms, *
sym, *
end;
1008 lseek(fd, offset, 0);
1009 size = read(fd, &ahdr,
sizeof(ahdr));
1010 if (size == -1)
goto syserr;
1011 if (size == 0)
break;
1012 if (size !=
sizeof(ahdr)
1013 || sscanf(ahdr.ar_size,
"%d", &size) != 1) {
1016 offset +=
sizeof(ahdr);
1017 if (load_header(fd, &hdr, offset) == -1)
1019 syms = load_sym(fd, &hdr, offset);
1020 if (syms ==
NULL)
goto badlib;
1022 end = syms + (hdr.a_syms /
sizeof(
struct nlist));
1024 if (sym->n_type == N_EXT|N_TEXT
1033 if (load_1(fd, offset, 0) == -1) {
1038 if (offset & 1) offset++;
1049 if (fd >= 0) close(fd);
1054 load(
const char *file)
1059 if (dln_init_p == 0) {
1060 if (dln_init(dln_argv0) == -1)
return -1;
1063 if (file[result-1] ==
'a') {
1064 return load_lib(file);
1067 fd = open(file, O_RDONLY);
1072 result = load_1(fd, 0, file);
1079 dln_sym(
const char *name)
1084 return (
void*)sym->n_value;
1090 #ifdef USE_DLN_DLOPEN
1102 #include <sys/ldr.h>
1106 #if NS_TARGET_MAJOR < 4
1107 #include <mach-o/rld.h>
1109 #include <mach-o/dyld.h>
1110 #ifndef NSLINKMODULE_OPTION_BINDNOW
1111 #define NSLINKMODULE_OPTION_BINDNOW 1
1116 #include <mach-o/dyld.h>
1120 #if defined _WIN32 && !defined __CYGWIN__
1121 #include <windows.h>
1122 #include <imagehlp.h>
1125 #if defined _WIN32 && !defined __CYGWIN__
1129 int error = GetLastError();
1131 size_t len =
snprintf(message, size,
"%d: ", error);
1133 #define format_message(sublang) FormatMessage(\
1134 FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, \
1135 NULL, error, MAKELANGID(LANG_NEUTRAL, (sublang)), \
1136 message + len, size - len, NULL)
1137 if (format_message(SUBLANG_ENGLISH_US) == 0)
1138 format_message(SUBLANG_DEFAULT);
1139 for (p = message + len; *
p; p++) {
1140 if (*p ==
'\n' || *p ==
'\r')
1145 #define dln_strerror() dln_strerror(message, sizeof message)
1146 #elif ! defined _AIX
1150 #ifdef USE_DLN_A_OUT
1153 switch (dln_errno) {
1155 return "Symbol name conflict";
1157 return "No initializer given";
1159 return "Unresolved symbols";
1161 return "Not a library file";
1163 return "Malformed library file";
1165 return "Not initialized";
1171 #ifdef USE_DLN_DLOPEN
1172 return (
char*)dlerror();
1177 #if defined(_AIX) && ! defined(_IA64)
1179 aix_loaderror(
const char *pathname)
1181 char *message[1024], errbuf[1024];
1183 #define ERRBUF_APPEND(s) strncat(errbuf, (s), sizeof(errbuf)-strlen(errbuf)-1)
1184 snprintf(errbuf,
sizeof(errbuf),
"load failed - %s. ", pathname);
1186 if (loadquery(L_GETMESSAGES, &message[0],
sizeof(message)) != -1) {
1187 ERRBUF_APPEND(
"Please issue below command for detailed reasons:\n\t");
1188 ERRBUF_APPEND(
"/usr/sbin/execerror ruby ");
1189 for (i=0; message[
i]; i++) {
1190 ERRBUF_APPEND(
"\"");
1191 ERRBUF_APPEND(message[i]);
1192 ERRBUF_APPEND(
"\" ");
1194 ERRBUF_APPEND(
"\n");
1197 ERRBUF_APPEND(
"[loadquery failed]");
1203 #if defined _WIN32 && defined RUBY_EXPORT
1204 HANDLE rb_libruby_handle(
void);
1207 rb_w32_check_imported(HMODULE ext, HMODULE mine)
1210 const IMAGE_IMPORT_DESCRIPTOR *desc;
1212 desc = ImageDirectoryEntryToData(ext,
TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &size);
1213 if (!desc)
return 0;
1214 while (desc->Name) {
1215 PIMAGE_THUNK_DATA pint = (PIMAGE_THUNK_DATA)((
char *)ext + desc->Characteristics);
1216 PIMAGE_THUNK_DATA piat = (PIMAGE_THUNK_DATA)((
char *)ext + desc->FirstThunk);
1217 for (; piat->u1.Function; piat++, pint++) {
1218 static const char prefix[] =
"rb_";
1219 PIMAGE_IMPORT_BY_NAME pii;
1222 if (IMAGE_SNAP_BY_ORDINAL(pint->u1.Ordinal))
continue;
1223 pii = (PIMAGE_IMPORT_BY_NAME)((
char *)ext + (size_t)pint->u1.AddressOfData);
1224 name = (
const char *)pii->Name;
1225 if (strncmp(name, prefix,
sizeof(prefix) - 1) == 0) {
1226 FARPROC addr = GetProcAddress(mine, name);
1227 if (addr)
return (FARPROC)piat->u1.Function == addr;
1236 #if defined(DLN_NEEDS_ALT_SEPARATOR) && DLN_NEEDS_ALT_SEPARATOR
1237 #define translit_separator(src) do { \
1238 char *tmp = ALLOCA_N(char, strlen(src) + 1), *p = tmp, c; \
1240 *p++ = ((c = *file++) == '/') ? DLN_NEEDS_ALT_SEPARATOR : c; \
1245 #define translit_separator(str) (void)(str)
1251 #if !defined(_AIX) && !defined(NeXT)
1252 const char *error = 0;
1253 #define DLN_ERROR() (error = dln_strerror(), strcpy(ALLOCA_N(char, strlen(error) + 1), error))
1256 #if defined _WIN32 && !defined __CYGWIN__
1268 strlcpy(winfile, file,
sizeof(winfile));
1271 if ((handle = LoadLibrary(winfile)) ==
NULL) {
1276 #if defined _WIN32 && defined RUBY_EXPORT
1277 if (!rb_w32_check_imported(handle, rb_libruby_handle())) {
1278 FreeLibrary(handle);
1279 error =
"incompatible library version";
1284 if ((init_fct = (
void(*)())GetProcAddress(handle, buf)) ==
NULL) {
1292 #ifdef USE_DLN_A_OUT
1293 if (load(file) == -1) {
1305 #ifdef USE_DLN_DLOPEN
1312 # define RTLD_LAZY 1
1318 # define RTLD_GLOBAL 0
1322 if ((handle = (
void*)dlopen(file, RTLD_LAZY|RTLD_GLOBAL)) ==
NULL) {
1327 init_fct = (
void(*)())(
VALUE)dlsym(handle, buf);
1328 #if defined __SYMBIAN32__
1329 if (init_fct ==
NULL) {
1330 init_fct = (
void(*)())dlsym(handle,
"1");
1333 if (init_fct ==
NULL) {
1352 flags = BIND_DEFERRED;
1353 lib = shl_load(file, flags, 0);
1358 shl_findsym(&lib, buf, TYPE_PROCEDURE, (
void*)&init_fct);
1359 if (init_fct ==
NULL) {
1360 shl_findsym(&lib, buf, TYPE_UNDEFINED, (
void*)&init_fct);
1361 if (init_fct ==
NULL) {
1371 #if defined(_AIX) && ! defined(_IA64)
1376 init_fct = (
void(*)())load((
char*)file, 1, 0);
1377 if (init_fct ==
NULL) {
1378 aix_loaderror(file);
1380 if (loadbind(0, (
void*)
dln_load, (
void*)init_fct) == -1) {
1381 aix_loaderror(file);
1384 return (
void*)init_fct;
1388 #if defined(NeXT) || defined(MACOSX_DYLD)
1399 #if defined(NeXT) && (NS_TARGET_MAJOR < 4)
1403 unsigned long init_address;
1404 char *object_files[2] = {
NULL,
NULL};
1408 object_files[0] = (
char*)file;
1410 s = NXOpenFile(2,NX_WRITEONLY);
1413 if(rld_load(s,
NULL, object_files,
NULL) == 0) {
1420 if(rld_lookup(s, buf, &init_address) == 0) {
1423 dln_loaderror(
"Failed to lookup Init function %.200s", file);
1431 init_fct = (
void(*)())init_address;
1433 return (
void*)init_address;
1438 NSObjectFileImage obj_file;
1445 dyld_result = NSCreateObjectFileImageFromFile(file, &obj_file);
1447 if (dyld_result != NSObjectFileImageSuccess) {
1451 NSLinkModule(obj_file, file, NSLINKMODULE_OPTION_BINDNOW);
1454 if(!NSIsSymbolNameDefined(buf)) {
1455 dln_loaderror(
"Failed to lookup Init function %.200s",file);
1457 init_fct = NSAddressOfSymbol(NSLookupAndBindSymbol(buf));
1460 return (
void*)init_fct;
1465 #if defined(__BEOS__) || defined(__HAIKU__)
1466 # define DLN_DEFINED
1473 img_id = load_add_on(file);
1485 err_stat = get_image_symbol(img_id, buf,
1486 B_SYMBOL_TYPE_TEXT, (
void **)&init_fct);
1488 if (err_stat != B_NO_ERROR) {
1493 err_stat = get_image_symbol(img_id, real_name,
1494 B_SYMBOL_TYPE_TEXT, (
void **)&init_fct);
1497 if ((B_BAD_IMAGE_ID == err_stat) || (B_BAD_INDEX == err_stat)) {
1498 unload_add_on(img_id);
1499 dln_loaderror(
"Failed to lookup Init function %.200s", file);
1501 else if (B_NO_ERROR != err_stat) {
1502 char errmsg[] =
"Internal of BeOS version. %.200s (symbol_name = %s)";
1503 unload_add_on(img_id);
1509 return (
void*)img_id;
1519 #if !defined(_AIX) && !defined(NeXT)
static void dln_loaderror(const char *format,...)
int register char * block
size_t strlen(const char *)
if(len<=MAX_WORD_LENGTH &&len >=MIN_WORD_LENGTH)
char * dln_find_file_r(const char *, const char *, char *, size_t)
static const char funcname_prefix[sizeof(FUNCNAME_PREFIX)-1]
memset(y->frac+ix+1, 0,(y->Prec-(ix+1))*sizeof(BDIGIT))
unsigned char buf[MIME_BUF_SIZE]
#define init_funcname(buf, file)
char * dln_find_exe_r(const char *, const char *, char *, size_t)
register unsigned int len
RUBY_EXTERN size_t strlcpy(char *, const char *, size_t)
void * dln_load(const char *file)
static const char * dln_strerror(void)
static size_t init_funcname_len(const char **file)
static long rb_str_index(VALUE str, VALUE sub, long offset)
RUBY_EXTERN char * strerror(int)
#define translit_separator(str)
RUBY_EXTERN size_t strlcat(char *, const char *, size_t)
static char fbuf[MAXPATHLEN]
static ULONG(STDMETHODCALLTYPE AddRef)(IDispatch __RPC_FAR *This)