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 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;
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;
449 memset(addr + hdrp->a_text + hdrp->a_data, 0, hdrp->a_bss);
452 memset(addr + hdrp->a_text + hdrp->a_data, 0, bss);
459 undef_print(
char *
key,
char *value)
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;
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;
728 && new_sym->n_value != (
long)dln_undefined) {
729 dln_errno = DLN_ECONFL;
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);
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;
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;
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;
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();
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 1321 #ifdef __native_client__ 1323 if (file[0] ==
'.' && file[1] ==
'/') file+=2;
1325 for (
p = file; *
p; ++
p) {
1326 if (*
p ==
'/') *
p =
'_';
1330 if ((handle = (
void*)dlopen(file, RTLD_LAZY|RTLD_GLOBAL)) ==
NULL) {
1331 #ifdef __native_client__ 1338 init_fct = (void(*)())(
VALUE)dlsym(handle,
buf);
1339 #ifdef __native_client__ 1343 #if defined __SYMBIAN32__ 1344 if (init_fct ==
NULL) {
1345 init_fct = (void(*)())dlsym(handle,
"1");
1348 if (init_fct ==
NULL) {
1367 flags = BIND_DEFERRED;
1368 lib = shl_load(file, flags, 0);
1373 shl_findsym(&lib,
buf, TYPE_PROCEDURE, (
void*)&init_fct);
1374 if (init_fct ==
NULL) {
1375 shl_findsym(&lib,
buf, TYPE_UNDEFINED, (
void*)&init_fct);
1376 if (init_fct ==
NULL) {
1386 #if defined(_AIX) && ! defined(_IA64) 1391 init_fct = (void(*)())load((
char*)file, 1, 0);
1392 if (init_fct ==
NULL) {
1393 aix_loaderror(file);
1395 if (loadbind(0, (
void*)
dln_load, (
void*)init_fct) == -1) {
1396 aix_loaderror(file);
1399 return (
void*)init_fct;
1403 #if defined(MACOSX_DYLD) 1416 NSObjectFileImage obj_file;
1423 dyld_result = NSCreateObjectFileImageFromFile(file, &obj_file);
1425 if (dyld_result != NSObjectFileImageSuccess) {
1429 NSLinkModule(obj_file, file, NSLINKMODULE_OPTION_BINDNOW);
1432 if (!NSIsSymbolNameDefined(
buf)) {
1433 dln_loaderror(
"Failed to lookup Init function %.200s",file);
1435 init_fct = NSAddressOfSymbol(NSLookupAndBindSymbol(
buf));
1438 return (
void*)init_fct;
1442 #if defined(__BEOS__) || defined(__HAIKU__) 1443 # define DLN_DEFINED 1450 img_id = load_add_on(file);
1462 err_stat = get_image_symbol(img_id,
buf,
1463 B_SYMBOL_TYPE_TEXT, (
void **)&init_fct);
1465 if (err_stat != B_NO_ERROR) {
1470 err_stat = get_image_symbol(img_id, real_name,
1471 B_SYMBOL_TYPE_TEXT, (
void **)&init_fct);
1474 if ((B_BAD_IMAGE_ID == err_stat) || (B_BAD_INDEX == err_stat)) {
1475 unload_add_on(img_id);
1476 dln_loaderror(
"Failed to lookup Init function %.200s", file);
1478 else if (B_NO_ERROR != err_stat) {
1479 char errmsg[] =
"Internal of BeOS version. %.200s (symbol_name = %s)";
1480 unload_add_on(img_id);
1486 return (
void*)img_id;
1496 #if !defined(_AIX) && !defined(NeXT)
static void dln_loaderror(const char *format,...)
size_t strlen(const char *)
if(dispIdMember==DISPID_VALUE)
int st_insert(st_table *, st_data_t, st_data_t)
char * dln_find_file_r(const char *, const char *, char *, size_t)
void st_free_table(st_table *)
st_table * st_init_strtable(void)
static const char funcname_prefix[sizeof(FUNCNAME_PREFIX) - 1]
int st_lookup(st_table *, st_data_t, st_data_t *)
int st_delete(st_table *, st_data_t *, st_data_t *)
#define init_funcname(buf, file)
char * dln_find_exe_r(const char *, const char *, char *, size_t)
unsigned char buf[MIME_BUF_SIZE]
RUBY_EXTERN size_t strlcpy(char *, const char *, size_t)
st_table * st_init_numtable(void)
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]
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
static ULONG(STDMETHODCALLTYPE AddRef)(IDispatch __RPC_FAR *This)