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 EXTERNAL_PREFIX "_" 112 # define EXTERNAL_PREFIX "" 114 # define FUNCNAME_PREFIX EXTERNAL_PREFIX"Init_" 117 #if defined __CYGWIN__ || defined DOSISH 118 #define isdirsep(x) ((x) == '/' || (x) == '\\') 120 #define isdirsep(x) ((x) == '/') 126 const char *p = *file, *base, *dot =
NULL;
129 for (base = p; *p; p++) {
130 if (*p ==
'.' && !dot) dot = p;
135 return (dot ? dot : p) - base;
140 #define init_funcname(buf, file) do {\ 141 const char *base = (file);\ 142 const size_t flen = init_funcname_len(&base);\ 143 const size_t plen = sizeof(funcname_prefix);\ 144 char *const tmp = ALLOCA_N(char, plen+flen+1);\ 148 memcpy(tmp, funcname_prefix, plen);\ 149 memcpy(tmp+plen, base, flen);\ 150 tmp[plen+flen] = '\0';\ 157 # define LIBC_NAME "libc.a" 160 #ifndef DLN_DEFAULT_LIB_PATH 161 # define DLN_DEFAULT_LIB_PATH "/lib:/usr/lib:/usr/local/lib:." 166 static int dln_errno;
168 #define DLN_ENOEXEC ENOEXEC 169 #define DLN_ECONFL 1201 170 #define DLN_ENOINIT 1202 171 #define DLN_EUNDEF 1203 172 #define DLN_ENOTLIB 1204 173 #define DLN_EBADLIB 1205 174 #define DLN_EINIT 1206 176 static int dln_init_p = 0;
184 # define N_MAGIC(x) (x).a_magic 187 #define INVALID_OBJECT(h) (N_MAGIC(h) != OMAGIC) 195 static int load_lib();
198 load_header(
int fd,
struct exec *hdrp,
long disp)
203 size = read(fd, hdrp,
sizeof(
struct exec));
208 if (
size !=
sizeof(
struct exec) || N_BADMAG(*hdrp)) {
209 dln_errno = DLN_ENOEXEC;
216 #define RELOC_SYMBOL(r) ((r)->r_symbolnum) 217 #define RELOC_MEMORY_SUB_P(r) ((r)->r_bsr) 218 #define RELOC_PCREL_P(r) ((r)->r_pcrel || (r)->r_bsr) 219 #define RELOC_TARGET_SIZE(r) ((r)->r_length) 223 #ifndef RELOC_ADDRESS 224 #define RELOC_ADDRESS(r) ((r)->r_address) 225 #define RELOC_EXTERN_P(r) ((r)->r_extern) 226 #define RELOC_SYMBOL(r) ((r)->r_symbolnum) 227 #define RELOC_MEMORY_SUB_P(r) 0 228 #define RELOC_PCREL_P(r) ((r)->r_pcrel) 229 #define RELOC_TARGET_SIZE(r) ((r)->r_length) 232 #if defined(__sun) && defined(__sparc) 234 # undef relocation_info 235 # define relocation_info reloc_info_sparc 236 # define R_RIGHTSHIFT(r) (reloc_r_rightshift[(r)->r_type]) 237 # define R_BITSIZE(r) (reloc_r_bitsize[(r)->r_type]) 238 # define R_LENGTH(r) (reloc_r_length[(r)->r_type]) 239 static int reloc_r_rightshift[] = {
240 0, 0, 0, 0, 0, 0, 2, 2, 10, 0, 0, 0, 0, 0, 0,
242 static int reloc_r_bitsize[] = {
243 8, 16, 32, 8, 16, 32, 30, 22, 22, 22, 13, 10, 32, 32, 16,
245 static int reloc_r_length[] = {
246 0, 1, 2, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
248 # define R_PCREL(r) \ 249 ((r)->r_type >= RELOC_DISP8 && (r)->r_type <= RELOC_WDISP22) 250 # define R_SYMBOL(r) ((r)->r_index) 254 #define R_SYMBOL(r) ((r)->r_symbolnum) 255 #define R_MEMORY_SUB(r) ((r)->r_bsr) 256 #define R_PCREL(r) ((r)->r_pcrel || (r)->r_bsr) 257 #define R_LENGTH(r) ((r)->r_length) 261 # define R_SYMBOL(r) ((r)->r_symbolnum) 262 # define R_MEMORY_SUB(r) 0 263 # define R_PCREL(r) ((r)->r_pcrel) 264 # define R_LENGTH(r) ((r)->r_length) 267 static struct relocation_info *
268 load_reloc(
int fd,
struct exec *hdrp,
long disp)
270 struct relocation_info *reloc;
273 lseek(fd, disp + N_TXTOFF(*hdrp) + hdrp->a_text + hdrp->a_data, 0);
274 size = hdrp->a_trsize + hdrp->a_drsize;
281 if (read(fd, reloc,
size) !=
size) {
290 static struct nlist *
291 load_sym(
int fd,
struct exec *hdrp,
long disp)
293 struct nlist * buffer;
299 lseek(fd, N_SYMOFF(*hdrp) + hdrp->a_syms + disp, 0);
300 if (read(fd, &
size,
sizeof(
int)) !=
sizeof(
int)) {
304 buffer = (
struct nlist*)
xmalloc(hdrp->a_syms +
size);
305 if (buffer ==
NULL) {
310 lseek(fd, disp + N_SYMOFF(*hdrp), 0);
311 if (read(fd, buffer, hdrp->a_syms +
size) != hdrp->a_syms +
size) {
317 end =
sym + hdrp->a_syms /
sizeof(
struct nlist);
318 displ = (long)buffer + (
long)(hdrp->a_syms);
321 sym->n_un.n_name = (
char*)
sym->n_un.n_strx + displ;
327 dln_errno = DLN_ENOEXEC;
332 sym_hash(
struct exec *hdrp,
struct nlist *syms)
335 struct nlist *
sym = syms;
336 struct nlist *end = syms + (hdrp->a_syms /
sizeof(
struct nlist));
352 dln_init(
const char *prog)
359 if (dln_init_p == 1)
return 0;
362 if (file ==
NULL || (fd = open(file, O_RDONLY)) < 0) {
367 if (load_header(fd, &hdr, 0) == -1)
return -1;
368 syms = load_sym(fd, &hdr, 0);
373 sym_tbl = sym_hash(&hdr, syms);
374 if (sym_tbl ==
NULL) {
381 if (read(fd, &c, 1) == -1) {
385 if (c !=
'#')
goto err_noexec;
386 if (read(fd, &c, 1) == -1) {
390 if (c !=
'!')
goto err_noexec;
394 while (read(fd, &c, 1) == 1) {
395 if (c ==
'\n')
goto err_noexec;
396 if (c !=
'\t' && c !=
' ') {
402 while (read(fd, p, 1) == 1) {
403 if (*p ==
'\n' || *p ==
'\t' || *p ==
' ')
break;
406 dln_errno = ENAMETOOLONG;
412 return dln_init(
buf);
421 dln_errno = DLN_ENOEXEC;
426 load_text_data(
int fd,
struct exec *hdrp,
int bss,
long disp)
431 lseek(fd, disp + N_TXTOFF(*hdrp), 0);
432 size = hdrp->a_text + hdrp->a_data;
434 if (bss == -1)
size += hdrp->a_bss;
435 else if (bss > 1)
size += bss;
450 memset(addr + hdrp->a_text + hdrp->a_data, 0, hdrp->a_bss);
453 memset(addr + hdrp->a_text + hdrp->a_data, 0, bss);
460 undef_print(
char *
key,
char *value)
462 fprintf(stderr,
" %s\n",
key);
467 dln_print_undef(
void)
469 fprintf(stderr,
" Undefined symbols:\n");
477 fprintf(stderr,
"dln: Calling undefined function\n");
485 struct relocation_info reloc;
497 link_undef(
const char *
name,
long base,
struct relocation_info *reloc)
501 char *addr = (
char*)(reloc->r_address + base);
503 obj = (
struct undef*)
xmalloc(
sizeof(
struct undef));
507 switch (R_LENGTH(reloc)) {
512 obj->u.s = *(
short*)addr;
515 obj->u.l = *(
long*)addr;
518 if (reloc_tbl ==
NULL) {
530 reloc_undef(
int no,
struct undef *undef,
struct reloc_arg *arg)
534 #if defined(__sun) && defined(__sparc) 535 unsigned int mask = 0;
538 if (strcmp(arg->name, undef->name) != 0)
return ST_CONTINUE;
539 address = (
char*)(undef->base + undef->reloc.r_address);
542 if (R_PCREL(&(undef->reloc)))
datum -= undef->base;
543 #
if defined(__sun) && defined(__sparc)
544 datum += undef->reloc.r_addend;
545 datum >>= R_RIGHTSHIFT(&(undef->reloc));
546 mask = (1 << R_BITSIZE(&(undef->reloc))) - 1;
549 switch (R_LENGTH(&(undef->reloc))) {
551 *address = undef->u.c;
556 *(
short *)address = undef->u.s;
557 *(
short *)address &= ~mask;
558 *(
short *)address |=
datum;
561 *(
long *)address = undef->u.l;
562 *(
long *)address &= ~mask;
563 *(
long *)address |=
datum;
567 switch (R_LENGTH(&(undef->reloc))) {
569 if (R_MEMORY_SUB(&(undef->reloc)))
570 *address =
datum - *address;
571 else *address = undef->u.c +
datum;
574 if (R_MEMORY_SUB(&(undef->reloc)))
575 *(
short*)address =
datum - *(
short*)address;
576 else *(
short*)address = undef->u.s +
datum;
579 if (R_MEMORY_SUB(&(undef->reloc)))
580 *(
long*)address =
datum - *(
long*)address;
581 else *(
long*)address = undef->u.l +
datum;
591 unlink_undef(
const char *
name,
long value)
593 struct reloc_arg arg;
606 reloc_repl(
int no,
struct undef *undef,
struct indr_data *data)
608 if (strcmp(data->name0, undef->name) == 0) {
610 undef->name =
strdup(data->name1);
617 load_1(
int fd,
long disp,
const char *need_init)
619 static const char *libc = LIBC_NAME;
621 struct relocation_info *reloc =
NULL;
624 struct nlist *syms =
NULL;
629 if (load_header(fd, &hdr, disp) == -1)
return -1;
630 if (INVALID_OBJECT(hdr)) {
631 dln_errno = DLN_ENOEXEC;
634 reloc = load_reloc(fd, &hdr, disp);
635 if (reloc ==
NULL)
return -1;
637 syms = load_sym(fd, &hdr, disp);
644 end = syms + (hdr.a_syms /
sizeof(
struct nlist));
646 struct nlist *old_sym;
647 int value =
sym->n_value;
650 if (
sym->n_type == (N_INDR | N_EXT)) {
651 char *
key =
sym->n_un.n_name;
655 unlink_undef(
key, old_sym->n_value);
660 struct indr_data data;
662 data.name0 =
sym->n_un.n_name;
663 data.name1 =
sym[1].n_un.n_name;
675 if (
sym->n_type == (N_UNDF | N_EXT)) {
676 if (
st_lookup(sym_tbl,
sym->n_un.n_name, &old_sym) == 0) {
682 sym->n_type = N_EXT | N_COMM;
683 sym->n_value = old_sym->n_value;
687 value >=
sizeof(double) ?
sizeof(
double) - 1
688 : value >=
sizeof(long) ?
sizeof(
long) - 1
691 sym->n_type = N_COMM;
693 new_common &= ~(long)rnd;
694 sym->n_value = new_common;
700 sym->n_type = N_EXT | N_COMM;
701 sym->n_value = old_sym->n_value;
704 sym->n_value = (long)dln_undefined;
712 block = load_text_data(fd, &hdr, hdr.a_bss + new_common, disp);
713 if (block == 0)
goto err_exit;
717 struct nlist *new_sym;
720 switch (
sym->n_type) {
722 sym->n_value += hdr.a_text + hdr.a_data;
726 sym->n_value += block;
729 && new_sym->n_value != (
long)dln_undefined) {
730 dln_errno = DLN_ECONFL;
736 unlink_undef(
key,
sym->n_value);
740 new_sym = (
struct nlist*)
xmalloc(
sizeof(
struct nlist));
742 new_sym->n_un.n_name =
strdup(
sym->n_un.n_name);
743 st_insert(sym_tbl, new_sym->n_un.n_name, new_sym);
748 sym->n_value += block;
758 struct relocation_info * rel = reloc;
759 struct relocation_info * rel_beg = reloc +
760 (hdr.a_trsize/
sizeof(
struct relocation_info));
761 struct relocation_info * rel_end = reloc +
762 (hdr.a_trsize+hdr.a_drsize)/
sizeof(
struct relocation_info);
764 while (rel < rel_end) {
765 char *address = (
char*)(rel->r_address + block);
767 #if defined(__sun) && defined(__sparc) 768 unsigned int mask = 0;
772 address += hdr.a_text;
775 sym = &(syms[R_SYMBOL(rel)]);
776 switch (
sym->n_type) {
778 link_undef(
sym->n_un.n_name, block, rel);
788 switch (R_SYMBOL(rel)) {
794 datum = block + new_common;
800 if (R_PCREL(rel))
datum -= block;
802 #if defined(__sun) && defined(__sparc) 803 datum += rel->r_addend;
804 datum >>= R_RIGHTSHIFT(rel);
805 mask = (1 << R_BITSIZE(rel)) - 1;
809 switch (R_LENGTH(rel)) {
815 *(
short *)address &= ~mask;
816 *(
short *)address |=
datum;
819 *(
long *)address &= ~mask;
820 *(
long *)address |=
datum;
824 switch (R_LENGTH(rel)) {
830 *(
short *)address +=
datum;
833 *(
long *)address +=
datum;
843 char **libs_to_be_linked = 0;
847 if (load_lib(libc) == -1)
goto err_exit;
855 if (
name[0] ==
'_' &&
sym->n_value >= block) {
856 if (strcmp(
name+1,
"dln_libs_to_be_linked") == 0) {
857 libs_to_be_linked = (
char**)
sym->n_value;
859 else if (strcmp(
name+1,
buf) == 0) {
861 ((int (*)())
sym->n_value)();
865 if (libs_to_be_linked && undef_tbl->
num_entries > 0) {
866 while (*libs_to_be_linked) {
867 load_lib(*libs_to_be_linked);
876 dln_errno = DLN_ENOINIT;
880 if (load_lib(libc) == -1)
goto err_exit;
882 dln_errno = DLN_EUNDEF;
890 if (syms)
free(syms);
891 if (reloc)
free(reloc);
892 if (block)
free((
char*)block);
896 static int target_offset;
898 search_undef(
const char *
key,
int value,
st_table *lib_tbl)
903 target_offset = offset;
912 const char *dln_librrb_ary_path = DLN_DEFAULT_LIB_PATH;
915 load_lib(
const char *lib)
919 char armagic[SARMAG];
927 if (dln_init_p == 0) {
928 dln_errno = DLN_ENOINIT;
933 dln_errno = DLN_EBADLIB;
935 if (lib[0] ==
'-' && lib[1] ==
'l') {
936 long len =
strlen(lib) + 4;
946 path =
getenv(
"DLN_LIBRARY_PATH");
947 if (path ==
NULL) path = dln_librrb_ary_path;
948 else path = envpath =
strdup(path);
951 if (envpath)
free(envpath);
952 fd = open(file, O_RDONLY);
953 if (fd == -1)
goto syserr;
954 size = read(fd, armagic, SARMAG);
955 if (
size == -1)
goto syserr;
957 if (
size != SARMAG) {
958 dln_errno = DLN_ENOTLIB;
961 size = read(fd, &ahdr,
sizeof(ahdr));
962 if (
size == -1)
goto syserr;
963 if (
size !=
sizeof(ahdr) || sscanf(ahdr.ar_size,
"%d", &
size) != 1) {
967 if (strncmp(ahdr.ar_name,
"__.SYMDEF", 9) == 0) {
972 if (data ==
NULL)
goto syserr;
974 nsym = *data /
sizeof(
struct symdef);
975 base = (
struct symdef*)(data + 1);
976 name_base = (
char*)(base + nsym) +
sizeof(int);
978 char *
name = name_base + base->rb_str_index;
987 if (target_offset == -1)
break;
988 if (load_1(fd, target_offset, 0) == -1) {
1002 int offset = SARMAG;
1005 struct nlist *syms, *
sym, *end;
1009 lseek(fd, offset, 0);
1010 size = read(fd, &ahdr,
sizeof(ahdr));
1011 if (
size == -1)
goto syserr;
1012 if (
size == 0)
break;
1013 if (
size !=
sizeof(ahdr)
1014 || sscanf(ahdr.ar_size,
"%d", &
size) != 1) {
1017 offset +=
sizeof(ahdr);
1018 if (load_header(fd, &hdr, offset) == -1)
1020 syms = load_sym(fd, &hdr, offset);
1021 if (syms ==
NULL)
goto badlib;
1023 end = syms + (hdr.a_syms /
sizeof(
struct nlist));
1025 if (
sym->n_type == N_EXT|N_TEXT
1034 if (load_1(fd, offset, 0) == -1) {
1039 if (offset & 1) offset++;
1050 if (fd >= 0) close(fd);
1055 load(
const char *file)
1060 if (dln_init_p == 0) {
1061 if (dln_init(dln_argv0) == -1)
return -1;
1064 if (file[
result-1] ==
'a') {
1065 return load_lib(file);
1068 fd = open(file, O_RDONLY);
1073 result = load_1(fd, 0, file);
1080 dln_sym(
const char *
name)
1085 return (
void*)
sym->n_value;
1091 #ifdef USE_DLN_DLOPEN 1103 #include <sys/ldr.h> 1107 #if NS_TARGET_MAJOR < 4 1108 #include <mach-o/rld.h> 1110 #include <mach-o/dyld.h> 1111 #ifndef NSLINKMODULE_OPTION_BINDNOW 1112 #define NSLINKMODULE_OPTION_BINDNOW 1 1117 #include <mach-o/dyld.h> 1121 #if defined _WIN32 && !defined __CYGWIN__ 1122 #include <windows.h> 1123 #include <imagehlp.h> 1126 #if defined _WIN32 && !defined __CYGWIN__ 1130 int error = GetLastError();
1134 #define format_message(sublang) FormatMessage(\ 1135 FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, \ 1136 NULL, error, MAKELANGID(LANG_NEUTRAL, (sublang)), \ 1137 message + len, size - len, NULL) 1138 if (format_message(SUBLANG_ENGLISH_US) == 0)
1139 format_message(SUBLANG_DEFAULT);
1140 for (p = message + len; *p; p++) {
1141 if (*p ==
'\n' || *p ==
'\r')
1146 #define dln_strerror() dln_strerror(message, sizeof message) 1147 #elif ! defined _AIX 1151 #ifdef USE_DLN_A_OUT 1154 switch (dln_errno) {
1156 return "Symbol name conflict";
1158 return "No initializer given";
1160 return "Unresolved symbols";
1162 return "Not a library file";
1164 return "Malformed library file";
1166 return "Not initialized";
1172 #ifdef USE_DLN_DLOPEN 1173 return (
char*)dlerror();
1178 #if defined(_AIX) && ! defined(_IA64) 1180 aix_loaderror(
const char *pathname)
1182 char *message[1024], errbuf[1024];
1184 #define ERRBUF_APPEND(s) strncat(errbuf, (s), sizeof(errbuf)-strlen(errbuf)-1) 1185 snprintf(errbuf,
sizeof(errbuf),
"load failed - %s. ", pathname);
1187 if (loadquery(L_GETMESSAGES, &message[0],
sizeof(message)) != -1) {
1188 ERRBUF_APPEND(
"Please issue below command for detailed reasons:\n\t");
1189 ERRBUF_APPEND(
"/usr/sbin/execerror ruby ");
1190 for (i=0; message[i]; i++) {
1191 ERRBUF_APPEND(
"\"");
1192 ERRBUF_APPEND(message[i]);
1193 ERRBUF_APPEND(
"\" ");
1195 ERRBUF_APPEND(
"\n");
1198 ERRBUF_APPEND(
"[loadquery failed]");
1204 #if defined _WIN32 && defined RUBY_EXPORT 1205 HANDLE rb_libruby_handle(
void);
1208 rb_w32_check_imported(HMODULE ext, HMODULE mine)
1211 const IMAGE_IMPORT_DESCRIPTOR *desc;
1213 desc = ImageDirectoryEntryToData(ext,
TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &
size);
1214 if (!desc)
return 0;
1215 while (desc->Name) {
1216 PIMAGE_THUNK_DATA pint = (PIMAGE_THUNK_DATA)((
char *)ext + desc->Characteristics);
1217 PIMAGE_THUNK_DATA piat = (PIMAGE_THUNK_DATA)((
char *)ext + desc->FirstThunk);
1218 for (; piat->u1.Function; piat++, pint++) {
1219 static const char prefix[] =
"rb_";
1220 PIMAGE_IMPORT_BY_NAME pii;
1223 if (IMAGE_SNAP_BY_ORDINAL(pint->u1.Ordinal))
continue;
1224 pii = (PIMAGE_IMPORT_BY_NAME)((
char *)ext + (size_t)pint->u1.AddressOfData);
1225 name = (
const char *)pii->Name;
1226 if (strncmp(
name, prefix,
sizeof(prefix) - 1) == 0) {
1227 FARPROC addr = GetProcAddress(mine,
name);
1228 if (addr)
return (FARPROC)piat->u1.Function == addr;
1237 #if defined(DLN_NEEDS_ALT_SEPARATOR) && DLN_NEEDS_ALT_SEPARATOR 1238 #define translit_separator(src) do { \ 1239 char *tmp = ALLOCA_N(char, strlen(src) + 1), *p = tmp, c; \ 1241 *p++ = ((c = *file++) == '/') ? DLN_NEEDS_ALT_SEPARATOR : c; \ 1246 #define translit_separator(str) (void)(str) 1252 #if !defined(_AIX) && !defined(NeXT) 1253 const char *error = 0;
1254 #define DLN_ERROR() (error = dln_strerror(), strcpy(ALLOCA_N(char, strlen(error) + 1), error)) 1257 #if defined _WIN32 && !defined __CYGWIN__ 1274 handle = LoadLibraryW(winfile);
1282 #if defined _WIN32 && defined RUBY_EXPORT 1283 if (!rb_w32_check_imported(handle, rb_libruby_handle())) {
1284 FreeLibrary(handle);
1285 error =
"incompatible library version";
1290 if ((init_fct = (
void(*)())GetProcAddress(handle,
buf)) ==
NULL) {
1298 #ifdef USE_DLN_A_OUT 1299 if (load(file) == -1) {
1311 #ifdef USE_DLN_DLOPEN 1318 # define RTLD_LAZY 1 1324 # define RTLD_GLOBAL 0 1327 #ifdef __native_client__ 1329 if (file[0] ==
'.' && file[1] ==
'/') file+=2;
1331 for (p = file; *p; ++p) {
1332 if (*p ==
'/') *p =
'_';
1336 if ((handle = (
void*)dlopen(file, RTLD_LAZY|RTLD_GLOBAL)) ==
NULL) {
1337 #ifdef __native_client__ 1344 # if defined RUBY_EXPORT 1346 static const char incompatible[] =
"incompatible library version";
1350 # if defined __APPLE__ 1352 rb_fatal(
"%s - %s", incompatible, file);
1355 error = incompatible;
1362 init_fct = (void(*)())(
VALUE)dlsym(handle,
buf);
1363 #ifdef __native_client__ 1367 #if defined __SYMBIAN32__ 1368 if (init_fct ==
NULL) {
1369 init_fct = (void(*)())dlsym(handle,
"1");
1372 if (init_fct ==
NULL) {
1391 flags = BIND_DEFERRED;
1392 lib = shl_load(file, flags, 0);
1397 shl_findsym(&lib,
buf, TYPE_PROCEDURE, (
void*)&init_fct);
1398 if (init_fct ==
NULL) {
1399 shl_findsym(&lib,
buf, TYPE_UNDEFINED, (
void*)&init_fct);
1400 if (init_fct ==
NULL) {
1410 #if defined(_AIX) && ! defined(_IA64) 1415 init_fct = (void(*)())load((
char*)file, 1, 0);
1416 if (init_fct ==
NULL) {
1417 aix_loaderror(file);
1419 if (loadbind(0, (
void*)
dln_load, (
void*)init_fct) == -1) {
1420 aix_loaderror(file);
1423 return (
void*)init_fct;
1427 #if defined(MACOSX_DYLD) 1440 NSObjectFileImage obj_file;
1447 dyld_result = NSCreateObjectFileImageFromFile(file, &obj_file);
1449 if (dyld_result != NSObjectFileImageSuccess) {
1453 NSLinkModule(obj_file, file, NSLINKMODULE_OPTION_BINDNOW);
1456 if (!NSIsSymbolNameDefined(
buf)) {
1457 dln_loaderror(
"Failed to lookup Init function %.200s",file);
1459 init_fct = NSAddressOfSymbol(NSLookupAndBindSymbol(
buf));
1462 return (
void*)init_fct;
1466 #if defined(__BEOS__) || defined(__HAIKU__) 1467 # define DLN_DEFINED 1474 img_id = load_add_on(file);
1486 err_stat = get_image_symbol(img_id,
buf,
1487 B_SYMBOL_TYPE_TEXT, (
void **)&init_fct);
1489 if (err_stat != B_NO_ERROR) {
1494 err_stat = get_image_symbol(img_id, real_name,
1495 B_SYMBOL_TYPE_TEXT, (
void **)&init_fct);
1498 if ((B_BAD_IMAGE_ID == err_stat) || (B_BAD_INDEX == err_stat)) {
1499 unload_add_on(img_id);
1500 dln_loaderror(
"Failed to lookup Init function %.200s", file);
1502 else if (B_NO_ERROR != err_stat) {
1503 char errmsg[] =
"Internal of BeOS version. %.200s (symbol_name = %s)";
1504 unload_add_on(img_id);
1510 return (
void*)img_id;
1520 #if !defined(_AIX) && !defined(NeXT)
static void dln_loaderror(const char *format,...)
size_t strlen(const char *)
int st_insert(st_table *, st_data_t, st_data_t)
void st_free_table(st_table *)
if((ID)(DISPID) nameid !=nameid)
st_table * st_init_strtable(void)
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
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 *)
void rb_fatal(const char *fmt,...)
#define init_funcname(buf, file)
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)
void * ruby_xmalloc(size_t size)
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)
WCHAR * rb_w32_mbstr_to_wstr(UINT, const char *, int, long *)
#define translit_separator(str)
RUBY_EXTERN size_t strlcat(char *, const char *, size_t)
RUBY_SYMBOL_EXPORT_BEGIN void * alloca()
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
static ULONG(STDMETHODCALLTYPE AddRef)(IDispatch __RPC_FAR *This)