mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
46acd0075d
Support loading builtin features written in Ruby, which implement with C builtin functions. [Feature #16254] Several features: (1) Load .rb file at boottime with native binary. Now, prelude.rb is loaded at boottime. However, this file is contained into the interpreter as a text format and we need to compile it. This patch contains a feature to load from binary format. (2) __builtin_func() in Ruby call func() written in C. In Ruby file, we can write `__builtin_func()` like method call. However this is not a method call, but special syntax to call a function `func()` written in C. C functions should be defined in a file (same compile unit) which load this .rb file. Functions (`func` in above example) should be defined with (a) 1st parameter: rb_execution_context_t *ec (b) rest parameters (0 to 15). (c) VALUE return type. This is very similar requirements for functions used by rb_define_method(), however `rb_execution_context_t *ec` is new requirement. (3) automatic C code generation from .rb files. tool/mk_builtin_loader.rb creates a C code to load .rb files needed by miniruby and ruby command. This script is run by BASERUBY, so *.rb should be written in BASERUBY compatbile syntax. This script load a .rb file and find all of __builtin_ prefix method calls, and generate a part of C code to export functions. tool/mk_builtin_binary.rb creates a C code which contains binary compiled Ruby files needed by ruby command.
89 lines
2.3 KiB
C
89 lines
2.3 KiB
C
#include "internal.h"
|
|
#include "vm_core.h"
|
|
#include "iseq.h"
|
|
#include "builtin.h"
|
|
|
|
// include from miniinits.c
|
|
|
|
static const char *
|
|
read_file(const char *fname, size_t *psize)
|
|
{
|
|
struct stat st;
|
|
char *code;
|
|
FILE *fp;
|
|
|
|
if (stat(fname, &st) != 0) {
|
|
rb_bug("stat fails: %s", fname);
|
|
}
|
|
|
|
size_t fsize = st.st_size;
|
|
if ((code = malloc(fsize + 1)) == NULL) {
|
|
rb_bug("can't allocate memory: %s (%d)", fname, (int)fsize);
|
|
}
|
|
|
|
if ((fp = fopen(fname, "rb")) == NULL) {
|
|
rb_bug("can't open file: %s", fname);
|
|
}
|
|
|
|
size_t read_size = fread(code, 1, fsize, fp);
|
|
if (read_size != fsize) {
|
|
rb_bug("can't read file enough: %s (expect %d but was %d)", fname, (int)fsize, (int)read_size);
|
|
}
|
|
|
|
code[fsize] = 0;
|
|
*psize = fsize;
|
|
return code;
|
|
}
|
|
|
|
static struct st_table *loaded_builtin_table;
|
|
|
|
void
|
|
rb_load_with_builtin_functions(const char *feature_name, const char *fname, const struct rb_builtin_function *table)
|
|
{
|
|
size_t fsize;
|
|
const char *code = read_file(fname, &fsize);
|
|
VALUE code_str = rb_utf8_str_new_static(code, fsize);
|
|
VALUE name_str = rb_sprintf("<internal:%s>", feature_name);
|
|
rb_obj_hide(code_str);
|
|
|
|
rb_ast_t *ast = rb_parser_compile_string_path(rb_parser_new(), name_str, code_str, 1);
|
|
|
|
GET_VM()->builtin_function_table = table;
|
|
const rb_iseq_t *iseq = rb_iseq_new(&ast->body, name_str, name_str, Qnil, NULL, ISEQ_TYPE_TOP);
|
|
GET_VM()->builtin_function_table = NULL;
|
|
|
|
rb_ast_dispose(ast);
|
|
free((void *)code); // code_str becomes broken.
|
|
|
|
// register (loaded iseq will not be freed)
|
|
st_insert(loaded_builtin_table, (st_data_t)feature_name, (st_data_t)iseq);
|
|
rb_gc_register_mark_object((VALUE)iseq);
|
|
|
|
// eval
|
|
rb_iseq_eval(iseq);
|
|
}
|
|
|
|
static int
|
|
each_builtin_i(st_data_t key, st_data_t val, st_data_t dmy)
|
|
{
|
|
const char *feature = (const char *)key;
|
|
const rb_iseq_t *iseq = (const rb_iseq_t *)val;
|
|
|
|
rb_yield_values(2, rb_str_new2(feature), rb_iseqw_new(iseq));
|
|
|
|
return ST_CONTINUE;
|
|
}
|
|
|
|
static VALUE
|
|
each_builtin(VALUE self)
|
|
{
|
|
st_foreach(loaded_builtin_table, each_builtin_i, 0);
|
|
return Qnil;
|
|
}
|
|
|
|
void
|
|
Init_builtin(void)
|
|
{
|
|
rb_define_singleton_method(rb_cRubyVM, "each_builtin", each_builtin, 0);
|
|
loaded_builtin_table = st_init_strtable();
|
|
}
|