Ruby » Ruby master

/exts.mk

/goruby

/id.h

/largefile.h

/lex.c

/libruby*.*

OBJCOPY = @OBJCOPY@

VCS = @VCS@

VCSUP = @VCSUP@

OBJEXT = @OBJEXT@

ASMEXT = S

$(srcdir)/configure: $(srcdir)/configure.in

$(CHDIR) $(srcdir) && exec $(AUTOCONF)

# Things which should be considered:

# * with gperf v.s. without gperf

@$(ECHO) preprocessing $<

$(Q) $(CPP) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -E $< > $@

clean-local::

$(Q)$(RM) ext/extinit.c ext/extinit.$(OBJEXT) ext/ripper/y.output

-$(Q)$(RM) $(pkgconfig_DATA)

lib: $(LIBRUBY)

dll: $(LIBRUBY_SO)

# V=0 quiet, V=1 verbose. other values don't work.

V = 0

{$(VPATH)}subst.h

ENCODING_H_INCLUDES= {$(VPATH)}encoding.h {$(VPATH)}oniguruma.h

ID_H_INCLUDES = {$(VPATH)}id.h {$(VPATH)}vm_opts.h

VM_CORE_H_INCLUDES = {$(VPATH)}vm_core.h {$(VPATH)}thread_$(THREAD_MODEL).h \

{$(VPATH)}node.h {$(VPATH)}method.h {$(VPATH)}atomic.h \

$(ID_H_INCLUDES)

eval.$(OBJEXT): {$(VPATH)}eval.c {$(VPATH)}eval_intern.h {$(VPATH)}vm.h \

$(RUBY_H_INCLUDES) $(VM_CORE_H_INCLUDES) {$(VPATH)}eval_error.c \

{$(VPATH)}eval_jump.c {$(VPATH)}debug.h {$(VPATH)}gc.h {$(VPATH)}iseq.h \

load.$(OBJEXT): {$(VPATH)}load.c {$(VPATH)}eval_intern.h \

{$(VPATH)}util.h $(RUBY_H_INCLUDES) $(VM_CORE_H_INCLUDES) \

{$(VPATH)}dln.h {$(VPATH)}debug.h \

file.$(OBJEXT): {$(VPATH)}file.c $(RUBY_H_INCLUDES) {$(VPATH)}io.h \

$(ENCODING_H_INCLUDES) {$(VPATH)}util.h {$(VPATH)}dln.h \

{$(VPATH)}internal.h

gc.$(OBJEXT): {$(VPATH)}gc.c $(RUBY_H_INCLUDES) {$(VPATH)}re.h \

{$(VPATH)}regex.h $(ENCODING_H_INCLUDES) $(VM_CORE_H_INCLUDES) \

{$(VPATH)}gc.h {$(VPATH)}io.h {$(VPATH)}eval_intern.h {$(VPATH)}util.h \

hash.$(OBJEXT): {$(VPATH)}hash.c $(RUBY_H_INCLUDES) {$(VPATH)}util.h \

$(ENCODING_H_INCLUDES)

inits.$(OBJEXT): {$(VPATH)}inits.c $(RUBY_H_INCLUDES) \

numeric.$(OBJEXT): {$(VPATH)}numeric.c $(RUBY_H_INCLUDES) \

{$(VPATH)}util.h $(ENCODING_H_INCLUDES) {$(VPATH)}internal.h

object.$(OBJEXT): {$(VPATH)}object.c $(RUBY_H_INCLUDES) {$(VPATH)}util.h \

pack.$(OBJEXT): {$(VPATH)}pack.c $(RUBY_H_INCLUDES) {$(VPATH)}encoding.h \

{$(VPATH)}oniguruma.h

parse.$(OBJEXT): {$(VPATH)}parse.c $(RUBY_H_INCLUDES) {$(VPATH)}node.h \

iseq.$(OBJEXT): {$(VPATH)}iseq.c {$(VPATH)}gc.h {$(VPATH)}iseq.h \

$(RUBY_H_INCLUDES) $(VM_CORE_H_INCLUDES) {$(VPATH)}insns.inc \

{$(VPATH)}insns_info.inc {$(VPATH)}node_name.inc {$(VPATH)}debug.h {$(VPATH)}internal.h

vm.$(OBJEXT): {$(VPATH)}vm.c {$(VPATH)}gc.h {$(VPATH)}iseq.h \

{$(VPATH)}eval_intern.h $(RUBY_H_INCLUDES) $(ENCODING_H_INCLUDES) \

$(VM_CORE_H_INCLUDES) {$(VPATH)}vm_method.c {$(VPATH)}vm_eval.c \

if test x"${build}" != x"${host}"; then

AC_CHECK_TOOL(CC, gcc)

fi

RUBY_MINGW32

AC_PROG_CC

AC_PROG_CXX

#include "ruby/encoding.h"

#include "internal.h"

#include "vm_core.h"

#define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))

}

if (tag != TAG_FATAL) {

EXEC_EVENT_HOOK(th, RUBY_EVENT_RAISE, th->cfp->self, 0, 0);

}

}

#include "internal.h"

#include "gc.h"

#include "constant.h"

#include <stdio.h>

#include <setjmp.h>

#include <sys/types.h>

}

#define GC_PROF_TIMER_START do {\

if (objspace->profile.run) {\

if (!objspace->profile.record) {\

objspace->profile.size = 1000;\

} while(0)

#define GC_PROF_TIMER_STOP(marked) do {\

if (objspace->profile.run) {\

gc_time = getrusage_time() - gc_time;\

if (gc_time < 0) gc_time = 0;\

during_gc++;

GC_PROF_TIMER_START;

GC_PROF_SWEEP_TIMER_START;

if (objspace->heap.sweep_slots) {

res = lazy_sweep(objspace);

if (res) {

GC_PROF_SWEEP_TIMER_STOP;

GC_PROF_SET_MALLOC_INFO;

GC_PROF_TIMER_STOP(Qfalse);

set_heaps_increment(objspace);

}

GC_PROF_SWEEP_TIMER_START;

if (!(res = lazy_sweep(objspace))) {

after_gc_sweep(objspace);

during_gc = 0;

}

}

GC_PROF_SWEEP_TIMER_STOP;

GC_PROF_TIMER_STOP(Qtrue);

{

struct gc_list *list;

rb_thread_t *th = GET_THREAD();

GC_PROF_MARK_TIMER_START;

objspace->heap.live_num = 0;

gc_mark_rest(objspace);

}

}

GC_PROF_MARK_TIMER_STOP;

}

during_gc++;

gc_marks(objspace);

GC_PROF_SWEEP_TIMER_START;

gc_sweep(objspace);

GC_PROF_SWEEP_TIMER_STOP;

GC_PROF_TIMER_STOP(Qtrue);

()

(VALUE val)

{

val = rb_str_resurrect(str);

}

/**

(...)

(VALUE val) // inc += 1 - num;

{

val = rb_ary_new4((long)num, STACK_ADDR_FROM_TOP(num));

POPN(num);

}

(VALUE val) // inc += 1 - num;

{

rb_num_t i;

val = rb_hash_new();

for (i = num; i > 0; i -= 2) {

const VALUE v = TOPN(i - 2);

const VALUE k = TOPN(i - 1);

{

rb_event_flag_t flag = (rb_event_flag_t)nf;

EXEC_EVENT_HOOK(th, flag, GET_SELF(), 0, 0 /* TODO: id, klass */);

}

#include "internal.h"

#include "dln.h"

#include "eval_intern.h"

VALUE ruby_dln_librefs;

VALUE fname, wrap, path;

rb_scan_args(argc, argv, "11", &fname, &wrap);

path = rb_find_file(FilePathValue(fname));

if (!path) {

if (!rb_file_load_ok(RSTRING_PTR(fname)))

path = fname;

}

rb_load_internal(path, RTEST(wrap));

return Qtrue;

}

} volatile saved;

char *volatile ftptr = 0;

PUSH_TAG();

saved.safe = rb_safe_level();

if ((state = EXEC_TAG()) == 0) {

th->errinfo = errinfo;

return result;

}

#include <float.h>

#include "constant.h"

#include "internal.h"

VALUE rb_cBasicObject;

VALUE rb_mKernel;

if (FL_TEST(klass, FL_SINGLETON)) {

rb_raise(rb_eTypeError, "can't create instance of singleton class");

}

obj = rb_funcall(klass, ID_ALLOCATOR, 0, 0);

if (rb_obj_class(obj) != rb_class_real(klass)) {

rb_raise(rb_eTypeError, "wrong instance allocation");

}

}

case VM_METHOD_TYPE_NOTIMPLEMENTED:

case VM_METHOD_TYPE_CFUNC: {

EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, recv, id, klass);

{

rb_control_frame_t *reg_cfp = th->cfp;

}

vm_pop_frame(th);

}

EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, id, klass);

break;

}

rb_bug("vm_call0: unsupported method type (%d)", def->type);

val = Qundef;

}

RUBY_VM_CHECK_INTS();

return val;

}

#include <math.h>

#include "constant.h"

#include "internal.h"

/* control stack frame */

const rb_method_definition_t *def = me->def;

rb_control_frame_t *cfp;

EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, recv, me->called_id, me->klass);

cfp = vm_push_frame(th, 0, VM_FRAME_MAGIC_CFUNC,

vm_pop_frame(th);

EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, me->called_id, me->klass);

return val;

rb_proc_t *proc;

VALUE val;

EXEC_EVENT_HOOK(th, RUBY_EVENT_CALL, recv, me->called_id, me->klass);

/* control block frame */

GetProcPtr(me->def->body.proc, proc);

val = rb_vm_invoke_proc(th, proc, recv, argc, argv, blockptr);

EXEC_EVENT_HOOK(th, RUBY_EVENT_RETURN, recv, me->called_id, me->klass);

return val;