kanayago 0.1.1 → 0.2.0

data/ext/kanayago/kanayago.h

@@ -18,4 +18,9 @@ extern const rb_data_type_t ruby_parser_data_type;
 extern const rb_data_type_t ast_data_type;
 // End for Kanayago
 
+#define symbol(arg) \
+    ID2SYM(rb_intern((arg)))
+
+VALUE ast_to_node_instance(const NODE *);
+
 #endif /* KANAYAGO_H */

data/ext/kanayago/literal_node.c

@@ -0,0 +1,343 @@
+#include "literal_node.h"
+#include "internal/ruby_parser.h"
+#include "kanayago.h"
+#include "internal/encoding.h"
+#include "rubyparser.h"
+
+VALUE rb_cIntegerNode;
+VALUE rb_cFloatNode;
+VALUE rb_cRationalNode;
+VALUE rb_cImaginaryNode;
+VALUE rb_cStringNode;
+VALUE rb_cSymbolNode;
+VALUE rb_cZeroListNode;
+VALUE rb_cFileNode;
+VALUE rb_cLineNode;
+VALUE rb_cEncodingNode;
+VALUE rb_cNilNode;
+VALUE rb_cTrueNode;
+VALUE rb_cFalseNode;
+VALUE rb_cRangeNode;
+VALUE rb_cExclusiveRangeNode;
+VALUE rb_cFlipFlopNode;
+VALUE rb_cExclusiveFlipFlopNode;
+VALUE rb_cHashNode;
+VALUE rb_cNthRefNode;
+VALUE rb_cBackRefNode;
+
+VALUE
+integer_node_new(const NODE *node)
+{
+    VALUE result = rb_class_new_instance(0, 0, rb_cIntegerNode);
+
+    rb_ivar_set(result, rb_intern("@val"), rb_node_integer_literal_val(node));
+    rb_ivar_set(result, rb_intern("@minus"), RNODE_INTEGER(node)->minus == TRUE ? Qtrue : Qfalse);
+    rb_ivar_set(result, rb_intern("@base"), INT2FIX(RNODE_INTEGER(node)->base));
+
+    return result;
+}
+
+VALUE
+float_node_new(const NODE *node)
+{
+    VALUE result = rb_class_new_instance(0, 0, rb_cFloatNode);
+
+    rb_ivar_set(result, rb_intern("@val"), rb_node_float_literal_val(node));
+    rb_ivar_set(result, rb_intern("@minus"), RNODE_FLOAT(node)->minus == TRUE ? Qtrue : Qfalse);
+
+    return result;
+}
+
+VALUE
+rational_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cRationalNode);
+
+    rb_ivar_set(obj, rb_intern("@val"), rb_node_rational_literal_val(node));
+    rb_ivar_set(obj, rb_intern("@minus"), RNODE_RATIONAL(node)->minus == TRUE ? Qtrue : Qfalse);
+    rb_ivar_set(obj, rb_intern("@base"), INT2FIX(RNODE_RATIONAL(node)->base));
+    rb_ivar_set(obj, rb_intern("@seen_point"), INT2FIX(RNODE_RATIONAL(node)->seen_point));
+
+    return obj;
+}
+
+static VALUE
+parser_string_coderange_type_to_str(enum rb_parser_string_coderange_type coderange)
+{
+    switch (coderange) {
+      case RB_PARSER_ENC_CODERANGE_UNKNOWN:
+        return rb_str_new_cstr("RB_PARSER_ENC_CODERANGE_UNKNOWN");
+      case RB_PARSER_ENC_CODERANGE_7BIT:
+	return rb_str_new_cstr("RB_PARSER_ENC_CODERANGE_7BIT");
+      case RB_PARSER_ENC_CODERANGE_VALID:
+	return rb_str_new_cstr("RB_PARSER_ENC_CODERANGE_VALID");
+      case RB_PARSER_ENC_CODERANGE_BROKEN:
+	return rb_str_new_cstr("RB_PARSER_ENC_CODERANGE_BROKEN");
+    }
+    return Qnil;
+}
+
+static VALUE
+numeric_type_to_str(enum rb_numeric_type type)
+{
+    switch (type) {
+      case integer_literal:
+        return rb_str_new_cstr("integer_literal");
+      case float_literal:
+	return rb_str_new_cstr("float_literal");
+      case rational_literal:
+	return rb_str_new_cstr("rational_literal");
+    }
+    return Qnil;
+}
+
+VALUE
+imaginary_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cImaginaryNode);
+    enum rb_numeric_type type = RNODE_IMAGINARY(node)->type;
+
+    rb_ivar_set(obj, rb_intern("@val"), rb_node_imaginary_literal_val(node));
+    rb_ivar_set(obj, rb_intern("@minus"), RNODE_IMAGINARY(node)->minus == TRUE ? Qtrue : Qfalse);
+    rb_ivar_set(obj, rb_intern("@base"), INT2FIX(RNODE_IMAGINARY(node)->base));
+    rb_ivar_set(obj, rb_intern("@seen_point"), INT2FIX(RNODE_IMAGINARY(node)->seen_point));
+    rb_ivar_set(obj, rb_intern("@type"), numeric_type_to_str(type));
+
+    return obj;
+}
+
+VALUE
+string_node_new(const NODE *node)
+{
+    VALUE result = rb_class_new_instance(0, 0, rb_cStringNode);
+    rb_parser_string_t *str = RNODE_STR(node)->string;
+    rb_encoding *enc = str->enc;
+    char *ptr = str->ptr;
+    long len = str->len;
+    enum rb_parser_string_coderange_type conderange = str->coderange;
+
+    rb_ivar_set(result, rb_intern("@ptr"), rb_enc_str_new(ptr, len, enc));
+    rb_ivar_set(result, rb_intern("@len"), LONG2FIX(len));
+    rb_ivar_set(result, rb_intern("@enc"), rb_enc_from_encoding(enc));
+    rb_ivar_set(result, rb_intern("@coderange"), parser_string_coderange_type_to_str(conderange));
+
+    return result;
+}
+
+VALUE
+symbol_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cSymbolNode);
+
+    rb_parser_string_t *str = RNODE_SYM(node)->string;
+    rb_encoding *enc = str->enc;
+    char *ptr = str->ptr;
+    long len = str->len;
+    enum rb_parser_string_coderange_type conderange = str->coderange;
+
+    rb_ivar_set(obj, rb_intern("@ptr"), rb_enc_str_new(ptr, len, enc));
+    rb_ivar_set(obj, rb_intern("@len"), LONG2FIX(len));
+    rb_ivar_set(obj, rb_intern("@enc"), rb_enc_from_encoding(enc));
+    rb_ivar_set(obj, rb_intern("@coderange"), parser_string_coderange_type_to_str(conderange));
+
+    return obj;
+}
+
+VALUE
+zero_list_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cZeroListNode);
+
+    rb_ivar_set(obj, rb_intern("@len"), INT2FIX(0));
+    rb_ivar_set(obj, rb_intern("@val"), rb_ary_new());
+
+    return obj;
+}
+
+VALUE
+file_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cFileNode);
+
+    rb_parser_string_t *str = RNODE_FILE(node)->path;
+    rb_encoding *enc = str->enc;
+    char *ptr = str->ptr;
+    long len = str->len;
+    enum rb_parser_string_coderange_type conderange = str->coderange;
+
+    rb_ivar_set(obj, rb_intern("@ptr"), rb_enc_str_new(ptr, len, enc));
+    rb_ivar_set(obj, rb_intern("@len"), LONG2FIX(len));
+    rb_ivar_set(obj, rb_intern("@enc"), rb_enc_from_encoding(enc));
+    rb_ivar_set(obj, rb_intern("@coderange"), parser_string_coderange_type_to_str(conderange));
+
+    return obj;
+}
+
+VALUE
+line_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cLineNode);
+
+    rb_ivar_set(obj, rb_intern("@lineno"), INT2FIX(node->nd_loc.beg_pos.lineno));
+
+    return obj;
+}
+
+VALUE
+encoding_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cEncodingNode);
+
+    rb_ivar_set(obj, rb_intern("@val"), rb_enc_from_encoding(RNODE_ENCODING(node)->enc));
+
+    return obj;
+}
+
+VALUE
+nil_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cNilNode);
+
+    rb_ivar_set(obj, rb_intern("@val"), Qnil);
+
+    return obj;
+}
+
+VALUE
+true_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cTrueNode);
+
+    rb_ivar_set(obj, rb_intern("@val"), Qtrue);
+
+    return obj;
+}
+
+VALUE
+false_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cFalseNode);
+
+    rb_ivar_set(obj, rb_intern("@val"), Qfalse);
+
+    return obj;
+}
+
+VALUE
+range_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cRangeNode);
+
+    rb_ivar_set(obj, rb_intern("@beg"), ast_to_node_instance(RNODE_DOT2(node)->nd_beg));
+    rb_ivar_set(obj, rb_intern("@end"), ast_to_node_instance(RNODE_DOT2(node)->nd_end));
+
+    return obj;
+}
+
+VALUE
+exclusive_range_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cExclusiveRangeNode);
+
+    rb_ivar_set(obj, rb_intern("@beg"), ast_to_node_instance(RNODE_DOT3(node)->nd_beg));
+    rb_ivar_set(obj, rb_intern("@end"), ast_to_node_instance(RNODE_DOT3(node)->nd_end));
+
+    return obj;
+}
+
+VALUE
+flip_flop_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cFlipFlopNode);
+
+    rb_ivar_set(obj, rb_intern("@beg"), ast_to_node_instance(RNODE_FLIP2(node)->nd_beg));
+    rb_ivar_set(obj, rb_intern("@end"), ast_to_node_instance(RNODE_FLIP2(node)->nd_end));
+
+    return obj;
+}
+
+VALUE
+exclusive_flip_flop_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cExclusiveFlipFlopNode);
+
+    rb_ivar_set(obj, rb_intern("@beg"), ast_to_node_instance(RNODE_FLIP3(node)->nd_beg));
+    rb_ivar_set(obj, rb_intern("@end"), ast_to_node_instance(RNODE_FLIP3(node)->nd_end));
+
+    return obj;
+}
+
+VALUE
+hash_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cHashNode);
+
+    rb_ivar_set(obj, rb_intern("@head"), ast_to_node_instance(RNODE_HASH(node)->nd_head));
+    rb_ivar_set(obj, rb_intern("@brace"), RNODE_HASH(node)->nd_brace ? Qtrue : Qfalse);
+
+    return obj;
+}
+
+VALUE
+nth_ref_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cNthRefNode);
+
+    rb_ivar_set(obj, rb_intern("@nth"), LONG2NUM(RNODE_NTH_REF(node)->nd_nth));
+
+    return obj;
+}
+
+VALUE
+back_ref_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cBackRefNode);
+
+    rb_ivar_set(obj, rb_intern("@nth"), LONG2NUM(RNODE_BACK_REF(node)->nd_nth));
+
+    return obj;
+}
+
+void
+Init_LiteralNode(VALUE module)
+{
+    rb_cIntegerNode = rb_define_class_under(module, "IntegerNode", rb_cObject);
+
+    rb_cFloatNode = rb_define_class_under(module, "FloatNode", rb_cObject);
+
+    rb_cRationalNode = rb_define_class_under(module, "RationalNode", rb_cObject);
+
+    rb_cImaginaryNode = rb_define_class_under(module, "ImaginaryNode", rb_cObject);
+
+    rb_cStringNode = rb_define_class_under(module, "StringNode", rb_cObject);
+
+    rb_cSymbolNode = rb_define_class_under(module, "SymbolNode", rb_cObject);
+
+    rb_cZeroListNode = rb_define_class_under(module, "ZeroListNode", rb_cObject);
+
+    rb_cFileNode = rb_define_class_under(module, "FileNode", rb_cObject);
+
+    rb_cLineNode = rb_define_class_under(module, "LineNode", rb_cObject);
+
+    rb_cEncodingNode = rb_define_class_under(module, "EncodingNode", rb_cObject);
+
+    rb_cNilNode = rb_define_class_under(module, "NilNode", rb_cObject);
+
+    rb_cTrueNode = rb_define_class_under(module, "TrueNode", rb_cObject);
+
+    rb_cFalseNode = rb_define_class_under(module, "FalseNode", rb_cObject);
+
+    rb_cRangeNode = rb_define_class_under(module, "RangeNode", rb_cObject);
+
+    rb_cExclusiveRangeNode = rb_define_class_under(module, "ExclusiveRangeNode", rb_cObject);
+
+    rb_cFlipFlopNode = rb_define_class_under(module, "FlipFlopNode", rb_cObject);
+
+    rb_cExclusiveFlipFlopNode = rb_define_class_under(module, "ExclusiveFlipFlopNode", rb_cObject);
+
+    rb_cHashNode = rb_define_class_under(module, "HashNode", rb_cObject);
+
+    rb_cNthRefNode = rb_define_class_under(module, "NthRefNode", rb_cObject);
+
+    rb_cBackRefNode = rb_define_class_under(module, "BackRefNode", rb_cObject);
+}

data/ext/kanayago/literal_node.h

@@ -0,0 +1,30 @@
+#ifndef KANAYAGO_LITERAL_NODE_H
+#define KANAYAGO_LITERAL_NODE_H
+
+#include "internal/ruby_parser.h"
+#include "kanayago.h"
+
+VALUE integer_node_new(const NODE *);
+VALUE float_node_new(const NODE *);
+VALUE rational_node_new(const NODE *);
+VALUE imaginary_node_new(const NODE *);
+VALUE symbol_node_new(const NODE *);
+VALUE string_node_new(const NODE *);
+VALUE zero_list_node_new(const NODE *);
+VALUE file_node_new(const NODE *node);
+VALUE line_node_new(const NODE *);
+VALUE encoding_node_new(const NODE *);
+VALUE nil_node_new(const NODE *);
+VALUE true_node_new(const NODE *);
+VALUE false_node_new(const NODE *);
+VALUE range_node_new(const NODE *);
+VALUE exclusive_range_node_new(const NODE *);
+VALUE flip_flop_node_new(const NODE *);
+VALUE exclusive_flip_flop_node_new(const NODE *);
+VALUE hash_node_new(const NODE *);
+VALUE nth_ref_node_new(const NODE *);
+VALUE back_ref_node_new(const NODE *);
+
+void Init_LiteralNode(VALUE);
+
+#endif

data/ext/kanayago/method.h

@@ -15,6 +15,7 @@
 #include "internal/imemo.h"
 #include "internal/compilers.h"
 #include "internal/static_assert.h"
+#include "ruby/atomic.h"
 
 #ifndef END_OF_ENUMERATION
 # if defined(__GNUC__) &&! defined(__STRICT_ANSI__)
@@ -72,10 +73,17 @@ typedef struct rb_callable_method_entry_struct { /* same fields with rb_method_e
 #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_CACHED_SET(rb_callable_method_entry_t *me)
+{
+    if (!METHOD_ENTRY_CACHED(me)) {
+        me->flags |= IMEMO_FL_USER4;
+    }
+}
+
 static inline void
 METHOD_ENTRY_VISI_SET(rb_method_entry_t *me, rb_method_visibility_t visi)
 {
@@ -181,7 +189,8 @@ struct rb_method_definition_struct {
     unsigned int iseq_overload: 1;
     unsigned int no_redef_warning: 1;
     unsigned int aliased : 1;
-    int reference_count : 28;
+
+    rb_atomic_t reference_count;
 
     union {
         rb_method_iseq_t iseq;
@@ -195,6 +204,7 @@ struct rb_method_definition_struct {
 
     ID original_id;
     uintptr_t method_serial;
+    const rb_namespace_t *ns;
 };
 
 struct rb_id_table;
@@ -237,6 +247,7 @@ 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_vm_weak_references(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);
@@ -244,12 +255,17 @@ const rb_callable_method_entry_t *rb_method_entry_complement_defined_class(const
 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_method_table_insert0(VALUE klass, struct rb_id_table *table, ID method_id, const rb_method_entry_t *me, bool iclass_shared_mtbl);
 
 void rb_scope_visibility_set(rb_method_visibility_t);
 
 VALUE rb_unnamed_parameters(int arity);
 
+void rb_vm_insert_cc_refinement(const struct rb_callcache *cc);
+void rb_vm_delete_cc_refinement(const struct rb_callcache *cc);
+
 void rb_clear_method_cache(VALUE klass_or_module, ID mid);
 void rb_clear_all_refinement_method_cache(void);
+void rb_invalidate_method_caches(struct rb_id_table *cm_tbl, VALUE cc_tbl);
 
 #endif /* RUBY_METHOD_H */

data/ext/kanayago/node.c

@@ -225,7 +225,7 @@ free_ast_value(rb_ast_t *ast, void *ctx, NODE *node)
 static void
 rb_node_buffer_free(rb_ast_t *ast, node_buffer_t *nb)
 {
-    if (nb && nb->tokens) {
+    if (nb->tokens) {
         parser_tokens_free(ast, nb->tokens);
     }
     iterate_node_values(ast, &nb->buffer_list, free_ast_value, NULL);
@@ -438,3 +438,9 @@ rb_node_set_type(NODE *n, enum node_type t)
 {
     return nd_init_type(n, t);
 }
+
+enum node_type
+rb_node_get_type(const NODE *n)
+{
+    return (enum node_type)nd_type(n);
+}

data/ext/kanayago/node.h

@@ -67,16 +67,27 @@ const struct kwtable *rb_reserved_word(const char *, unsigned int);
 struct parser_params;
 PRINTF_ARGS(void rb_parser_printf(struct parser_params *parser, const char *fmt, ...), 2, 3);
 VALUE rb_node_set_type(NODE *n, enum node_type t);
+enum node_type rb_node_get_type(const NODE *n);
 
 RUBY_SYMBOL_EXPORT_END
 
 #define NODE_LSHIFT (NODE_TYPESHIFT+7)
 #define NODE_LMASK  (((SIGNED_VALUE)1<<(sizeof(VALUE)*CHAR_BIT-NODE_LSHIFT))-1)
 
-#define nd_line(n) (int)(((SIGNED_VALUE)(n)->flags)>>NODE_LSHIFT)
-#define nd_set_line(n,l) \
-    (n)->flags=(((n)->flags&~((VALUE)(-1)<<NODE_LSHIFT))|((VALUE)((l)&NODE_LMASK)<<NODE_LSHIFT))
+static inline int
+nd_line(const NODE *n)
+{
+    if (!n) return -1;
+    SIGNED_VALUE flags = (SIGNED_VALUE)n->flags;
+    return (int)(flags >> NODE_LSHIFT);
+}
 
+static inline void
+nd_set_line(NODE *n, SIGNED_VALUE l)
+{
+    n->flags &= ~(~(VALUE)0 << NODE_LSHIFT);
+    n->flags |= ((VALUE)(l & NODE_LMASK) << NODE_LSHIFT);
+}
 
 #define NODE_SPECIAL_REQUIRED_KEYWORD ((NODE *)-1)
 #define NODE_REQUIRED_KEYWORD_P(node) ((node) == NODE_SPECIAL_REQUIRED_KEYWORD)