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

data/lib/kanayago/literal_node.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Kanayago
+  class IntegerNode
+    attr_reader :val, :minus, :base
+  end
+
+  class FloatNode
+    attr_reader :val, :minus
+  end
+
+  class RationalNode
+    attr_reader :val, :minus, :base, :seen_point
+  end
+
+  class ImaginaryNode
+    attr_reader :val, :minus, :base, :seen_point, :type
+  end
+
+  class StringNode
+    attr_reader :ptr, :len, :enc, :coderange
+  end
+
+  class SymbolNode
+    attr_reader :ptr, :len, :enc, :coderange
+  end
+
+  class ListNode
+    attr_reader :len, :val
+  end
+
+  class ZeroListNode
+    attr_reader :len, :val
+  end
+
+  class FileNode
+    attr_reader :ptr, :len, :enc, :coderange
+  end
+
+  class LineNode
+    attr_reader :lineno
+  end
+
+  class EncodingNode
+    attr_reader :val
+  end
+
+  class NilNode
+    attr_reader :val
+  end
+
+  class TrueNode
+    attr_reader :val
+  end
+
+  class FalseNode
+    attr_reader :val
+  end
+
+  class RangeNode
+    attr_reader :beg, :end
+  end
+
+  class ExclusiveRangeNode
+    attr_reader :beg, :end
+  end
+
+  class FlipFlopNode
+    attr_reader :beg, :end
+  end
+
+  class ExclusiveFlipFlopNode
+    attr_reader :beg, :end
+  end
+
+  class HashNode
+    attr_reader :head, :brace
+  end
+
+  class NthRefNode
+    attr_reader :nth
+  end
+
+  class BackRefNode
+    attr_reader :nth
+  end
+end

data/lib/kanayago/pattern_node.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kanayago
+  class InNode
+    attr_reader :head, :body, :next
+  end
+
+  class ArrayPatternNode
+    attr_reader :pconst, :pre_args, :rest_arg, :post_args
+  end
+
+  class HashPatternNode
+    attr_reader :pconst, :pkwargs, :pkwrestarg
+  end
+
+  class FindPatternNode
+    attr_reader :pconst, :pre_rest_arg, :args, :post_rest_arg
+  end
+end

data/lib/kanayago/statement_node.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Kanayago
+  class IfStatementNode
+    attr_reader :cond, :body, :else
+  end
+
+  class UnlessStatementNode
+    attr_reader :cond, :body, :else
+  end
+
+  class OrNode
+    attr_reader :first, :second
+  end
+
+  class AndNode
+    attr_reader :first, :second
+  end
+
+  class WhileNode
+    attr_reader :state, :cond, :body
+  end
+
+  class UntilNode
+    attr_reader :state, :cond, :body
+  end
+
+  class ForNode
+    attr_reader :iter, :body
+  end
+
+  class AliasNode
+    attr_reader :first, :second
+  end
+
+  class ValiasNode
+    attr_reader :alias, :original
+  end
+
+  class UndefNode
+    attr_reader :undefs
+  end
+
+  class ReturnNode
+    attr_reader :statements
+  end
+
+  class GlobalAssignmentNode
+    attr_reader :id, :value
+  end
+
+  class ClassVariableAssignmentNode
+    attr_reader :id, :value
+  end
+
+  class InstanceAssignmentNode
+    attr_reader :id, :value
+  end
+
+  class LocalAssignmentNode
+    attr_reader :id, :value
+  end
+
+  class SingletonDefinitionNode
+    attr_reader :recv, :mid, :defn
+  end
+
+  class SingletonClassNode
+    attr_reader :recv, :body
+  end
+
+  class AttributeAssignmentNode
+    attr_reader :recv, :mid, :args
+  end
+
+  class SafeCallNode
+    attr_reader :recv, :mid, :args
+  end
+
+  class SuperNode
+    attr_reader :args
+  end
+
+  class ZeroSuperNode # rubocop:disable Lint/EmptyClass
+  end
+
+  class CaseNode
+    attr_reader :head, :body
+  end
+
+  class Case2Node
+    attr_reader :body
+  end
+
+  class Case3Node
+    attr_reader :head, :body
+  end
+
+  class WhenNode
+    attr_reader :head, :body, :next
+  end
+
+  class RetryNode # rubocop:disable Lint/EmptyClass
+  end
+
+  class RedoNode # rubocop:disable Lint/EmptyClass
+  end
+
+  class BreakNode
+    attr_reader :statements
+  end
+
+  class NextNode
+    attr_reader :statements
+  end
+
+  class DefinedNode
+    attr_reader :head
+  end
+
+  class IterNode
+    attr_reader :body, :iter
+  end
+
+  class EnsureNode
+    attr_reader :head, :ensr
+  end
+
+  class RescueNode
+    attr_reader :head, :resq, :else
+  end
+
+  class RescueBodyNode
+    attr_reader :args, :exc_var, :body, :next
+  end
+
+  class OperatorAssignment1Node
+    attr_reader :recv, :mid, :index, :rvalue
+  end
+
+  class OperatorAssignment2Node
+    attr_reader :recv, :value, :vid, :mid
+  end
+
+  class OperatorAssignmentAndNode
+    attr_reader :head, :value
+  end
+
+  class OperatorAssignmentOrNode
+    attr_reader :head, :value
+  end
+
+  class OperatorConstantDeclarationNode
+    attr_reader :head, :value, :aid, :shareability
+  end
+
+  class YieldNode
+    attr_reader :head
+  end
+
+  class LambdaNode
+    attr_reader :body
+  end
+
+  class SplatNode
+    attr_reader :head
+  end
+
+  class BlockPassNode
+    attr_reader :head, :body, :forwarding
+  end
+
+  class ArgsAuxNode
+    attr_reader :pid, :plen, :next
+  end
+
+  class OptArgNode
+    attr_reader :body, :next
+  end
+
+  class KwArgNode
+    attr_reader :body, :next
+  end
+
+  class PostArgNode
+    attr_reader :first, :second
+  end
+
+  class ArgsCatNode
+    attr_reader :head, :body
+  end
+
+  class ArgsPushNode
+    attr_reader :head, :body
+  end
+
+  class ForMasgnNode
+    attr_reader :var
+  end
+
+  class MasgnNode
+    attr_reader :head, :value, :args
+  end
+
+  class DasgnNode
+    attr_reader :vid, :value
+  end
+
+  class OnceNode
+    attr_reader :body
+  end
+
+  class ErrinfoNode # rubocop:disable Lint/EmptyClass
+  end
+
+  class PostexeNode
+    attr_reader :body
+  end
+
+  class ErrorNode # rubocop:disable Lint/EmptyClass
+  end
+end