kanayago 0.1.1 → 0.3.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/pattern_node.c

@@ -0,0 +1,78 @@
+#include "pattern_node.h"
+#include "internal/ruby_parser.h"
+#include "kanayago.h"
+
+VALUE rb_cInNode;
+VALUE rb_cArrayPatternNode;
+VALUE rb_cHashPatternNode;
+VALUE rb_cFindPatternNode;
+
+VALUE
+in_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cInNode);
+
+    rb_ivar_set(obj, rb_intern("@head"), ast_to_node_instance(RNODE_IN(node)->nd_head));
+    rb_ivar_set(obj, rb_intern("@body"), ast_to_node_instance(RNODE_IN(node)->nd_body));
+    rb_ivar_set(obj, rb_intern("@next"), ast_to_node_instance(RNODE_IN(node)->nd_next));
+
+    return obj;
+}
+
+VALUE
+array_pattern_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cArrayPatternNode);
+    NODE *rest_arg = RNODE_ARYPTN(node)->rest_arg;
+
+    rb_ivar_set(obj, rb_intern("@pconst"), ast_to_node_instance(RNODE_ARYPTN(node)->nd_pconst));
+    rb_ivar_set(obj, rb_intern("@pre_args"), ast_to_node_instance(RNODE_ARYPTN(node)->pre_args));
+    // rest_arg can be NODE_SPECIAL_NO_NAME_REST (-1), which should be preserved as a special marker
+    rb_ivar_set(obj, rb_intern("@rest_arg"),
+                (rest_arg == (NODE *)-1) ? INT2FIX(-1) : ast_to_node_instance(rest_arg));
+    rb_ivar_set(obj, rb_intern("@post_args"), ast_to_node_instance(RNODE_ARYPTN(node)->post_args));
+
+    return obj;
+}
+
+VALUE
+hash_pattern_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cHashPatternNode);
+
+    rb_ivar_set(obj, rb_intern("@pconst"), ast_to_node_instance(RNODE_HSHPTN(node)->nd_pconst));
+    rb_ivar_set(obj, rb_intern("@pkwargs"), ast_to_node_instance(RNODE_HSHPTN(node)->nd_pkwargs));
+    rb_ivar_set(obj, rb_intern("@pkwrestarg"), ast_to_node_instance(RNODE_HSHPTN(node)->nd_pkwrestarg));
+
+    return obj;
+}
+
+VALUE
+find_pattern_node_new(const NODE *node)
+{
+    VALUE obj = rb_class_new_instance(0, 0, rb_cFindPatternNode);
+    NODE *pre_rest_arg = RNODE_FNDPTN(node)->pre_rest_arg;
+    NODE *post_rest_arg = RNODE_FNDPTN(node)->post_rest_arg;
+
+    rb_ivar_set(obj, rb_intern("@pconst"), ast_to_node_instance(RNODE_FNDPTN(node)->nd_pconst));
+    // rest args can be NODE_SPECIAL_NO_NAME_REST (-1)
+    rb_ivar_set(obj, rb_intern("@pre_rest_arg"),
+                (pre_rest_arg == (NODE *)-1) ? INT2FIX(-1) : ast_to_node_instance(pre_rest_arg));
+    rb_ivar_set(obj, rb_intern("@args"), ast_to_node_instance(RNODE_FNDPTN(node)->args));
+    rb_ivar_set(obj, rb_intern("@post_rest_arg"),
+                (post_rest_arg == (NODE *)-1) ? INT2FIX(-1) : ast_to_node_instance(post_rest_arg));
+
+    return obj;
+}
+
+void
+Init_PatternNode(VALUE module)
+{
+    rb_cInNode = rb_define_class_under(module, "InNode", rb_cObject);
+
+    rb_cArrayPatternNode = rb_define_class_under(module, "ArrayPatternNode", rb_cObject);
+
+    rb_cHashPatternNode = rb_define_class_under(module, "HashPatternNode", rb_cObject);
+
+    rb_cFindPatternNode = rb_define_class_under(module, "FindPatternNode", rb_cObject);
+}

data/ext/kanayago/pattern_node.h

@@ -0,0 +1,13 @@
+#ifndef KANAYAGO_PATTERN_NODE_H
+#define KANAYAGO_PATTERN_NODE_H
+
+#include "kanayago.h"
+
+VALUE in_node_new(const NODE *);
+VALUE array_pattern_node_new(const NODE *);
+VALUE hash_pattern_node_new(const NODE *);
+VALUE find_pattern_node_new(const NODE *);
+
+void Init_PatternNode(VALUE);
+
+#endif

data/ext/kanayago/scope_node.c

@@ -0,0 +1,34 @@
+#include "kanayago.h"
+
+VALUE rb_cScopeNode;
+
+VALUE
+scope_node_new(const NODE *node)
+{
+    VALUE result = rb_class_new_instance(0, 0, rb_cScopeNode);
+
+    rb_ivar_set(result, symbol("args"), ast_to_node_instance((const NODE *)(RNODE_SCOPE(node)->nd_args)));
+    rb_ivar_set(result, symbol("body"), ast_to_node_instance(RNODE_SCOPE(node)->nd_body));
+
+    return result;
+}
+
+static VALUE
+scope_node_args_get(VALUE self)
+{
+    return rb_ivar_get(self, symbol("args"));
+}
+
+static VALUE
+scope_node_body_get(VALUE self)
+{
+    return rb_ivar_get(self, symbol("body"));
+}
+
+void
+Init_ScopeNode(VALUE module)
+{
+    rb_cScopeNode = rb_define_class_under(module, "ScopeNode", rb_cObject);
+    rb_define_method(rb_cScopeNode, "args", scope_node_args_get, 0);
+    rb_define_method(rb_cScopeNode, "body", scope_node_body_get, 0);
+}

data/ext/kanayago/scope_node.h

@@ -0,0 +1,8 @@
+#ifndef KANAYAGO_SCOPE_NODE_H
+#define KANAYAGO_SCOPE_NODE_H
+
+VALUE scope_node_new(const NODE *);
+void Init_ScopeNode(VALUE);
+
+#endif
+