kanayago 0.1.1

data/ext/kanayago/lex.c

@@ -0,0 +1,302 @@
+/* ANSI-C code produced by gperf version 3.1 */
+/* Command-line: gperf -C -L ANSI-C -P -p -j1 -i 1 -g -o -t -N rb_reserved_word -k'1,3,$' defs/keywords  */
+
+#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
+      && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
+      && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
+      && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
+      && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
+      && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
+      && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
+      && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
+      && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
+      && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
+      && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
+      && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
+      && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
+      && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
+      && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
+      && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
+      && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
+      && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
+      && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
+      && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
+      && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
+      && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
+      && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
+/* The character set is not based on ISO-646.  */
+#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gperf@gnu.org>."
+#endif
+
+#line 1 "defs/keywords"
+
+struct kwtable {short name, id[2], state;};
+const struct kwtable *rb_reserved_word(const char *, unsigned int);
+#ifndef RIPPER
+static const struct kwtable *reserved_word(register const char *str, register size_t len);
+#define rb_reserved_word(str, len) reserved_word(str, len)
+#line 9 "defs/keywords"
+struct kwtable;
+
+#define TOTAL_KEYWORDS 41
+#define MIN_WORD_LENGTH 2
+#define MAX_WORD_LENGTH 12
+#define MIN_HASH_VALUE 8
+#define MAX_HASH_VALUE 50
+/* maximum key range = 43, duplicates = 0 */
+
+#ifdef __GNUC__
+__inline
+#else
+#ifdef __cplusplus
+inline
+#endif
+#endif
+static unsigned int
+hash (register const char *str, register size_t len)
+{
+  static const unsigned char asso_values[] =
+    {
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 26, 51, 51, 14, 51, 16,  8,
+      11, 13, 51, 51, 51, 51, 10, 51, 13, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 11, 51, 13,  1, 26,
+       4,  1,  8, 28, 51, 23, 51,  1,  1, 27,
+       5, 19, 21, 51,  8,  3,  3, 11, 51, 21,
+      24, 16, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+      51, 51, 51, 51, 51, 51
+    };
+  register unsigned int hval = (unsigned int)len;
+
+  switch (hval)
+    {
+      default:
+        hval += asso_values[(unsigned char)str[2]];
+      /*FALLTHROUGH*/
+      case 2:
+      case 1:
+        hval += asso_values[(unsigned char)str[0]];
+        break;
+    }
+  return (unsigned int)hval + asso_values[(unsigned char)str[len - 1]];
+}
+
+struct stringpool_t
+  {
+    char stringpool_str8[sizeof("break")];
+    char stringpool_str9[sizeof("else")];
+    char stringpool_str10[sizeof("nil")];
+    char stringpool_str11[sizeof("ensure")];
+    char stringpool_str12[sizeof("end")];
+    char stringpool_str13[sizeof("then")];
+    char stringpool_str14[sizeof("not")];
+    char stringpool_str15[sizeof("false")];
+    char stringpool_str16[sizeof("self")];
+    char stringpool_str17[sizeof("elsif")];
+    char stringpool_str18[sizeof("rescue")];
+    char stringpool_str19[sizeof("true")];
+    char stringpool_str20[sizeof("until")];
+    char stringpool_str21[sizeof("unless")];
+    char stringpool_str22[sizeof("return")];
+    char stringpool_str23[sizeof("def")];
+    char stringpool_str24[sizeof("and")];
+    char stringpool_str25[sizeof("do")];
+    char stringpool_str26[sizeof("yield")];
+    char stringpool_str27[sizeof("for")];
+    char stringpool_str28[sizeof("undef")];
+    char stringpool_str29[sizeof("or")];
+    char stringpool_str30[sizeof("in")];
+    char stringpool_str31[sizeof("when")];
+    char stringpool_str32[sizeof("retry")];
+    char stringpool_str33[sizeof("if")];
+    char stringpool_str34[sizeof("case")];
+    char stringpool_str35[sizeof("redo")];
+    char stringpool_str36[sizeof("next")];
+    char stringpool_str37[sizeof("super")];
+    char stringpool_str38[sizeof("module")];
+    char stringpool_str39[sizeof("begin")];
+    char stringpool_str40[sizeof("__LINE__")];
+    char stringpool_str41[sizeof("__FILE__")];
+    char stringpool_str42[sizeof("__ENCODING__")];
+    char stringpool_str43[sizeof("END")];
+    char stringpool_str44[sizeof("alias")];
+    char stringpool_str45[sizeof("BEGIN")];
+    char stringpool_str46[sizeof("defined?")];
+    char stringpool_str47[sizeof("class")];
+    char stringpool_str50[sizeof("while")];
+  };
+static const struct stringpool_t stringpool_contents =
+  {
+    "break",
+    "else",
+    "nil",
+    "ensure",
+    "end",
+    "then",
+    "not",
+    "false",
+    "self",
+    "elsif",
+    "rescue",
+    "true",
+    "until",
+    "unless",
+    "return",
+    "def",
+    "and",
+    "do",
+    "yield",
+    "for",
+    "undef",
+    "or",
+    "in",
+    "when",
+    "retry",
+    "if",
+    "case",
+    "redo",
+    "next",
+    "super",
+    "module",
+    "begin",
+    "__LINE__",
+    "__FILE__",
+    "__ENCODING__",
+    "END",
+    "alias",
+    "BEGIN",
+    "defined?",
+    "class",
+    "while"
+  };
+#define stringpool ((const char *) &stringpool_contents)
+const struct kwtable *
+rb_reserved_word (register const char *str, register size_t len)
+{
+  static const struct kwtable wordlist[] =
+    {
+      {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1},
+#line 19 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str8, {keyword_break, keyword_break}, EXPR_MID},
+#line 25 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str9, {keyword_else, keyword_else}, EXPR_BEG},
+#line 35 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str10, {keyword_nil, keyword_nil}, EXPR_END},
+#line 28 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str11, {keyword_ensure, keyword_ensure}, EXPR_BEG},
+#line 27 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str12, {keyword_end, keyword_end}, EXPR_END},
+#line 44 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str13, {keyword_then, keyword_then}, EXPR_BEG},
+#line 36 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str14, {keyword_not, keyword_not}, EXPR_ARG},
+#line 29 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str15, {keyword_false, keyword_false}, EXPR_END},
+#line 42 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str16, {keyword_self, keyword_self}, EXPR_END},
+#line 26 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str17, {keyword_elsif, keyword_elsif}, EXPR_VALUE},
+#line 39 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str18, {keyword_rescue, modifier_rescue}, EXPR_MID},
+#line 45 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str19, {keyword_true, keyword_true}, EXPR_END},
+#line 48 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str20, {keyword_until, modifier_until}, EXPR_VALUE},
+#line 47 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str21, {keyword_unless, modifier_unless}, EXPR_VALUE},
+#line 41 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str22, {keyword_return, keyword_return}, EXPR_MID},
+#line 22 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str23, {keyword_def, keyword_def}, EXPR_FNAME},
+#line 17 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str24, {keyword_and, keyword_and}, EXPR_VALUE},
+#line 24 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str25, {keyword_do, keyword_do}, EXPR_BEG},
+#line 51 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str26, {keyword_yield, keyword_yield}, EXPR_ARG},
+#line 30 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str27, {keyword_for, keyword_for}, EXPR_VALUE},
+#line 46 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str28, {keyword_undef, keyword_undef}, EXPR_FNAME|EXPR_FITEM},
+#line 37 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str29, {keyword_or, keyword_or}, EXPR_VALUE},
+#line 32 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str30, {keyword_in, keyword_in}, EXPR_VALUE},
+#line 49 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str31, {keyword_when, keyword_when}, EXPR_VALUE},
+#line 40 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str32, {keyword_retry, keyword_retry}, EXPR_END},
+#line 31 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str33, {keyword_if, modifier_if}, EXPR_VALUE},
+#line 20 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str34, {keyword_case, keyword_case}, EXPR_VALUE},
+#line 38 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str35, {keyword_redo, keyword_redo}, EXPR_END},
+#line 34 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str36, {keyword_next, keyword_next}, EXPR_MID},
+#line 43 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str37, {keyword_super, keyword_super}, EXPR_ARG},
+#line 33 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str38, {keyword_module, keyword_module}, EXPR_VALUE},
+#line 18 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str39, {keyword_begin, keyword_begin}, EXPR_BEG},
+#line 12 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str40, {keyword__LINE__, keyword__LINE__}, EXPR_END},
+#line 13 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str41, {keyword__FILE__, keyword__FILE__}, EXPR_END},
+#line 11 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str42, {keyword__ENCODING__, keyword__ENCODING__}, EXPR_END},
+#line 15 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str43, {keyword_END, keyword_END}, EXPR_END},
+#line 16 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str44, {keyword_alias, keyword_alias}, EXPR_FNAME|EXPR_FITEM},
+#line 14 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str45, {keyword_BEGIN, keyword_BEGIN}, EXPR_END},
+#line 23 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str46, {keyword_defined, keyword_defined}, EXPR_ARG},
+#line 21 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str47, {keyword_class, keyword_class}, EXPR_CLASS},
+      {-1}, {-1},
+#line 50 "defs/keywords"
+      {(int)(size_t)&((struct stringpool_t *)0)->stringpool_str50, {keyword_while, modifier_while}, EXPR_VALUE}
+    };
+
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register unsigned int key = hash (str, len);
+
+      if (key <= MAX_HASH_VALUE)
+        {
+          register int o = wordlist[key].name;
+          if (o >= 0)
+            {
+              register const char *s = o + stringpool;
+
+              if (*str == *s && !strcmp (str + 1, s + 1))
+                return &wordlist[key];
+            }
+        }
+    }
+  return 0;
+}
+#line 52 "defs/keywords"
+
+#endif

data/ext/kanayago/method.h

@@ -0,0 +1,255 @@
+#ifndef RUBY_METHOD_H
+#define RUBY_METHOD_H 1
+/**********************************************************************
+
+  method.h -
+
+  $Author$
+  created at: Wed Jul 15 20:02:33 2009
+
+  Copyright (C) 2009 Koichi Sasada
+
+**********************************************************************/
+
+#include "internal.h"
+#include "internal/imemo.h"
+#include "internal/compilers.h"
+#include "internal/static_assert.h"
+
+#ifndef END_OF_ENUMERATION
+# if defined(__GNUC__) &&! defined(__STRICT_ANSI__)
+#   define END_OF_ENUMERATION(key)
+# else
+#   define END_OF_ENUMERATION(key) END_OF_##key##_PLACEHOLDER = 0
+# endif
+#endif
+
+/* cref */
+
+typedef enum {
+    METHOD_VISI_UNDEF     = 0x00,
+    METHOD_VISI_PUBLIC    = 0x01,
+    METHOD_VISI_PRIVATE   = 0x02,
+    METHOD_VISI_PROTECTED = 0x03,
+
+    METHOD_VISI_MASK = 0x03
+} rb_method_visibility_t;
+
+typedef struct rb_scope_visi_struct {
+    BITFIELD(rb_method_visibility_t, method_visi, 3);
+    unsigned int module_func : 1;
+} rb_scope_visibility_t;
+
+/*! CREF (Class REFerence) */
+typedef struct rb_cref_struct {
+    VALUE flags;
+    VALUE refinements;
+    VALUE klass_or_self;
+    struct rb_cref_struct * next;
+    const rb_scope_visibility_t scope_visi;
+} rb_cref_t;
+
+/* method data type */
+
+typedef struct rb_method_entry_struct {
+    VALUE flags;
+    VALUE defined_class;
+    struct rb_method_definition_struct * const def;
+    ID called_id;
+    VALUE owner;
+} rb_method_entry_t;
+
+typedef struct rb_callable_method_entry_struct { /* same fields with rb_method_entry_t */
+    VALUE flags;
+    const VALUE defined_class;
+    struct rb_method_definition_struct * const def;
+    ID called_id;
+    const VALUE owner;
+} rb_callable_method_entry_t;
+
+#define METHOD_ENTRY_VISI(me)  (rb_method_visibility_t)(((me)->flags & (IMEMO_FL_USER0 | IMEMO_FL_USER1)) >> (IMEMO_FL_USHIFT+0))
+#define METHOD_ENTRY_BASIC(me) (int)                   (((me)->flags & (IMEMO_FL_USER2                 )) >> (IMEMO_FL_USHIFT+2))
+#define METHOD_ENTRY_COMPLEMENTED(me)        ((me)->flags & IMEMO_FL_USER3)
+#define METHOD_ENTRY_COMPLEMENTED_SET(me)    ((me)->flags |= IMEMO_FL_USER3)
+#define METHOD_ENTRY_CACHED(me)              ((me)->flags & IMEMO_FL_USER4)
+#define METHOD_ENTRY_CACHED_SET(me)          ((me)->flags |= IMEMO_FL_USER4)
+#define METHOD_ENTRY_INVALIDATED(me)         ((me)->flags & IMEMO_FL_USER5)
+#define METHOD_ENTRY_INVALIDATED_SET(me)     ((me)->flags |= IMEMO_FL_USER5)
+
+static inline void
+METHOD_ENTRY_VISI_SET(rb_method_entry_t *me, rb_method_visibility_t visi)
+{
+    VM_ASSERT((int)visi >= 0 && visi <= 3);
+    me->flags = (me->flags & ~(IMEMO_FL_USER0 | IMEMO_FL_USER1)) | (visi << (IMEMO_FL_USHIFT+0));
+}
+static inline void
+METHOD_ENTRY_BASIC_SET(rb_method_entry_t *me, unsigned int basic)
+{
+    VM_ASSERT(basic <= 1);
+    me->flags = (me->flags & ~(IMEMO_FL_USER2                 )) | (basic << (IMEMO_FL_USHIFT+2));
+}
+static inline void
+METHOD_ENTRY_FLAGS_SET(rb_method_entry_t *me, rb_method_visibility_t visi, unsigned int basic)
+{
+    VM_ASSERT((int)visi >= 0 && visi <= 3);
+    VM_ASSERT(basic <= 1);
+    me->flags =
+      (me->flags & ~(IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2)) |
+        ((visi << (IMEMO_FL_USHIFT+0)) | (basic << (IMEMO_FL_USHIFT+2)));
+}
+static inline void
+METHOD_ENTRY_FLAGS_COPY(rb_method_entry_t *dst, const rb_method_entry_t *src)
+{
+    dst->flags =
+      (dst->flags & ~(IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2
+      |IMEMO_FL_USER3)) |
+        (src->flags & (IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2|IMEMO_FL_USER3));
+}
+
+typedef enum {
+    VM_METHOD_TYPE_ISEQ,      /*!< Ruby method */
+    VM_METHOD_TYPE_CFUNC,     /*!< C method */
+    VM_METHOD_TYPE_ATTRSET,   /*!< attr_writer or attr_accessor */
+    VM_METHOD_TYPE_IVAR,      /*!< attr_reader or attr_accessor */
+    VM_METHOD_TYPE_BMETHOD,
+    VM_METHOD_TYPE_ZSUPER,
+    VM_METHOD_TYPE_ALIAS,
+    VM_METHOD_TYPE_UNDEF,
+    VM_METHOD_TYPE_NOTIMPLEMENTED,
+    VM_METHOD_TYPE_OPTIMIZED, /*!< Kernel#send, Proc#call, etc */
+    VM_METHOD_TYPE_MISSING,   /*!< wrapper for method_missing(id) */
+    VM_METHOD_TYPE_REFINED,   /*!< refinement */
+
+    END_OF_ENUMERATION(VM_METHOD_TYPE)
+} rb_method_type_t;
+#define VM_METHOD_TYPE_MINIMUM_BITS 4
+STATIC_ASSERT(VM_METHOD_TYPE_MINIMUM_BITS,
+              VM_METHOD_TYPE_REFINED <= (1<<VM_METHOD_TYPE_MINIMUM_BITS));
+
+#ifndef rb_iseq_t
+typedef struct rb_iseq_struct rb_iseq_t;
+#define rb_iseq_t rb_iseq_t
+#endif
+
+typedef struct rb_method_iseq_struct {
+    const rb_iseq_t * iseqptr; /*!< iseq pointer, should be separated from iseqval */
+    rb_cref_t * cref;          /*!< class reference, should be marked */
+} rb_method_iseq_t; /* check rb_add_method_iseq() when modify the fields */
+
+typedef VALUE (*rb_cfunc_t)(ANYARGS);
+typedef struct rb_method_cfunc_struct {
+    rb_cfunc_t func;
+    VALUE (*invoker)(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS));
+    int argc;
+} rb_method_cfunc_t;
+
+typedef struct rb_method_attr_struct {
+    ID id;
+    VALUE location; /* should be marked */
+} rb_method_attr_t;
+
+typedef struct rb_method_alias_struct {
+    struct rb_method_entry_struct * original_me; /* original_me->klass is original owner */
+} rb_method_alias_t;
+
+typedef struct rb_method_refined_struct {
+    struct rb_method_entry_struct * orig_me;
+} rb_method_refined_t;
+
+typedef struct rb_method_bmethod_struct {
+    VALUE proc; /* should be marked */
+    struct rb_hook_list_struct *hooks;
+    VALUE defined_ractor;
+} rb_method_bmethod_t;
+
+enum method_optimized_type {
+    OPTIMIZED_METHOD_TYPE_SEND,
+    OPTIMIZED_METHOD_TYPE_CALL,
+    OPTIMIZED_METHOD_TYPE_BLOCK_CALL,
+    OPTIMIZED_METHOD_TYPE_STRUCT_AREF,
+    OPTIMIZED_METHOD_TYPE_STRUCT_ASET,
+    OPTIMIZED_METHOD_TYPE__MAX
+};
+
+typedef struct rb_method_optimized {
+    enum method_optimized_type type;
+    unsigned int index;
+} rb_method_optimized_t;
+
+struct rb_method_definition_struct {
+    BITFIELD(rb_method_type_t, type, VM_METHOD_TYPE_MINIMUM_BITS);
+    unsigned int iseq_overload: 1;
+    unsigned int no_redef_warning: 1;
+    unsigned int aliased : 1;
+    int reference_count : 28;
+
+    union {
+        rb_method_iseq_t iseq;
+        rb_method_cfunc_t cfunc;
+        rb_method_attr_t attr;
+        rb_method_alias_t alias;
+        rb_method_refined_t refined;
+        rb_method_bmethod_t bmethod;
+        rb_method_optimized_t optimized;
+    } body;
+
+    ID original_id;
+    uintptr_t method_serial;
+};
+
+struct rb_id_table;
+
+typedef struct rb_method_definition_struct rb_method_definition_t;
+STATIC_ASSERT(sizeof_method_def, offsetof(rb_method_definition_t, body) <= 8);
+
+#define UNDEFINED_METHOD_ENTRY_P(me) (!(me) || !(me)->def || (me)->def->type == VM_METHOD_TYPE_UNDEF)
+#define UNDEFINED_REFINED_METHOD_P(def) \
+    ((def)->type == VM_METHOD_TYPE_REFINED && \
+     UNDEFINED_METHOD_ENTRY_P((def)->body.refined.orig_me))
+
+void rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *option, rb_method_visibility_t visi);
+void rb_add_method_cfunc(VALUE klass, ID mid, VALUE (*func)(ANYARGS), int argc, rb_method_visibility_t visi);
+void rb_add_method_iseq(VALUE klass, ID mid, const rb_iseq_t *iseq, rb_cref_t *cref, rb_method_visibility_t visi);
+void rb_add_method_optimized(VALUE klass, ID mid, enum method_optimized_type, unsigned int index, rb_method_visibility_t visi);
+void rb_add_refined_method_entry(VALUE refined_class, ID mid);
+
+rb_method_entry_t *rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *, rb_method_visibility_t noex);
+rb_method_entry_t *rb_method_entry_create(ID called_id, VALUE klass, rb_method_visibility_t visi, rb_method_definition_t *def);
+
+const rb_method_entry_t *rb_method_entry_at(VALUE obj, ID id);
+
+const rb_method_entry_t *rb_method_entry(VALUE klass, ID id);
+const rb_method_entry_t *rb_method_entry_with_refinements(VALUE klass, ID id, VALUE *defined_class);
+const rb_method_entry_t *rb_method_entry_without_refinements(VALUE klass, ID id, VALUE *defined_class);
+const rb_method_entry_t *rb_resolve_refined_method(VALUE refinements, const rb_method_entry_t *me);
+RUBY_SYMBOL_EXPORT_BEGIN
+const rb_method_entry_t *rb_resolve_me_location(const rb_method_entry_t *, VALUE[5]);
+RUBY_SYMBOL_EXPORT_END
+
+const rb_callable_method_entry_t *rb_callable_method_entry(VALUE klass, ID id);
+const rb_callable_method_entry_t *rb_callable_method_entry_or_negative(VALUE klass, ID id);
+const rb_callable_method_entry_t *rb_callable_method_entry_with_refinements(VALUE klass, ID id, VALUE *defined_class);
+const rb_callable_method_entry_t *rb_callable_method_entry_without_refinements(VALUE klass, ID id, VALUE *defined_class);
+
+int rb_method_entry_arity(const rb_method_entry_t *me);
+int rb_method_entry_eq(const rb_method_entry_t *m1, const rb_method_entry_t *m2);
+st_index_t rb_hash_method_entry(st_index_t hash, const rb_method_entry_t *me);
+
+VALUE rb_method_entry_location(const rb_method_entry_t *me);
+
+void rb_free_method_entry(const rb_method_entry_t *me);
+
+const rb_method_entry_t *rb_method_entry_clone(const rb_method_entry_t *me);
+const rb_callable_method_entry_t *rb_method_entry_complement_defined_class(const rb_method_entry_t *src_me, ID called_id, VALUE defined_class);
+void rb_method_entry_copy(rb_method_entry_t *dst, const rb_method_entry_t *src);
+
+void rb_method_table_insert(VALUE klass, struct rb_id_table *table, ID method_id, const rb_method_entry_t *me);
+
+void rb_scope_visibility_set(rb_method_visibility_t);
+
+VALUE rb_unnamed_parameters(int arity);
+
+void rb_clear_method_cache(VALUE klass_or_module, ID mid);
+void rb_clear_all_refinement_method_cache(void);
+
+#endif /* RUBY_METHOD_H */