ruby_tree_sitter 0.20.6.3-x86_64-linux

data/ext/tree_sitter/parser.c

@@ -0,0 +1,203 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cParser;
+
+typedef struct {
+  TSParser *data;
+  size_t cancellation_flag;
+} parser_t;
+
+static void parser_free(void *ptr) {
+  ts_parser_delete(((parser_t *)ptr)->data);
+  xfree(ptr);
+}
+
+static size_t parser_memsize(const void *ptr) {
+  parser_t *type = (parser_t *)ptr;
+  return sizeof(type);
+}
+
+const rb_data_type_t parser_data_type = {
+    .wrap_struct_name = "parser",
+    .function =
+        {
+            .dmark = NULL,
+            .dfree = parser_free,
+            .dsize = parser_memsize,
+            .dcompact = NULL,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+DATA_UNWRAP(parser)
+
+static VALUE parser_allocate(VALUE klass) {
+  parser_t *parser;
+  VALUE res = TypedData_Make_Struct(klass, parser_t, &parser_data_type, parser);
+  parser->data = ts_parser_new();
+  return res;
+}
+
+static VALUE parser_get_language(VALUE self) {
+  return new_language(ts_parser_language(SELF));
+}
+
+static VALUE parser_get_included_ranges(VALUE self) {
+  uint32_t length;
+  const TSRange *ranges = ts_parser_included_ranges(SELF, &length);
+  VALUE res = rb_ary_new_capa(length);
+  for (uint32_t i = 0; i < length; i++) {
+    rb_ary_push(res, new_range(&ranges[i]));
+  }
+  return res;
+}
+
+static VALUE parser_get_timeout_micros(VALUE self) {
+  return ULL2NUM(ts_parser_timeout_micros(SELF));
+}
+
+static VALUE parser_get_logger(VALUE self) {
+  return new_logger_by_val(ts_parser_logger(SELF));
+}
+
+static VALUE parser_get_cancellation_flag(VALUE self) {
+  return SIZET2NUM(*ts_parser_cancellation_flag(SELF));
+}
+
+static VALUE parser_set_language(VALUE self, VALUE language) {
+  return ts_parser_set_language(SELF, value_to_language(language)) ? Qtrue
+                                                                   : Qfalse;
+}
+
+static VALUE parser_set_included_ranges(VALUE self, VALUE array) {
+  Check_Type(array, T_ARRAY);
+
+  long length = rb_array_len(array);
+  TSRange *ranges = (TSRange *)malloc(length * sizeof(TSRange));
+  for (long i = 0; i < length; i++) {
+    ranges[i] = value_to_range(rb_ary_entry(array, i));
+  }
+  bool res = ts_parser_set_included_ranges(SELF, ranges, (uint32_t)length);
+  if (ranges) {
+    free(ranges);
+  }
+  return res ? Qtrue : Qfalse;
+}
+
+static VALUE parser_set_timeout_micros(VALUE self, VALUE timeout) {
+  ts_parser_set_timeout_micros(SELF, NUM2ULL(timeout));
+  return Qnil;
+}
+
+static VALUE parser_set_cancellation_flag(VALUE self, VALUE flag) {
+  unwrap(self)->cancellation_flag = NUM2SIZET(flag);
+  ts_parser_set_cancellation_flag(SELF, &unwrap(self)->cancellation_flag);
+  return Qnil;
+}
+
+static VALUE parser_set_logger(VALUE self, VALUE logger) {
+  ts_parser_set_logger(SELF, value_to_logger(logger));
+  return Qnil;
+}
+
+static VALUE parser_parse(VALUE self, VALUE old_tree, VALUE input) {
+  if (NIL_P(input)) {
+    return Qnil;
+  }
+
+  TSTree *tree = NULL;
+  if (!NIL_P(old_tree)) {
+    tree = value_to_tree(old_tree);
+  }
+
+  TSTree *ret = ts_parser_parse(SELF, tree, value_to_input(input));
+  if (ret == NULL) {
+    return Qnil;
+  } else {
+    return new_tree(ret);
+  }
+}
+
+static VALUE parser_parse_string(VALUE self, VALUE old_tree, VALUE string) {
+  if (NIL_P(string)) {
+    return Qnil;
+  }
+
+  const char *str = StringValuePtr(string);
+  uint32_t len = (uint32_t)RSTRING_LEN(string);
+  TSTree *tree = NULL;
+  if (!NIL_P(old_tree)) {
+    tree = value_to_tree(old_tree);
+  }
+
+  TSTree *ret = ts_parser_parse_string(SELF, tree, str, len);
+  if (ret == NULL) {
+    return Qnil;
+  } else {
+    return new_tree(ret);
+  }
+}
+
+static VALUE parser_parse_string_encoding(VALUE self, VALUE old_tree,
+                                          VALUE string, VALUE encoding) {
+  if (NIL_P(string)) {
+    return Qnil;
+  }
+
+  const char *str = StringValuePtr(string);
+  uint32_t len = (uint32_t)RSTRING_LEN(string);
+  TSTree *tree = NULL;
+  if (!NIL_P(old_tree)) {
+    tree = value_to_tree(old_tree);
+  }
+
+  TSTree *ret = ts_parser_parse_string_encoding(SELF, tree, str, len,
+                                                value_to_encoding(encoding));
+
+  if (ret == NULL) {
+    return Qnil;
+  } else {
+    return new_tree(ret);
+  }
+}
+
+static VALUE parser_reset(VALUE self) {
+  ts_parser_reset(SELF);
+  return Qnil;
+}
+
+static VALUE parser_print_dot_graphs(VALUE self, VALUE file) {
+  if (NIL_P(file)) {
+    ts_parser_print_dot_graphs(SELF, -1);
+  } else if (rb_integer_type_p(file) && NUM2INT(file) < 0) {
+    ts_parser_print_dot_graphs(SELF, NUM2INT(file));
+  } else {
+    Check_Type(file, T_STRING);
+    char *path = StringValueCStr(file);
+    int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC,
+                  0644); // 0644 = all read + user write
+    ts_parser_print_dot_graphs(SELF, fd);
+  }
+  return Qnil;
+}
+
+void init_parser(void) {
+  cParser = rb_define_class_under(mTreeSitter, "Parser", rb_cObject);
+
+  rb_define_alloc_func(cParser, parser_allocate);
+
+  /* Class methods */
+  DECLARE_ACCESSOR(cParser, parser, language)
+  DECLARE_ACCESSOR(cParser, parser, included_ranges)
+  DECLARE_ACCESSOR(cParser, parser, timeout_micros)
+  DECLARE_ACCESSOR(cParser, parser, logger)
+  DECLARE_ACCESSOR(cParser, parser, cancellation_flag)
+  rb_define_method(cParser, "parse", parser_parse, 2);
+  rb_define_method(cParser, "parse_string", parser_parse_string, 2);
+  rb_define_method(cParser, "parse_string_encoding",
+                   parser_parse_string_encoding, 3);
+  rb_define_method(cParser, "reset", parser_reset, 0);
+  rb_define_method(cParser, "print_dot_graphs", parser_print_dot_graphs, 1);
+}

data/ext/tree_sitter/point.c

@@ -0,0 +1,26 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cPoint;
+
+DATA_WRAP(Point, point)
+DATA_DEFINE_ACCESSOR(point, row, UINT2NUM, NUM2UINT)
+DATA_DEFINE_ACCESSOR(point, column, UINT2NUM, NUM2UINT)
+
+static VALUE point_inspect(VALUE self) {
+  point_t *point = unwrap(self);
+  return rb_sprintf("{row=%i, column=%i}", point->data.row, point->data.column);
+}
+
+void init_point(void) {
+  cPoint = rb_define_class_under(mTreeSitter, "Point", rb_cObject);
+
+  rb_define_alloc_func(cPoint, point_allocate);
+
+  /* Class methods */
+  DECLARE_ACCESSOR(cPoint, point, row)
+  DECLARE_ACCESSOR(cPoint, point, column)
+  rb_define_method(cPoint, "inspect", point_inspect, 0);
+  rb_define_method(cPoint, "to_s", point_inspect, 0);
+}

data/ext/tree_sitter/quantifier.c

@@ -0,0 +1,43 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE mQuantifier;
+
+TSQuantifier value_to_quantifier(VALUE quantifier) {
+  return NUM2UINT(quantifier);
+}
+
+const char *quantifier_str(TSQuantifier error) {
+  switch (error) {
+  case TSQuantifierZero:
+    return "Zero";
+  case TSQuantifierZeroOrOne:
+    return "ZeroOrOne";
+  case TSQuantifierZeroOrMore:
+    return "ZeroOrMore";
+  case TSQuantifierOne:
+    return "One";
+  case TSQuantifierOneOrMore:
+    return "OneOrMore";
+  default:
+    return "??";
+  }
+}
+
+static VALUE quantifier_name(VALUE self, VALUE quant) {
+  int q = NUM2UINT(quant);
+  return safe_str(quantifier_str(q));
+}
+
+void init_quantifier(void) {
+  mQuantifier = rb_define_module_under(mTreeSitter, "Quantifier");
+
+  rb_define_module_function(mTreeSitter, "quantifier_name", quantifier_name, 1);
+
+  rb_define_const(mQuantifier, "ZERO", UINT2NUM(0));
+  rb_define_const(mQuantifier, "ZERO_OR_ONE", UINT2NUM(1));
+  rb_define_const(mQuantifier, "ZERO_OR_MORE", UINT2NUM(2));
+  rb_define_const(mQuantifier, "ONE", UINT2NUM(3));
+  rb_define_const(mQuantifier, "ONE_OR_MORE", UINT2NUM(4));
+}

data/ext/tree_sitter/query.c

@@ -0,0 +1,157 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cQuery;
+
+DATA_PTR_WRAP(Query, query);
+
+static VALUE query_initialize(VALUE self, VALUE language, VALUE source) {
+  TSLanguage *lang = value_to_language(language);
+  const char *src = StringValuePtr(source);
+  uint32_t len = (uint32_t)RSTRING_LEN(source);
+  uint32_t error_offset = 0;
+  TSQueryError error_type;
+
+  TSQuery *res = ts_query_new(lang, src, len, &error_offset, &error_type);
+
+  if (res == NULL || error_offset > 0) {
+    rb_raise(rb_eRuntimeError, "Could not create query: TSQueryError%s",
+             query_error_str(error_type));
+  } else {
+    SELF = res;
+  }
+
+  return self;
+}
+
+static VALUE query_pattern_count(VALUE self) {
+  return UINT2NUM(ts_query_pattern_count(SELF));
+}
+
+static VALUE query_capture_count(VALUE self) {
+  return UINT2NUM(ts_query_capture_count(SELF));
+}
+
+static VALUE query_string_count(VALUE self) {
+  return UINT2NUM(ts_query_string_count(SELF));
+}
+
+static VALUE query_start_byte_for_pattern(VALUE self, VALUE pattern_index) {
+  const TSQuery *query = SELF;
+  uint32_t index = NUM2UINT(pattern_index);
+  uint32_t range = ts_query_pattern_count(query);
+
+  if (index >= range) {
+    rb_raise(rb_eIndexError, "Index %d out of range (len = %d)", index, range);
+  } else {
+    return UINT2NUM(ts_query_start_byte_for_pattern(SELF, index));
+  }
+}
+
+static VALUE query_predicates_for_pattern(VALUE self, VALUE pattern_index) {
+  const TSQuery *query = SELF;
+  uint32_t index = NUM2UINT(pattern_index);
+  uint32_t length;
+  const TSQueryPredicateStep *steps =
+      ts_query_predicates_for_pattern(query, index, &length);
+  VALUE res = rb_ary_new_capa(length);
+
+  for (uint32_t i = 0; i < length; i++) {
+    rb_ary_push(res, new_query_predicate_step(&steps[i]));
+  }
+
+  return res;
+}
+
+static VALUE query_pattern_guaranteed_at_step(VALUE self, VALUE byte_offset) {
+  return UINT2NUM(
+      ts_query_is_pattern_guaranteed_at_step(SELF, NUM2UINT(byte_offset)));
+}
+
+static VALUE query_capture_name_for_id(VALUE self, VALUE id) {
+  const TSQuery *query = SELF;
+  uint32_t index = NUM2UINT(id);
+  uint32_t range = ts_query_capture_count(query);
+
+  if (index >= range) {
+    rb_raise(rb_eIndexError, "Index %d out of range (len = %d)", index, range);
+  } else {
+    uint32_t length;
+    const char *name = ts_query_capture_name_for_id(query, index, &length);
+    return safe_str2(name, length);
+  }
+}
+
+static VALUE query_capture_quantifier_for_id(VALUE self, VALUE id,
+                                             VALUE capture_id) {
+  const TSQuery *query = SELF;
+  uint32_t pattern = NUM2UINT(id);
+  uint32_t index = NUM2UINT(capture_id);
+  uint32_t range = ts_query_capture_count(query);
+
+  if (index >= range) {
+    rb_raise(rb_eIndexError, "Capture ID %d out of range (len = %d)", index,
+             range);
+  } else {
+    return UINT2NUM(ts_query_capture_quantifier_for_id(query, pattern, index));
+  }
+}
+
+static VALUE query_string_value_for_id(VALUE self, VALUE id) {
+  const TSQuery *query = SELF;
+  uint32_t index = NUM2UINT(id);
+  uint32_t range = ts_query_string_count(query);
+
+  if (index >= range) {
+    rb_raise(rb_eIndexError, "Index %d out of range (len = %d)", index, range);
+  } else {
+    uint32_t length;
+    const char *string = ts_query_string_value_for_id(query, index, &length);
+    return safe_str2(string, length);
+  }
+}
+
+static VALUE query_disable_capture(VALUE self, VALUE capture) {
+  const char *cap = StringValuePtr(capture);
+  uint32_t length = (uint32_t)RSTRING_LEN(capture);
+  ts_query_disable_capture(SELF, cap, length);
+  return Qnil;
+}
+
+static VALUE query_disable_pattern(VALUE self, VALUE pattern) {
+  TSQuery *query = SELF;
+  uint32_t index = NUM2UINT(pattern);
+  uint32_t range = ts_query_pattern_count(query);
+
+  if (index >= range) {
+    rb_raise(rb_eIndexError, "Index %d out of range (len = %d)", index, range);
+  } else {
+    ts_query_disable_pattern(query, index);
+    return Qnil;
+  }
+}
+
+void init_query(void) {
+  cQuery = rb_define_class_under(mTreeSitter, "Query", rb_cObject);
+
+  rb_define_alloc_func(cQuery, query_allocate);
+
+  /* Class methods */
+  rb_define_method(cQuery, "initialize", query_initialize, 2);
+  rb_define_method(cQuery, "pattern_count", query_pattern_count, 0);
+  rb_define_method(cQuery, "capture_count", query_capture_count, 0);
+  rb_define_method(cQuery, "string_count", query_string_count, 0);
+  rb_define_method(cQuery, "start_byte_for_pattern",
+                   query_start_byte_for_pattern, 1);
+  rb_define_method(cQuery, "predicates_for_pattern",
+                   query_predicates_for_pattern, 1);
+  rb_define_method(cQuery, "pattern_guaranteed_at_step?",
+                   query_pattern_guaranteed_at_step, 1);
+  rb_define_method(cQuery, "capture_name_for_id", query_capture_name_for_id, 1);
+  rb_define_method(cQuery, "capture_quantifier_for_id",
+                   query_capture_quantifier_for_id, 2);
+  rb_define_method(cQuery, "string_value_for_id", query_string_value_for_id, 1);
+  rb_define_method(cQuery, "disable_capture", query_disable_capture, 1);
+  rb_define_method(cQuery, "disable_pattern", query_disable_pattern, 1);
+}

data/ext/tree_sitter/query_capture.c

@@ -0,0 +1,28 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cQueryCapture;
+
+DATA_WRAP(QueryCapture, query_capture)
+DATA_DEFINE_GETTER(query_capture, index, UINT2NUM)
+DATA_DEFINE_GETTER(query_capture, node, new_node_by_val)
+
+static VALUE query_capture_inspect(VALUE self) {
+  TSQueryCapture query_capture = SELF;
+  return rb_sprintf("{index=%d, node=%+" PRIsVALUE "}", query_capture.index,
+                    new_node(&query_capture.node));
+}
+
+void init_query_capture(void) {
+  cQueryCapture =
+      rb_define_class_under(mTreeSitter, "QueryCapture", rb_cObject);
+
+  rb_define_alloc_func(cQueryCapture, query_capture_allocate);
+
+  /* Class methods */
+  DECLARE_GETTER(cQueryCapture, query_capture, index)
+  DECLARE_GETTER(cQueryCapture, query_capture, node)
+  rb_define_method(cQueryCapture, "inspect", query_capture_inspect, 0);
+  rb_define_method(cQueryCapture, "to_s", query_capture_inspect, 0);
+}

data/ext/tree_sitter/query_cursor.c

@@ -0,0 +1,103 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cQueryCursor;
+
+DATA_TYPE(TSQueryCursor *, query_cursor)
+DATA_FREE_PTR(query_cursor)
+DATA_MEMSIZE(query_cursor)
+DATA_DECLARE_DATA_TYPE(query_cursor)
+static VALUE query_cursor_allocate(VALUE klass) {
+  query_cursor_t *query_cursor;
+  VALUE res = TypedData_Make_Struct(klass, query_cursor_t,
+                                    &query_cursor_data_type, query_cursor);
+  query_cursor->data = ts_query_cursor_new();
+  return res;
+}
+DATA_UNWRAP(query_cursor)
+DATA_PTR_NEW(cQueryCursor, TSQueryCursor, query_cursor)
+DATA_FROM_VALUE(TSQueryCursor *, query_cursor)
+
+static VALUE query_cursor_exec(VALUE self, VALUE query, VALUE node) {
+  VALUE res = query_cursor_allocate(cQueryCursor);
+  query_cursor_t *query_cursor = unwrap(res);
+  ts_query_cursor_exec(query_cursor->data, value_to_query(query),
+                       value_to_node(node));
+  return res;
+}
+
+static VALUE query_cursor_did_exceed_match_limit(VALUE self) {
+  return ts_query_cursor_did_exceed_match_limit(SELF) ? Qtrue : Qfalse;
+}
+
+static VALUE query_cursor_get_match_limit(VALUE self) {
+  return UINT2NUM(ts_query_cursor_match_limit(SELF));
+}
+
+static VALUE query_cursor_set_match_limit(VALUE self, VALUE limit) {
+  ts_query_cursor_set_match_limit(SELF, NUM2UINT(limit));
+  return Qnil;
+}
+
+static VALUE query_cursor_set_byte_range(VALUE self, VALUE from, VALUE to) {
+  ts_query_cursor_set_byte_range(SELF, NUM2UINT(from), NUM2UINT(to));
+  return Qnil;
+}
+
+static VALUE query_cursor_set_point_range(VALUE self, VALUE from, VALUE to) {
+  ts_query_cursor_set_point_range(SELF, value_to_point(from),
+                                  value_to_point(to));
+  return Qnil;
+}
+
+static VALUE query_cursor_next_match(VALUE self) {
+  TSQueryMatch match;
+  if (ts_query_cursor_next_match(SELF, &match)) {
+    return new_query_match(&match);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE query_cursor_remove_match(VALUE self, VALUE id) {
+  ts_query_cursor_remove_match(SELF, NUM2UINT(id));
+  return Qnil;
+}
+
+// NOTE: maybe this is the limit of how "transparent" the bindings need to be.
+// Pending benchmarks, this can be very inefficient because obviously
+// ts_query_cursor_next_capture is intended to be used in a loop.  Creating an
+// array of two values and returning them, intuitively speaking, seem very
+// inefficient.
+static VALUE query_cursor_next_capture(VALUE self) {
+  TSQueryMatch match;
+  uint32_t index;
+  if (ts_query_cursor_next_capture(SELF, &match, &index)) {
+    VALUE res = rb_ary_new_capa(2);
+    rb_ary_push(res, UINT2NUM(index));
+    rb_ary_push(res, new_query_match(&match));
+    return res;
+  } else {
+    return Qnil;
+  }
+}
+
+void init_query_cursor(void) {
+  cQueryCursor = rb_define_class_under(mTreeSitter, "QueryCursor", rb_cObject);
+
+  rb_define_alloc_func(cQueryCursor, query_cursor_allocate);
+
+  /* Class methods */
+  DECLARE_ACCESSOR(cQueryCursor, query_cursor, match_limit)
+  rb_define_module_function(cQueryCursor, "exec", query_cursor_exec, 2);
+  rb_define_method(cQueryCursor, "exceed_match_limit?",
+                   query_cursor_did_exceed_match_limit, 0);
+  rb_define_method(cQueryCursor, "set_byte_range", query_cursor_set_byte_range,
+                   2);
+  rb_define_method(cQueryCursor, "set_point_range",
+                   query_cursor_set_point_range, 2);
+  rb_define_method(cQueryCursor, "next_match", query_cursor_next_match, 0);
+  rb_define_method(cQueryCursor, "remove_match", query_cursor_remove_match, 1);
+  rb_define_method(cQueryCursor, "next_capture", query_cursor_next_capture, 0);
+}

data/ext/tree_sitter/query_error.c

@@ -0,0 +1,41 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE mQueryError;
+
+TSQueryError value_to_query_error(VALUE query_error) {
+  return NUM2UINT(query_error);
+}
+
+const char *query_error_str(TSQueryError error) {
+  switch (error) {
+  case TSQueryErrorNone:
+    return "None";
+  case TSQueryErrorSyntax:
+    return "Syntax";
+  case TSQueryErrorNodeType:
+    return "Node Type";
+  case TSQueryErrorField:
+    return "Field";
+  case TSQueryErrorCapture:
+    return "Capture";
+  case TSQueryErrorStructure:
+    return "Structure";
+  case TSQueryErrorLanguage:
+    return "Language";
+  default:
+    return "??";
+  }
+}
+
+void init_query_error(void) {
+  mQueryError = rb_define_module_under(mTreeSitter, "QueryError");
+  rb_define_const(mQueryError, "NONE", UINT2NUM(0));
+  rb_define_const(mQueryError, "Syntax", UINT2NUM(1));
+  rb_define_const(mQueryError, "NodeType", UINT2NUM(2));
+  rb_define_const(mQueryError, "Field", UINT2NUM(3));
+  rb_define_const(mQueryError, "Capture", UINT2NUM(4));
+  rb_define_const(mQueryError, "Structure", UINT2NUM(5));
+  rb_define_const(mQueryError, "Language", UINT2NUM(6));
+}

data/ext/tree_sitter/query_match.c

@@ -0,0 +1,44 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cQueryMatch;
+
+DATA_WRAP(QueryMatch, query_match)
+DATA_DEFINE_GETTER(query_match, id, UINT2NUM)
+DATA_DEFINE_GETTER(query_match, pattern_index, INT2FIX)
+DATA_DEFINE_GETTER(query_match, capture_count, INT2FIX)
+
+static VALUE query_match_get_captures(VALUE self) {
+  query_match_t *query_match = unwrap(self);
+
+  uint16_t length = query_match->data.capture_count;
+  VALUE res = rb_ary_new_capa(length);
+  const TSQueryCapture *captures = query_match->data.captures;
+  for (int i = 0; i < length; i++) {
+    rb_ary_push(res, new_query_capture(&captures[i]));
+  }
+
+  return res;
+}
+
+static VALUE query_match_inspect(VALUE self) {
+  TSQueryMatch query_match = SELF;
+  return rb_sprintf("{id=%d, pattern_inex=%d, capture_count=%d}",
+                    query_match.id, query_match.pattern_index,
+                    query_match.capture_count);
+}
+
+void init_query_match(void) {
+  cQueryMatch = rb_define_class_under(mTreeSitter, "QueryMatch", rb_cObject);
+
+  rb_define_alloc_func(cQueryMatch, query_match_allocate);
+
+  /* Class methods */
+  DECLARE_GETTER(cQueryMatch, query_match, id)
+  DECLARE_GETTER(cQueryMatch, query_match, pattern_index)
+  DECLARE_GETTER(cQueryMatch, query_match, capture_count)
+  DECLARE_GETTER(cQueryMatch, query_match, captures)
+  rb_define_method(cQueryMatch, "inspect", query_match_inspect, 0);
+  rb_define_method(cQueryMatch, "to_s", query_match_inspect, 0);
+}