kanayago 0.1.1 → 0.2.0

data/ext/kanayago/statement_node.h

@@ -0,0 +1,66 @@
+#ifndef KANAYAGO_STATEMENT_NODE_H
+#define KANAYAGO_STATEMENT_NODE_H
+
+#include "internal/ruby_parser.h"
+#include "kanayago.h"
+
+VALUE if_statement_node_new(const NODE *);
+VALUE unless_statement_node_new(const NODE *);
+VALUE or_node_new(const NODE *);
+VALUE and_node_new(const NODE *);
+VALUE while_node_new(const NODE *);
+VALUE until_node_new(const NODE *);
+VALUE for_node_new(const NODE *);
+VALUE alias_node_new(const NODE *);
+VALUE valias_node_new(const NODE *);
+VALUE undef_node_new(const NODE *);
+VALUE return_node_new(const NODE *);
+VALUE global_assignment_node_new(const NODE *);
+VALUE class_variable_assignment_node_new(const NODE *);
+VALUE instance_assignment_node_new(const NODE *);
+VALUE local_assignment_node_new(const NODE *);
+VALUE singleton_definition_node_new(const NODE *);
+VALUE singleton_class_node_new(const NODE *);
+VALUE attribute_assignment_node_new(const NODE *);
+VALUE safe_call_node_new(const NODE *);
+VALUE super_node_new(const NODE *);
+VALUE zero_super_node_new(const NODE *);
+VALUE case_node_new(const NODE *);
+VALUE case2_node_new(const NODE *);
+VALUE case3_node_new(const NODE *);
+VALUE when_node_new(const NODE *);
+VALUE retry_node_new(const NODE *);
+VALUE redo_node_new(const NODE *);
+VALUE break_node_new(const NODE *);
+VALUE next_node_new(const NODE *);
+VALUE defined_node_new(const NODE *);
+VALUE iter_node_new(const NODE *);
+VALUE ensure_node_new(const NODE *);
+VALUE rescue_node_new(const NODE *);
+VALUE resbody_node_new(const NODE *);
+VALUE operator_assignment1_node_new(const NODE *);
+VALUE operator_assignment2_node_new(const NODE *);
+VALUE operator_assignment_and_node_new(const NODE *);
+VALUE operator_assignment_or_node_new(const NODE *);
+VALUE operator_constant_declaration_node_new(const NODE *);
+VALUE yield_node_new(const NODE *);
+VALUE lambda_node_new(const NODE *);
+VALUE splat_node_new(const NODE *);
+VALUE block_pass_node_new(const NODE *);
+VALUE args_aux_node_new(const NODE *);
+VALUE opt_arg_node_new(const NODE *);
+VALUE kw_arg_node_new(const NODE *);
+VALUE post_arg_node_new(const NODE *);
+VALUE args_cat_node_new(const NODE *);
+VALUE args_push_node_new(const NODE *);
+VALUE for_masgn_node_new(const NODE *);
+VALUE masgn_node_new(const NODE *);
+VALUE dasgn_node_new(const NODE *);
+VALUE once_node_new(const NODE *);
+VALUE errinfo_node_new(const NODE *);
+VALUE postexe_node_new(const NODE *);
+VALUE error_node_new(const NODE *);
+
+void Init_StatementNode(VALUE);
+
+#endif

data/ext/kanayago/string_node.c

@@ -0,0 +1,192 @@
+#include "string_node.h"
+#include "internal/ruby_parser.h"
+#include "internal/encoding.h"
+#include "kanayago.h"
+
+VALUE rb_cDynamicStringNode;
+VALUE rb_cDynamicSymbolNode;
+VALUE rb_cEmbeddedExpressionStringNode;
+VALUE rb_cExecuteStringNode;
+VALUE rb_cDynamicExecuteStringNode;
+VALUE rb_cRegexpNode;
+VALUE rb_cDynamicRegexpNode;
+VALUE rb_cMatchNode;
+VALUE rb_cMatch2Node;
+VALUE rb_cMatch3Node;
+
+VALUE
+dynamic_string_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cDynamicStringNode);
+    rb_parser_string_t *str = RNODE_DSTR(node)->string;
+    rb_encoding *enc = str->enc;
+    char *ptr = str->ptr;
+    long len = str->len;
+
+    rb_ivar_set(obj, rb_intern("@string"), rb_enc_str_new(ptr, len, enc));
+    rb_ivar_set(obj, rb_intern("@next_nodes"), ast_to_node_instance((const NODE *)RNODE_DSTR(node)->nd_next));
+
+    return obj;
+}
+
+VALUE
+dynamic_symbol_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cDynamicSymbolNode);
+    rb_parser_string_t *str = RNODE_DSYM(node)->string;
+    rb_encoding *enc = str->enc;
+    char *ptr = str->ptr;
+    long len = str->len;
+
+    rb_ivar_set(obj, rb_intern("@string"), rb_enc_str_new(ptr, len, enc));
+    rb_ivar_set(obj, rb_intern("@next_nodes"), ast_to_node_instance((const NODE *)RNODE_DSYM(node)->nd_next));
+
+    return obj;
+}
+
+VALUE
+embedded_expression_string_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cEmbeddedExpressionStringNode);
+
+    rb_ivar_set(obj, rb_intern("@body"), ast_to_node_instance(RNODE_EVSTR(node)->nd_body));
+
+    return obj;
+}
+
+VALUE
+execute_string_node_new(const NODE *node)
+{
+    VALUE result = rb_class_new_instance(0, 0, rb_cExecuteStringNode);
+    rb_parser_string_t *str = RNODE_XSTR(node)->string;
+    rb_encoding *enc = str->enc;
+    char *ptr = str->ptr;
+    long len = str->len;
+    enum rb_parser_string_coderange_type coderange = 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"), INT2FIX(coderange));
+
+    return result;
+}
+
+VALUE
+dynamic_execute_string_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cDynamicExecuteStringNode);
+    rb_parser_string_t *str = RNODE_DXSTR(node)->string;
+    rb_encoding *enc = str->enc;
+    char *ptr = str->ptr;
+    long len = str->len;
+
+    rb_ivar_set(obj, rb_intern("@string"), rb_enc_str_new(ptr, len, enc));
+    rb_ivar_set(obj, rb_intern("@next_nodes"), ast_to_node_instance((const NODE *)RNODE_DXSTR(node)->nd_next));
+
+    return obj;
+}
+
+VALUE
+regexp_node_new(const NODE *node)
+{
+    VALUE result = rb_class_new_instance(0, 0, rb_cRegexpNode);
+    rb_parser_string_t *str = RNODE_REGX(node)->string;
+    rb_encoding *enc = str->enc;
+    char *ptr = str->ptr;
+    long len = str->len;
+    enum rb_parser_string_coderange_type coderange = str->coderange;
+    int options = RNODE_REGX(node)->options;
+
+    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"), INT2FIX(coderange));
+    rb_ivar_set(result, rb_intern("@options"), INT2FIX(options));
+
+    return result;
+}
+
+VALUE
+dynamic_regexp_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cDynamicRegexpNode);
+    rb_parser_string_t *str = RNODE_DREGX(node)->string;
+    rb_encoding *enc = str->enc;
+    char *ptr = str->ptr;
+    long len = str->len;
+    long options = RNODE_DREGX(node)->as.nd_cflag;
+
+    rb_ivar_set(obj, rb_intern("@string"), rb_enc_str_new(ptr, len, enc));
+    rb_ivar_set(obj, rb_intern("@next_nodes"), ast_to_node_instance((const NODE *)RNODE_DREGX(node)->nd_next));
+    rb_ivar_set(obj, rb_intern("@options"), LONG2FIX(options));
+
+    return obj;
+}
+
+VALUE
+match_node_new(const NODE *node)
+{
+    VALUE result = rb_class_new_instance(0, 0, rb_cMatchNode);
+    rb_parser_string_t *str = RNODE_MATCH(node)->string;
+    rb_encoding *enc = str->enc;
+    char *ptr = str->ptr;
+    long len = str->len;
+    enum rb_parser_string_coderange_type coderange = str->coderange;
+    int options = RNODE_MATCH(node)->options;
+
+    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"), INT2FIX(coderange));
+    rb_ivar_set(result, rb_intern("@options"), INT2FIX(options));
+
+    return result;
+}
+
+VALUE
+match2_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cMatch2Node);
+
+    rb_ivar_set(obj, rb_intern("@recv"), ast_to_node_instance(RNODE_MATCH2(node)->nd_recv));
+    rb_ivar_set(obj, rb_intern("@value"), ast_to_node_instance(RNODE_MATCH2(node)->nd_value));
+    rb_ivar_set(obj, rb_intern("@args"), ast_to_node_instance(RNODE_MATCH2(node)->nd_args));
+
+    return obj;
+}
+
+VALUE
+match3_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cMatch3Node);
+
+    rb_ivar_set(obj, rb_intern("@recv"), ast_to_node_instance(RNODE_MATCH3(node)->nd_recv));
+    rb_ivar_set(obj, rb_intern("@value"), ast_to_node_instance(RNODE_MATCH3(node)->nd_value));
+
+    return obj;
+}
+
+void
+Init_StringNode(VALUE module)
+{
+    rb_cDynamicStringNode = rb_define_class_under(module, "DynamicStringNode", rb_cObject);
+
+    rb_cDynamicSymbolNode = rb_define_class_under(module, "DynamicSymbolNode", rb_cObject);
+
+    rb_cEmbeddedExpressionStringNode = rb_define_class_under(module, "EmbeddedExpressionStringNode", rb_cObject);
+
+    rb_cExecuteStringNode = rb_define_class_under(module, "ExecuteStringNode", rb_cObject);
+
+    rb_cDynamicExecuteStringNode = rb_define_class_under(module, "DynamicExecuteStringNode", rb_cObject);
+
+    rb_cRegexpNode = rb_define_class_under(module, "RegexpNode", rb_cObject);
+
+    rb_cDynamicRegexpNode = rb_define_class_under(module, "DynamicRegexpNode", rb_cObject);
+
+    rb_cMatchNode = rb_define_class_under(module, "MatchNode", rb_cObject);
+
+    rb_cMatch2Node = rb_define_class_under(module, "Match2Node", rb_cObject);
+
+    rb_cMatch3Node = rb_define_class_under(module, "Match3Node", rb_cObject);
+}

data/ext/kanayago/string_node.h

@@ -0,0 +1,19 @@
+#ifndef KANAYAGO_STRING_NODE_H
+#define KANAYAGO_STRING_NODE_H
+
+#include "kanayago.h"
+
+VALUE dynamic_string_node_new(const NODE*);
+VALUE dynamic_symbol_node_new(const NODE*);
+VALUE embedded_expression_string_node_new(const NODE *);
+VALUE execute_string_node_new(const NODE *);
+VALUE dynamic_execute_string_node_new(const NODE *);
+VALUE regexp_node_new(const NODE *);
+VALUE dynamic_regexp_node_new(const NODE *);
+VALUE match_node_new(const NODE *);
+VALUE match2_node_new(const NODE *);
+VALUE match3_node_new(const NODE *);
+
+void Init_StringNode(VALUE);
+
+#endif

data/ext/kanayago/symbol.h

@@ -39,7 +39,7 @@ struct RSymbol {
 #define is_attrset_id(id) ((id)==idASET||id_type(id)==ID_ATTRSET)
 #define is_const_id(id) (id_type(id)==ID_CONST)
 #define is_class_id(id) (id_type(id)==ID_CLASS)
-#define is_junk_id(id) (id_type(id)==ID_JUNK)
+#define is_internal_id(id) (id_type(id)==ID_INTERNAL)
 
 static inline int
 id_type(ID id)
@@ -58,13 +58,6 @@ static const uint32_t RB_ID_SERIAL_MAX = /* 256M on LP32 */
     ((sizeof(ID)-sizeof(rb_id_serial_t))*CHAR_BIT < RUBY_ID_SCOPE_SHIFT ?
      RUBY_ID_SCOPE_SHIFT : 0);
 
-typedef struct {
-    rb_id_serial_t last_id;
-    st_table *str_sym;
-    VALUE ids;
-    VALUE dsymbol_fstr_hash;
-} rb_symbols_t;
-
 static inline rb_id_serial_t
 rb_id_to_serial(ID id)
 {
@@ -98,7 +91,7 @@ sym_type(VALUE sym)
 #define is_attrset_sym(sym) (sym_type(sym)==ID_ATTRSET)
 #define is_const_sym(sym) (sym_type(sym)==ID_CONST)
 #define is_class_sym(sym) (sym_type(sym)==ID_CLASS)
-#define is_junk_sym(sym) (sym_type(sym)==ID_JUNK)
+#define is_internal_sym(sym) (sym_type(sym)==ID_INTERNAL)
 
 #ifndef RIPPER
 RUBY_FUNC_EXPORTED

data/ext/kanayago/thread_pthread.h

@@ -17,6 +17,11 @@
 #define RB_NATIVETHREAD_LOCK_INIT PTHREAD_MUTEX_INITIALIZER
 #define RB_NATIVETHREAD_COND_INIT PTHREAD_COND_INITIALIZER
 
+// TLS can not be accessed across .so on arm64 and perhaps ppc64le too.
+#if defined(__arm64__) || defined(__aarch64__) || defined(__powerpc64__)
+# define RB_THREAD_CURRENT_EC_NOINLINE
+#endif
+
 // this data should be protected by timer_th.waiting_lock
 struct rb_thread_sched_waiting {
     enum thread_sched_waiting_flag {
@@ -132,10 +137,8 @@ struct rb_thread_sched {
 
 #ifdef RB_THREAD_LOCAL_SPECIFIER
   NOINLINE(void rb_current_ec_set(struct rb_execution_context_struct *));
-  NOINLINE(struct rb_execution_context_struct *rb_current_ec_noinline(void));
 
-  # ifdef __APPLE__
-    // on Darwin, TLS can not be accessed across .so
+  # ifdef RB_THREAD_CURRENT_EC_NOINLINE
     NOINLINE(struct rb_execution_context_struct *rb_current_ec(void));
   # else
     RUBY_EXTERN RB_THREAD_LOCAL_SPECIFIER struct rb_execution_context_struct *ruby_current_ec;
@@ -165,4 +168,8 @@ native_tls_set(native_tls_key_t key, void *ptr)
 RUBY_EXTERN native_tls_key_t ruby_current_ec_key;
 #endif
 
+struct rb_ractor_struct;
+void rb_ractor_sched_wait(struct rb_execution_context_struct *ec, struct rb_ractor_struct *cr, rb_unblock_function_t *ubf, void *ptr);
+void rb_ractor_sched_wakeup(struct rb_ractor_struct *r, struct rb_thread_struct *th);
+
 #endif /* RUBY_THREAD_PTHREAD_H */

data/ext/kanayago/universal_parser.c

@@ -13,7 +13,6 @@
 #include "ruby/backward/2/inttypes.h"
 #include "probes.h"
 
-#define LIKELY(x) RB_LIKELY(x)
 #define UNLIKELY(x) RB_UNLIKELY(x)
 #ifndef TRUE
 # define TRUE    1
@@ -23,13 +22,9 @@
 # define FALSE   0
 #endif
 #define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
-#define rb_strlen_lit(str) (sizeof(str "") - 1)
+#define rb_strlen_lit(str) ((sizeof(str "") / sizeof(str ""[0])) - 1)
 #undef FIXNUM_MAX
 #define FIXNUM_MAX (LONG_MAX / 2)
-#undef RSTRING_GETMEM
-#define RSTRING_GETMEM(str, ptrvar, lenvar) \
-    ((ptrvar) = RSTRING_PTR(str),           \
-     (lenvar) = RSTRING_LEN(str))
 
 /* parser_st */
 #define st_table parser_st_table
@@ -90,8 +85,6 @@
 
 #define rb_attr_get p->config->attr_get
 
-#define rb_ary_new           p->config->ary_new
-#define rb_ary_push          p->config->ary_push
 #undef rb_ary_new_from_args
 #define rb_ary_new_from_args p->config->ary_new_from_args
 #define rb_ary_unshift       p->config->ary_unshift
@@ -113,32 +106,23 @@
 #define rb_id2str                p->config->id2str
 #undef ID2SYM
 #define ID2SYM                   p->config->id2sym
-#undef SYM2ID
-#define SYM2ID                   p->config->sym2id
 
 #define rb_str_catf                       p->config->str_catf
 #undef rb_str_cat_cstr
 #define rb_str_cat_cstr                   p->config->str_cat_cstr
-#define rb_str_modify                     p->config->str_modify
-#define rb_str_set_len                    p->config->str_set_len
-#define rb_str_cat                        p->config->str_cat
 #define rb_str_resize                     p->config->str_resize
 #undef rb_str_new
 #define rb_str_new                        p->config->str_new
 #undef rb_str_new_cstr
 #define rb_str_new_cstr                   p->config->str_new_cstr
 #define rb_str_to_interned_str            p->config->str_to_interned_str
-#define is_ascii_string                   p->config->is_ascii_string
 #define rb_enc_str_new                    p->config->enc_str_new
 #define rb_str_vcatf                      p->config->str_vcatf
 #define rb_sprintf                        p->config->rb_sprintf
 #undef RSTRING_PTR
 #define RSTRING_PTR                       p->config->rstring_ptr
-#undef RSTRING_END
-#define RSTRING_END                       p->config->rstring_end
 #undef RSTRING_LEN
 #define RSTRING_LEN                       p->config->rstring_len
-#define rb_obj_as_string                  p->config->obj_as_string
 
 #undef INT2NUM
 #define INT2NUM             p->config->int2num
@@ -162,7 +146,6 @@
 #define rb_enc_get              p->config->enc_get
 #define rb_enc_asciicompat      p->config->enc_asciicompat
 #define rb_utf8_encoding        p->config->utf8_encoding
-#define rb_enc_associate        p->config->enc_associate
 #define rb_ascii8bit_encoding   p->config->ascii8bit_encoding
 #define rb_enc_codelen          p->config->enc_codelen
 #define rb_enc_mbcput           p->config->enc_mbcput
@@ -171,7 +154,6 @@
 #define rb_enc_isspace          p->config->enc_isspace
 #define ENC_CODERANGE_7BIT      p->config->enc_coderange_7bit
 #define ENC_CODERANGE_UNKNOWN   p->config->enc_coderange_unknown
-#define rb_usascii_encoding     p->config->usascii_encoding
 
 #define rb_local_defined          p->config->local_defined
 #define rb_dvar_defined           p->config->dvar_defined
@@ -182,7 +164,6 @@
 
 #define rb_errinfo p->config->errinfo
 #define rb_set_errinfo p->config->set_errinfo
-#define rb_exc_raise p->config->exc_raise
 #define rb_make_exception p->config->make_exception
 
 #define ruby_sized_xfree p->config->sized_xfree

data/ext/kanayago/variable_node.c

@@ -0,0 +1,72 @@
+#include "internal/ruby_parser.h"
+#include "kanayago.h"
+
+VALUE rb_cLocalVariableNode;
+VALUE rb_cDynamicVariableNode;
+VALUE rb_cInstanceVariableNode;
+VALUE rb_cClassVariableNode;
+VALUE rb_cGlobalVariableNode;
+
+VALUE
+local_variable_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cLocalVariableNode);
+
+    rb_ivar_set(obj, rb_intern("@vid"), ID2SYM(RNODE_LVAR(node)->nd_vid));
+
+    return obj;
+}
+
+VALUE
+dynamic_variable_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cDynamicVariableNode);
+
+    rb_ivar_set(obj, rb_intern("@vid"), ID2SYM(RNODE_DVAR(node)->nd_vid));
+
+    return obj;
+}
+
+VALUE
+instance_variable_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cInstanceVariableNode);
+
+    rb_ivar_set(obj, rb_intern("@vid"), ID2SYM(RNODE_IVAR(node)->nd_vid));
+
+    return obj;
+}
+
+VALUE
+class_variable_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cClassVariableNode);
+
+    rb_ivar_set(obj, rb_intern("@vid"), ID2SYM(RNODE_IVAR(node)->nd_vid));
+
+    return obj;
+}
+
+VALUE
+global_variable_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cGlobalVariableNode);
+
+    rb_ivar_set(obj, rb_intern("@vid"), ID2SYM(RNODE_GVAR(node)->nd_vid));
+
+    return obj;
+}
+
+void
+Init_VariableNode(VALUE module)
+{
+    rb_cLocalVariableNode = rb_define_class_under(module, "LocalVariableNode", rb_cObject);
+
+    rb_cDynamicVariableNode = rb_define_class_under(module, "DynamicVariableNode", rb_cObject);
+
+    rb_cInstanceVariableNode = rb_define_class_under(module, "InstanceVariableNode", rb_cObject);
+
+    rb_cClassVariableNode = rb_define_class_under(module, "ClassVariableNode", rb_cObject);
+
+    rb_cGlobalVariableNode = rb_define_class_under(module, "GlobalVariableNode", rb_cObject);
+}

data/ext/kanayago/variable_node.h

@@ -0,0 +1,12 @@
+#ifndef KANAYAGO_VARIABLE_NODE_H
+#define KANAYAGO_VARIABLE_NODE_H
+#include "kanayago.h"
+
+VALUE local_variable_node_new(const NODE *);
+VALUE dynamic_variable_node_new(const NODE *);
+VALUE instance_variable_node_new(const NODE *);
+VALUE class_variable_node_new(const NODE *);
+VALUE global_variable_node_new(const NODE *);
+
+void Init_VariableNode(VALUE);
+#endif