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
22static void dln_loaderror(
const char *format, ...);
35#if defined(HAVE_ALLOCA_H)
52#define free(x) xfree(x)
62# define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
65#ifdef HAVE_SYS_PARAM_H
66# include <sys/param.h>
69# define MAXPATHLEN 1024
81# if defined(HAVE_DLOPEN)
91dln_loaderror(
const char *format, ...)
101#if defined(HAVE_DLOPEN) && !defined(USE_DLN_A_OUT) && !defined(_AIX) && !defined(MACOSX_DYLD) && !defined(_UNICOSMP)
103# define USE_DLN_DLOPEN
106#if defined(__hp9000s300) || ((defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)) && !defined(__ELF__)) || defined(NeXT) || defined(MACOSX_DYLD)
107# define EXTERNAL_PREFIX "_"
109# define EXTERNAL_PREFIX ""
111#define FUNCNAME_PREFIX EXTERNAL_PREFIX"Init_"
113#if defined __CYGWIN__ || defined DOSISH
114#define isdirsep(x) ((x) == '/' || (x) == '\\')
116#define isdirsep(x) ((x) == '/')
120init_funcname_len(
const char **file)
122 const char *p = *file, *base, *dot =
NULL;
125 for (base = p; *p; p++) {
126 if (*p ==
'.' && !dot) dot = p;
131 return (dot ? dot : p) - base;
136#define init_funcname(buf, file) do {\
137 const char *base = (file);\
138 const size_t flen = init_funcname_len(&base);\
139 const size_t plen = sizeof(funcname_prefix);\
140 char *const tmp = ALLOCA_N(char, plen+flen+1);\
144 memcpy(tmp, funcname_prefix, plen);\
145 memcpy(tmp+plen, base, flen);\
146 tmp[plen+flen] = '\0';\
153# define LIBC_NAME "libc.a"
156#ifndef DLN_DEFAULT_LIB_PATH
157# define DLN_DEFAULT_LIB_PATH "/lib:/usr/lib:/usr/local/lib:."
164#define DLN_ENOEXEC ENOEXEC
165#define DLN_ECONFL 1201
166#define DLN_ENOINIT 1202
167#define DLN_EUNDEF 1203
168#define DLN_ENOTLIB 1204
169#define DLN_EBADLIB 1205
170#define DLN_EINIT 1206
172static int dln_init_p = 0;
180# define N_MAGIC(x) (x).a_magic
183#define INVALID_OBJECT(h) (N_MAGIC(h) != OMAGIC)
191static int load_lib();
194load_header(
int fd,
struct exec *hdrp,
long disp)
199 size =
read(fd, hdrp,
sizeof(
struct exec));
204 if (
size !=
sizeof(
struct exec) || N_BADMAG(*hdrp)) {
205 dln_errno = DLN_ENOEXEC;
212#define RELOC_SYMBOL(r) ((r)->r_symbolnum)
213#define RELOC_MEMORY_SUB_P(r) ((r)->r_bsr)
214#define RELOC_PCREL_P(r) ((r)->r_pcrel || (r)->r_bsr)
215#define RELOC_TARGET_SIZE(r) ((r)->r_length)
220#define RELOC_ADDRESS(r) ((r)->r_address)
221#define RELOC_EXTERN_P(r) ((r)->r_extern)
222#define RELOC_SYMBOL(r) ((r)->r_symbolnum)
223#define RELOC_MEMORY_SUB_P(r) 0
224#define RELOC_PCREL_P(r) ((r)->r_pcrel)
225#define RELOC_TARGET_SIZE(r) ((r)->r_length)
228#if defined(__sun) && defined(__sparc)
230# undef relocation_info
231# define relocation_info reloc_info_sparc
232# define R_RIGHTSHIFT(r) (reloc_r_rightshift[(r)->r_type])
233# define R_BITSIZE(r) (reloc_r_bitsize[(r)->r_type])
234# define R_LENGTH(r) (reloc_r_length[(r)->r_type])
235static const int reloc_r_rightshift[] = {
236 0, 0, 0, 0, 0, 0, 2, 2, 10, 0, 0, 0, 0, 0, 0,
238static const int reloc_r_bitsize[] = {
239 8, 16, 32, 8, 16, 32, 30, 22, 22, 22, 13, 10, 32, 32, 16,
241static const int reloc_r_length[] = {
242 0, 1, 2, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
245 ((r)->r_type >= RELOC_DISP8 && (r)->r_type <= RELOC_WDISP22)
246# define R_SYMBOL(r) ((r)->r_index)
250#define R_SYMBOL(r) ((r)->r_symbolnum)
251#define R_MEMORY_SUB(r) ((r)->r_bsr)
252#define R_PCREL(r) ((r)->r_pcrel || (r)->r_bsr)
253#define R_LENGTH(r) ((r)->r_length)
257# define R_SYMBOL(r) ((r)->r_symbolnum)
258# define R_MEMORY_SUB(r) 0
259# define R_PCREL(r) ((r)->r_pcrel)
260# define R_LENGTH(r) ((r)->r_length)
263static struct relocation_info *
264load_reloc(
int fd,
struct exec *hdrp,
long disp)
266 struct relocation_info *reloc;
269 lseek(fd, disp + N_TXTOFF(*hdrp) + hdrp->a_text + hdrp->a_data, 0);
270 size = hdrp->a_trsize + hdrp->a_drsize;
287load_sym(
int fd,
struct exec *hdrp,
long disp)
289 struct nlist * buffer;
295 lseek(fd, N_SYMOFF(*hdrp) + hdrp->a_syms + disp, 0);
296 if (
read(fd, &
size,
sizeof(
int)) !=
sizeof(
int)) {
300 buffer = (
struct nlist*)
xmalloc(hdrp->a_syms +
size);
301 if (buffer ==
NULL) {
306 lseek(fd, disp + N_SYMOFF(*hdrp), 0);
307 if (
read(fd, buffer, hdrp->a_syms +
size) != hdrp->a_syms +
size) {
313 end =
sym + hdrp->a_syms /
sizeof(
struct nlist);
314 displ = (
long)buffer + (
long)(hdrp->a_syms);
317 sym->n_un.n_name = (
char*)
sym->n_un.n_strx + displ;
323 dln_errno = DLN_ENOEXEC;
328sym_hash(
struct exec *hdrp,
struct nlist *syms)
331 struct nlist *
sym = syms;
332 struct nlist *end = syms + (hdrp->a_syms /
sizeof(
struct nlist));
348dln_init(
const char *prog)
355 if (dln_init_p == 1)
return 0;
358 if (file ==
NULL || (fd = open(file, O_RDONLY)) < 0) {
363 if (load_header(fd, &hdr, 0) == -1)
return -1;
364 syms = load_sym(fd, &hdr, 0);
369 sym_tbl = sym_hash(&hdr, syms);
370 if (sym_tbl ==
NULL) {
377 if (
read(fd, &c, 1) == -1) {
381 if (c !=
'#')
goto err_noexec;
382 if (
read(fd, &c, 1) == -1) {
386 if (c !=
'!')
goto err_noexec;
390 while (
read(fd, &c, 1) == 1) {
391 if (c ==
'\n')
goto err_noexec;
392 if (c !=
'\t' && c !=
' ') {
398 while (
read(fd, p, 1) == 1) {
399 if (*p ==
'\n' || *p ==
'\t' || *p ==
' ')
break;
408 return dln_init(
buf);
417 dln_errno = DLN_ENOEXEC;
422load_text_data(
int fd,
struct exec *hdrp,
int bss,
long disp)
427 lseek(fd, disp + N_TXTOFF(*hdrp), 0);
428 size = hdrp->a_text + hdrp->a_data;
430 if (bss == -1)
size += hdrp->a_bss;
431 else if (bss > 1)
size += bss;
446 memset(addr + hdrp->a_text + hdrp->a_data, 0, hdrp->a_bss);
449 memset(addr + hdrp->a_text + hdrp->a_data, 0, bss);
456undef_print(
char *
key,
char *value)
481 struct relocation_info reloc;
493link_undef(
const char *
name,
long base,
struct relocation_info *reloc)
497 char *addr = (
char*)(reloc->r_address + base);
499 obj = (
struct undef*)
xmalloc(
sizeof(
struct undef));
503 switch (R_LENGTH(reloc)) {
508 obj->u.s = *(
short*)addr;
511 obj->u.l = *(
long*)addr;
514 if (reloc_tbl ==
NULL) {
526reloc_undef(
int no,
struct undef *undef,
struct reloc_arg *
arg)
530#if defined(__sun) && defined(__sparc)
531 unsigned int mask = 0;
535 address = (
char*)(undef->base + undef->reloc.r_address);
538 if (R_PCREL(&(undef->reloc)))
datum -= undef->base;
539#
if defined(__sun) && defined(__sparc)
540 datum += undef->reloc.r_addend;
541 datum >>= R_RIGHTSHIFT(&(undef->reloc));
542 mask = (1 << R_BITSIZE(&(undef->reloc))) - 1;
545 switch (R_LENGTH(&(undef->reloc))) {
547 *address = undef->u.c;
552 *(
short *)address = undef->u.s;
553 *(
short *)address &= ~mask;
554 *(
short *)address |=
datum;
557 *(
long *)address = undef->u.l;
558 *(
long *)address &= ~mask;
559 *(
long *)address |=
datum;
563 switch (R_LENGTH(&(undef->reloc))) {
565 if (R_MEMORY_SUB(&(undef->reloc)))
566 *address =
datum - *address;
567 else *address = undef->u.c +
datum;
570 if (R_MEMORY_SUB(&(undef->reloc)))
571 *(
short*)address =
datum - *(
short*)address;
572 else *(
short*)address = undef->u.s +
datum;
575 if (R_MEMORY_SUB(&(undef->reloc)))
576 *(
long*)address =
datum - *(
long*)address;
577 else *(
long*)address = undef->u.l +
datum;
587unlink_undef(
const char *
name,
long value)
589 struct reloc_arg
arg;
602reloc_repl(
int no,
struct undef *undef,
struct indr_data *data)
604 if (
strcmp(data->name0, undef->name) == 0) {
606 undef->name =
strdup(data->name1);
613load_1(
int fd,
long disp,
const char *need_init)
615 static const char *libc = LIBC_NAME;
617 struct relocation_info *reloc =
NULL;
620 struct nlist *syms =
NULL;
625 if (load_header(fd, &hdr, disp) == -1)
return -1;
626 if (INVALID_OBJECT(hdr)) {
627 dln_errno = DLN_ENOEXEC;
630 reloc = load_reloc(fd, &hdr, disp);
631 if (reloc ==
NULL)
return -1;
633 syms = load_sym(fd, &hdr, disp);
640 end = syms + (hdr.a_syms /
sizeof(
struct nlist));
642 struct nlist *old_sym;
643 int value =
sym->n_value;
646 if (
sym->n_type == (N_INDR | N_EXT)) {
647 char *
key =
sym->n_un.n_name;
651 unlink_undef(
key, old_sym->n_value);
656 struct indr_data data;
658 data.name0 =
sym->n_un.n_name;
659 data.name1 =
sym[1].n_un.n_name;
671 if (
sym->n_type == (N_UNDF | N_EXT)) {
672 if (
st_lookup(sym_tbl,
sym->n_un.n_name, &old_sym) == 0) {
678 sym->n_type = N_EXT | N_COMM;
679 sym->n_value = old_sym->n_value;
683 value >=
sizeof(
double) ?
sizeof(
double) - 1
684 : value >=
sizeof(
long) ?
sizeof(
long) - 1
687 sym->n_type = N_COMM;
689 new_common &= ~(
long)rnd;
690 sym->n_value = new_common;
696 sym->n_type = N_EXT | N_COMM;
697 sym->n_value = old_sym->n_value;
700 sym->n_value = (
long)dln_undefined;
708 block = load_text_data(fd, &hdr, hdr.a_bss + new_common, disp);
709 if (block == 0)
goto err_exit;
713 struct nlist *new_sym;
716 switch (
sym->n_type) {
718 sym->n_value += hdr.a_text + hdr.a_data;
722 sym->n_value += block;
725 && new_sym->n_value != (
long)dln_undefined) {
726 dln_errno = DLN_ECONFL;
732 unlink_undef(
key,
sym->n_value);
736 new_sym = (
struct nlist*)
xmalloc(
sizeof(
struct nlist));
738 new_sym->n_un.n_name =
strdup(
sym->n_un.n_name);
739 st_insert(sym_tbl, new_sym->n_un.n_name, new_sym);
744 sym->n_value += block;
754 struct relocation_info * rel = reloc;
755 struct relocation_info * rel_beg = reloc +
756 (hdr.a_trsize/
sizeof(
struct relocation_info));
757 struct relocation_info * rel_end = reloc +
758 (hdr.a_trsize+hdr.a_drsize)/
sizeof(
struct relocation_info);
760 while (rel < rel_end) {
761 char *address = (
char*)(rel->r_address + block);
763#if defined(__sun) && defined(__sparc)
764 unsigned int mask = 0;
768 address += hdr.a_text;
771 sym = &(syms[R_SYMBOL(rel)]);
772 switch (
sym->n_type) {
774 link_undef(
sym->n_un.n_name, block, rel);
784 switch (R_SYMBOL(rel)) {
790 datum = block + new_common;
796 if (R_PCREL(rel))
datum -= block;
798#if defined(__sun) && defined(__sparc)
799 datum += rel->r_addend;
800 datum >>= R_RIGHTSHIFT(rel);
801 mask = (1 << R_BITSIZE(rel)) - 1;
805 switch (R_LENGTH(rel)) {
811 *(
short *)address &= ~
mask;
812 *(
short *)address |=
datum;
815 *(
long *)address &= ~
mask;
816 *(
long *)address |=
datum;
820 switch (R_LENGTH(rel)) {
826 *(
short *)address +=
datum;
829 *(
long *)address +=
datum;
839 char **libs_to_be_linked = 0;
843 if (load_lib(libc) == -1)
goto err_exit;
851 if (
name[0] ==
'_' &&
sym->n_value >= block) {
852 if (
strcmp(
name+1,
"dln_libs_to_be_linked") == 0) {
853 libs_to_be_linked = (
char**)
sym->n_value;
857 ((
int (*)())
sym->n_value)();
861 if (libs_to_be_linked && undef_tbl->
num_entries > 0) {
862 while (*libs_to_be_linked) {
863 load_lib(*libs_to_be_linked);
872 dln_errno = DLN_ENOINIT;
876 if (load_lib(libc) == -1)
goto err_exit;
878 dln_errno = DLN_EUNDEF;
886 if (syms)
free(syms);
887 if (reloc)
free(reloc);
888 if (block)
free((
char*)block);
892static int target_offset;
894search_undef(
const char *
key,
int value,
st_table *lib_tbl)
899 target_offset = offset;
908const char *dln_librrb_ary_path = DLN_DEFAULT_LIB_PATH;
911load_lib(
const char *lib)
915 char armagic[SARMAG];
923 if (dln_init_p == 0) {
924 dln_errno = DLN_ENOINIT;
929 dln_errno = DLN_EBADLIB;
931 if (lib[0] ==
'-' && lib[1] ==
'l') {
947 if (envpath)
free(envpath);
948 fd = open(file, O_RDONLY);
949 if (fd == -1)
goto syserr;
951 if (
size == -1)
goto syserr;
953 if (
size != SARMAG) {
954 dln_errno = DLN_ENOTLIB;
957 size =
read(fd, &ahdr,
sizeof(ahdr));
958 if (
size == -1)
goto syserr;
959 if (
size !=
sizeof(ahdr) ||
sscanf(ahdr.ar_size,
"%d", &
size) != 1) {
963 if (
strncmp(ahdr.ar_name,
"__.SYMDEF", 9) == 0) {
968 if (data ==
NULL)
goto syserr;
970 nsym = *data /
sizeof(
struct symdef);
971 base = (
struct symdef*)(data + 1);
972 name_base = (
char*)(base + nsym) +
sizeof(
int);
974 char *
name = name_base + base->rb_str_index;
983 if (target_offset == -1)
break;
984 if (load_1(fd, target_offset, 0) == -1) {
1001 struct nlist *syms, *
sym, *end;
1005 lseek(fd, offset, 0);
1006 size =
read(fd, &ahdr,
sizeof(ahdr));
1007 if (
size == -1)
goto syserr;
1008 if (
size == 0)
break;
1009 if (
size !=
sizeof(ahdr)
1013 offset +=
sizeof(ahdr);
1014 if (load_header(fd, &hdr, offset) == -1)
1016 syms = load_sym(fd, &hdr, offset);
1017 if (syms ==
NULL)
goto badlib;
1019 end = syms + (hdr.a_syms /
sizeof(
struct nlist));
1021 if (
sym->n_type == N_EXT|N_TEXT
1030 if (load_1(fd, offset, 0) == -1) {
1035 if (offset & 1) offset++;
1046 if (fd >= 0)
close(fd);
1051load(
const char *file)
1056 if (dln_init_p == 0) {
1057 if (dln_init(dln_argv0) == -1)
return -1;
1060 if (file[result-1] ==
'a') {
1061 return load_lib(file);
1064 fd = open(file, O_RDONLY);
1069 result = load_1(fd, 0, file);
1076dln_sym(
const char *
name)
1081 return (
void*)
sym->n_value;
1087#ifdef USE_DLN_DLOPEN
1103#if NS_TARGET_MAJOR < 4
1104#include <mach-o/rld.h>
1106#include <mach-o/dyld.h>
1107#ifndef NSLINKMODULE_OPTION_BINDNOW
1108#define NSLINKMODULE_OPTION_BINDNOW 1
1113#include <mach-o/dyld.h>
1119#include <imagehlp.h>
1124dln_strerror(
char *message,
size_t size)
1126 int error = GetLastError();
1130#define format_message(sublang) FormatMessage(\
1131 FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, \
1132 NULL, error, MAKELANGID(LANG_NEUTRAL, (sublang)), \
1133 message + len, size - len, NULL)
1134 if (format_message(SUBLANG_ENGLISH_US) == 0)
1135 format_message(SUBLANG_DEFAULT);
1136 for (p = message +
len; *p; p++) {
1137 if (*p ==
'\n' || *p ==
'\r')
1142#define dln_strerror() dln_strerror(message, sizeof message)
1150 switch (dln_errno) {
1152 return "Symbol name conflict";
1154 return "No initializer given";
1156 return "Unresolved symbols";
1158 return "Not a library file";
1160 return "Malformed library file";
1162 return "Not initialized";
1168#ifdef USE_DLN_DLOPEN
1169 return (
char*)dlerror();
1176aix_loaderror(
const char *pathname)
1178 char *message[1024], errbuf[1024];
1180#define ERRBUF_APPEND(s) strlcat(errbuf, (s), sizeof(errbuf))
1181 snprintf(errbuf,
sizeof(errbuf),
"load failed - %s. ", pathname);
1183 if (loadquery(L_GETMESSAGES, &message[0],
sizeof(message)) != -1) {
1184 ERRBUF_APPEND(
"Please issue below command for detailed reasons:\n\t");
1185 ERRBUF_APPEND(
"/usr/sbin/execerror ruby ");
1186 for (
i=0; message[
i];
i++) {
1187 ERRBUF_APPEND(
"\"");
1188 ERRBUF_APPEND(message[
i]);
1189 ERRBUF_APPEND(
"\" ");
1191 ERRBUF_APPEND(
"\n");
1195 ERRBUF_APPEND(
"[loadquery failed]");
1197 dln_loaderror(
"%s", errbuf);
1201#if defined _WIN32 && defined RUBY_EXPORT
1202HANDLE rb_libruby_handle(
void);
1205rb_w32_check_imported(HMODULE ext, HMODULE mine)
1208 const IMAGE_IMPORT_DESCRIPTOR *desc;
1210 desc = ImageDirectoryEntryToData(ext,
TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &
size);
1211 if (!desc)
return 0;
1212 while (desc->Name) {
1213 PIMAGE_THUNK_DATA pint = (PIMAGE_THUNK_DATA)((
char *)ext + desc->Characteristics);
1214 PIMAGE_THUNK_DATA piat = (PIMAGE_THUNK_DATA)((
char *)ext + desc->FirstThunk);
1215 for (; piat->u1.Function; piat++, pint++) {
1216 static const char prefix[] =
"rb_";
1217 PIMAGE_IMPORT_BY_NAME pii;
1220 if (IMAGE_SNAP_BY_ORDINAL(pint->u1.Ordinal))
continue;
1221 pii = (PIMAGE_IMPORT_BY_NAME)((
char *)ext + (
size_t)pint->u1.AddressOfData);
1222 name = (
const char *)pii->Name;
1224 FARPROC addr = GetProcAddress(mine,
name);
1225 if (addr)
return (FARPROC)piat->u1.Function == addr;
1234#if defined(DLN_NEEDS_ALT_SEPARATOR) && DLN_NEEDS_ALT_SEPARATOR
1235#define translit_separator(src) do { \
1236 char *tmp = ALLOCA_N(char, strlen(src) + 1), *p = tmp, c; \
1238 *p++ = ((c = *file++) == '/') ? DLN_NEEDS_ALT_SEPARATOR : c; \
1243#define translit_separator(str) (void)(str)
1246#ifdef USE_DLN_DLOPEN
1248#if defined(__clang__) || GCC_VERSION_SINCE(4, 2, 0)
1252dln_incompatible_library_p(
void *handle)
1263#if (defined _WIN32 || defined USE_DLN_DLOPEN) && defined RUBY_EXPORT
1264 static const char incompatible[] =
"incompatible library version";
1266#if !defined(_AIX) && !defined(NeXT)
1267 const char *
error = 0;
1287 handle = LoadLibraryW(winfile);
1291 error = dln_strerror();
1295#if defined _WIN32 && defined RUBY_EXPORT
1296 if (!rb_w32_check_imported(handle, rb_libruby_handle())) {
1297 FreeLibrary(handle);
1298 error = incompatible;
1303 if ((init_fct = (
void(*)())GetProcAddress(handle,
buf)) ==
NULL) {
1304 dln_loaderror(
"%s - %s\n%s", dln_strerror(),
buf, file);
1312 if (load(file) == -1) {
1313 error = dln_strerror();
1324#ifdef USE_DLN_DLOPEN
1337# define RTLD_GLOBAL 0
1341 if ((handle = (
void*)dlopen(file, RTLD_LAZY|RTLD_GLOBAL)) ==
NULL) {
1342 error = dln_strerror();
1345# if defined RUBY_EXPORT
1347 if (dln_incompatible_library_p(handle)) {
1349# if defined __APPLE__ && \
1350 defined(MAC_OS_X_VERSION_MIN_REQUIRED) && \
1351 (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_11)
1353 rb_fatal(
"%s - %s", incompatible, file);
1356 error = incompatible;
1364 if (init_fct ==
NULL) {
1365 const size_t errlen =
strlen(
error = dln_strerror()) + 1;
1384 flags = BIND_DEFERRED;
1385 lib = shl_load(file, flags, 0);
1390 shl_findsym(&lib,
buf, TYPE_PROCEDURE, (
void*)&init_fct);
1391 if (init_fct ==
NULL) {
1392 shl_findsym(&lib,
buf, TYPE_UNDEFINED, (
void*)&init_fct);
1393 if (init_fct ==
NULL) {
1395 dln_loaderror(
"%s - %s",
strerror(ENOSYM), file);
1408 init_fct = (
void(*)())load((
char*)file, 1, 0);
1409 if (init_fct ==
NULL) {
1410 aix_loaderror(file);
1412 if (loadbind(0, (
void*)
dln_load, (
void*)init_fct) == -1) {
1413 aix_loaderror(file);
1416 return (
void*)init_fct;
1420#if defined(MACOSX_DYLD)
1433 NSObjectFileImage obj_file;
1440 dyld_result = NSCreateObjectFileImageFromFile(file, &obj_file);
1442 if (dyld_result != NSObjectFileImageSuccess) {
1443 dln_loaderror(
"Failed to load %.200s", file);
1446 NSLinkModule(obj_file, file, NSLINKMODULE_OPTION_BINDNOW);
1449 if (!NSIsSymbolNameDefined(
buf)) {
1450 dln_loaderror(
"Failed to lookup Init function %.200s",file);
1452 init_fct = NSAddressOfSymbol(NSLookupAndBindSymbol(
buf));
1455 return (
void*)init_fct;
1465#if !defined(_AIX) && !defined(NeXT)
1467 dln_loaderror(
"%s - %s",
error, file);
void * dln_load(const char *file)
#define translit_separator(str)
#define init_funcname(buf, file)
void rb_fatal(const char *fmt,...)
void st_free_table(st_table *tab)
int st_delete(st_table *tab, st_data_t *key, st_data_t *value)
st_table * st_init_numtable(void)
st_table * st_init_strtable(void)
int st_insert(st_table *tab, st_data_t key, st_data_t value)
int st_lookup(st_table *tab, st_data_t key, st_data_t *value)
int st_foreach(st_table *tab, st_foreach_callback_func *func, st_data_t arg)
#define rb_str_index(str, sub, offset)
WCHAR * rb_w32_mbstr_to_wstr(UINT, const char *, int, long *)