ruby_tree_sitter 1.6.0-x86-linux-musl

data/ext/tree_sitter/language.c

@@ -0,0 +1,219 @@
+#include "tree_sitter.h"
+#include <dlfcn.h>
+#include <stdint.h>
+#include <stdio.h>
+
+typedef TSLanguage *(tree_sitter_lang)(void);
+const char *tree_sitter_prefix = "tree_sitter_";
+
+extern VALUE mTreeSitter;
+
+VALUE cLanguage;
+
+DATA_TYPE(TSLanguage *, language)
+DATA_FREE(language)
+DATA_MEMSIZE(language)
+DATA_DECLARE_DATA_TYPE(language)
+DATA_ALLOCATE(language)
+DATA_UNWRAP(language)
+
+TSLanguage *value_to_language(VALUE self) { return SELF; }
+
+VALUE new_language(const TSLanguage *language) {
+  VALUE res = language_allocate(cLanguage);
+  unwrap(res)->data = (TSLanguage *)language;
+  return res;
+}
+
+/**
+ * Load a language parser from disk.
+ *
+ * @raise [RuntimeError] if the parser was not found, or if it's incompatible
+ * with this gem.
+ *
+ * @param name [String] the parser's name.
+ * @param path [String, Pathname] the parser's shared library (so, dylib) path on disk.
+ *
+ * @return [Language]
+ */
+static VALUE language_load(VALUE self, VALUE name, VALUE path) {
+  VALUE path_s = rb_funcall(path, rb_intern("to_s"), 0);
+  char *path_cstr = StringValueCStr(path_s);
+  void *lib = dlopen(path_cstr, RTLD_NOW);
+  const char *err = dlerror();
+  if (err != NULL) {
+    rb_raise(rb_eRuntimeError,
+             "Could not load shared library `%s'.\nReason: %s", path_cstr, err);
+  }
+
+  char buf[256];
+  snprintf(buf, sizeof(buf), "tree_sitter_%s", StringValueCStr(name));
+  tree_sitter_lang *make_ts_language = dlsym(lib, buf);
+  err = dlerror();
+  if (err != NULL) {
+    dlclose(lib);
+    rb_raise(rb_eRuntimeError,
+             "Could not load symbol `%s' from library `%s'.\nReason:%s",
+             StringValueCStr(name), path_cstr, err);
+  }
+
+  TSLanguage *lang = make_ts_language();
+  if (lang == NULL) {
+    dlclose(lib);
+    rb_raise(rb_eRuntimeError,
+             "TSLanguage = NULL for language `%s' in library `%s'.\nCall your "
+             "local TSLanguage supplier.",
+             StringValueCStr(name), path_cstr);
+  }
+
+  uint32_t version = ts_language_version(lang);
+  if (version < TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION) {
+    rb_raise(rb_eRuntimeError,
+             "Language %s (v%d) from `%s' is old.\nMinimum supported ABI: "
+             "v%d.\nCurrent ABI: v%d.",
+             StringValueCStr(name), version, path_cstr,
+             TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION,
+             TREE_SITTER_LANGUAGE_VERSION);
+  }
+
+  return new_language(lang);
+}
+
+static VALUE language_equal(VALUE self, VALUE other) {
+  TSLanguage *this = SELF;
+  TSLanguage *that = unwrap(other)->data;
+  return this == that ? Qtrue : Qfalse;
+}
+
+/**
+ * Get the number of distinct field names in the language.
+ *
+ * @return [Integer]
+ */
+static VALUE language_field_count(VALUE self) {
+  return UINT2NUM(ts_language_field_count(SELF));
+}
+
+/**
+ * Get the numerical id for the given field name string.
+ *
+ * @param name [String]
+ *
+ * @return [Integer]
+ */
+static VALUE language_field_id_for_name(VALUE self, VALUE name) {
+  TSLanguage *language = SELF;
+  const char *str = StringValuePtr(name);
+  uint32_t length = (uint32_t)RSTRING_LEN(name);
+  return UINT2NUM(ts_language_field_id_for_name(language, str, length));
+}
+
+/**
+ * Get the field name string for the given numerical id.
+ *
+ * @param field_id [Integer]
+ *
+ * @return [String]
+ */
+static VALUE language_field_name_for_id(VALUE self, VALUE field_id) {
+  return safe_str(ts_language_field_name_for_id(SELF, NUM2UINT(field_id)));
+}
+
+/**
+ * Get the next parse state. Combine this with lookahead iterators to generate
+ * completion suggestions or valid symbols in error nodes. Use
+ * {Node#grammar_symbol} for valid symbols.
+ */
+static VALUE language_next_state(VALUE self, VALUE state, VALUE symbol) {
+  uint16_t sta = (uint16_t)NUM2UINT(state);
+  uint16_t sym = (uint16_t)NUM2UINT(symbol);
+  return UINT2NUM(ts_language_next_state(SELF, sta, sym));
+}
+
+/**
+ * Get the number of distinct node types in the language.
+ *
+ * @return [Integer]
+ */
+static VALUE language_symbol_count(VALUE self) {
+  return UINT2NUM(ts_language_symbol_count(SELF));
+}
+
+/**
+ * Get a node type string for the given numerical id.
+ *
+ * @param symbol [Integer]
+ *
+ * @return [String]
+ */
+static VALUE language_symbol_name(VALUE self, VALUE symbol) {
+  return safe_str(ts_language_symbol_name(SELF, NUM2UINT(symbol)));
+}
+
+/**
+ * Get the numerical id for the given node type string.
+ *
+ * @param string   [Symbol]
+ * @param is_named [Boolean]
+ *
+ * @return [Integer]
+ */
+static VALUE language_symbol_for_name(VALUE self, VALUE string,
+                                      VALUE is_named) {
+  const char *str = rb_id2name(SYM2ID(string));
+  uint32_t length = (uint32_t)strlen(str);
+  bool named = RTEST(is_named);
+  return UINT2NUM(ts_language_symbol_for_name(SELF, str, length, named));
+}
+
+/**
+ * Check whether the given node type id belongs to named nodes, anonymous nodes,
+ * or a hidden nodes.
+ *
+ * Hidden nodes are never returned from the API.
+ *
+ * @see Node#named?
+ *
+ * @param symbol [Integer]
+ *
+ * @return [SymbolType]
+ */
+static VALUE language_symbol_type(VALUE self, VALUE symbol) {
+  return new_symbol_type(ts_language_symbol_type(SELF, NUM2UINT(symbol)));
+}
+
+/**
+ * Get the ABI version number for this language. This version number is used
+ * to ensure that languages were generated by a compatible version of
+ * Tree-sitter.
+ *
+ * @see Parser#language=
+ */
+static VALUE language_version(VALUE self) {
+  return UINT2NUM(ts_language_version(SELF));
+}
+
+void init_language(void) {
+  cLanguage = rb_define_class_under(mTreeSitter, "Language", rb_cObject);
+
+  rb_define_alloc_func(cLanguage, language_allocate);
+
+  /* Module methods */
+  rb_define_module_function(cLanguage, "load", language_load, 2);
+
+  /* Operators */
+  rb_define_method(cLanguage, "==", language_equal, 1);
+
+  /* Class methods */
+  rb_define_method(cLanguage, "field_count", language_field_count, 0);
+  rb_define_method(cLanguage, "field_id_for_name", language_field_id_for_name,
+                   1);
+  rb_define_method(cLanguage, "field_name_for_id", language_field_name_for_id,
+                   1);
+  rb_define_method(cLanguage, "next_state", language_next_state, 2);
+  rb_define_method(cLanguage, "symbol_count", language_symbol_count, 0);
+  rb_define_method(cLanguage, "symbol_for_name", language_symbol_for_name, 2);
+  rb_define_method(cLanguage, "symbol_name", language_symbol_name, 1);
+  rb_define_method(cLanguage, "symbol_type", language_symbol_type, 1);
+  rb_define_method(cLanguage, "version", language_version, 0);
+}

data/ext/tree_sitter/logger.c

@@ -0,0 +1,228 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cLogger;
+
+// This type is layed out in the DATA_* style.
+// data: the TSLogger object
+// payload: what will be used in TSLogger.log()
+//          therefore: data.payload = payload
+// format: optional formatting string. Passed to "printf" if it exists
+typedef struct {
+  TSLogger data;
+  VALUE payload;
+  VALUE format;
+} logger_t;
+
+static const char *logger_log_type_str(TSLogType log_type) {
+  switch (log_type) {
+  case TSLogTypeParse:
+    return "Parse:";
+  case TSLogTypeLex:
+    return "Lex  :";
+  default:
+    return "?????:";
+  }
+}
+
+static void logger_log_printf(void *ptr, TSLogType log_type,
+                              const char *message) {
+  logger_t *logger = (logger_t *)ptr;
+  VALUE type = safe_str(logger_log_type_str(log_type));
+  VALUE msg = safe_str(message);
+  rb_funcall(logger->payload, rb_intern("printf"), 3, logger->format, type,
+             msg);
+}
+
+static void logger_log_puts(void *ptr, TSLogType log_type,
+                            const char *message) {
+  logger_t *logger = (logger_t *)ptr;
+  const char *format =
+      NIL_P(logger->format) ? "%s %s" : StringValueCStr(logger->format);
+  VALUE str = rb_sprintf(format, logger_log_type_str(log_type), message);
+  rb_funcall(logger->payload, rb_intern("puts"), 1, str);
+}
+
+static void logger_log_write(void *ptr, TSLogType log_type,
+                             const char *message) {
+  logger_t *logger = (logger_t *)ptr;
+  const char *format =
+      NIL_P(logger->format) ? "%s %s\n" : StringValueCStr(logger->format);
+  VALUE str = rb_sprintf(format, logger_log_type_str(log_type), message);
+  rb_funcall(logger->payload, rb_intern("write"), 1, str);
+}
+
+static void logger_payload_set(logger_t *logger, VALUE value) {
+  logger->payload = value;
+  logger->data.payload = (void *)logger;
+
+  if (!NIL_P(logger->format) && !NIL_P(logger->payload)) {
+    if (rb_respond_to(logger->payload, rb_intern("printf"))) {
+      logger->data.log = logger_log_printf;
+    } else if (rb_respond_to(logger->payload, rb_intern("puts"))) {
+      logger->data.log = logger_log_puts;
+    } else {
+      logger->data.log = logger_log_write;
+    }
+  } else if (!NIL_P(logger->payload)) {
+    logger->data.log = logger_log_write;
+  }
+}
+
+static void logger_free(void *ptr) { xfree(ptr); }
+
+static size_t logger_memsize(const void *ptr) {
+  logger_t *type = (logger_t *)ptr;
+  return sizeof(type);
+}
+
+static void logger_mark(void *ptr) {
+  logger_t *logger = (logger_t *)ptr;
+  rb_gc_mark_movable(logger->payload);
+  // we don't want format to move because its reference will be
+  // consumed by the parser.
+  //
+  // No funny things please.
+  rb_gc_mark(logger->format);
+}
+
+static void logger_compact(void *ptr) {
+  logger_t *logger = (logger_t *)ptr;
+  logger->payload = rb_gc_location(logger->payload);
+}
+
+const rb_data_type_t logger_data_type = {
+    .wrap_struct_name = "logger",
+    .function =
+        {
+            .dmark = logger_mark,
+            .dfree = logger_free,
+            .dsize = logger_memsize,
+            .dcompact = logger_compact,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+DATA_UNWRAP(logger)
+
+static VALUE logger_allocate(VALUE klass) {
+  logger_t *logger;
+  return TypedData_Make_Struct(klass, logger_t, &logger_data_type, logger);
+}
+
+VALUE new_logger(const TSLogger *ptr) {
+  if (ptr != NULL) {
+    VALUE res = logger_allocate(cLogger);
+    logger_t *logger = unwrap(res);
+
+    logger->data.payload = logger;
+
+    VALUE payload = Qnil;
+    VALUE format = Qnil;
+    if (ptr->payload != NULL) {
+      logger_t *old_logger = (logger_t *)ptr->payload;
+      payload = old_logger->payload;
+      format = old_logger->format;
+    }
+    logger_payload_set(logger, payload);
+    logger->format = format;
+
+    return res;
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE new_logger_by_val(TSLogger val) { return new_logger(&val); }
+
+TSLogger value_to_logger(VALUE self) { return SELF; }
+
+static void logger_initialize_stderr(logger_t *logger) {
+  VALUE stderr = rb_gv_get("$stderr");
+  if (!NIL_P(stderr)) {
+    logger_payload_set(logger, stderr);
+  } else {
+    logger_payload_set(logger, Qnil);
+  }
+}
+
+/**
+ * Create a new logger.
+ *
+ * By default, it logs to stderr.
+ *
+ * You can provide your proper backend. You have to make sure that it
+ * exposes a +printf+, +puts+, or +write+ (lookup is done in that specific
+ * order). {::StringIO} is a perfect candidate.
+ *
+ * You can also provide a format ({::String}) if your backend supports a +printf+.
+ *
+ * @example
+ *   backend = StringIO.new
+ *   parser.logger = TreeSitter::Logger.new(backend)
+ *
+ * @param args [Array] The first argument is always a backend. The second
+ *                     argument is the format.
+ */
+static VALUE logger_initialize(int argc, VALUE *argv, VALUE self) {
+  // TODO:
+  // For now, we only take:
+  //   argv[0] = stream
+  //   argv[1] = format : String
+  // We need to add support for argv[1] : lambda/block
+  //   case argv[1]
+  //   in lambda => lambda
+  //   in String => puts || printf || write
+  //   else      => write
+  //   end
+  logger_t *logger = unwrap(self);
+
+  VALUE payload;
+  VALUE format;
+  rb_scan_args(argc, argv, "02", &payload, &format);
+
+  logger->format = format;
+
+  if (argc == 0) {
+    logger_initialize_stderr(logger);
+  } else {
+    logger_payload_set(logger, payload);
+  }
+
+  return self;
+}
+
+static VALUE logger_inspect(VALUE self) {
+  logger_t *logger = unwrap(self);
+  return rb_sprintf("{payload=%+" PRIsVALUE ", format=%+" PRIsVALUE "}",
+                    logger->payload, logger->format);
+}
+
+DATA_FAST_FORWARD_FNV(logger, write, payload)
+DATA_FAST_FORWARD_FNV(logger, puts, payload)
+DATA_FAST_FORWARD_FNV(logger, printf, payload)
+
+DEFINE_ACCESSOR(logger, format)
+DEFINE_GETTER(logger, payload)
+
+static VALUE logger_set_payload(VALUE self, VALUE payload) {
+  logger_payload_set(unwrap(self), payload);
+  return Qnil;
+}
+
+void init_logger(void) {
+  cLogger = rb_define_class_under(mTreeSitter, "Logger", rb_cObject);
+
+  rb_define_alloc_func(cLogger, logger_allocate);
+
+  /* Class methods */
+  rb_define_method(cLogger, "initialize", logger_initialize, -1);
+  DECLARE_ACCESSOR(cLogger, logger, format)
+  DECLARE_ACCESSOR(cLogger, logger, payload)
+  rb_define_method(cLogger, "write", logger_write, -1);
+  rb_define_method(cLogger, "puts", logger_puts, -1);
+  rb_define_method(cLogger, "printf", logger_printf, -1);
+  rb_define_method(cLogger, "inspect", logger_inspect, 0);
+  rb_define_method(cLogger, "to_s", logger_inspect, 0);
+}

data/ext/tree_sitter/macros.h

@@ -0,0 +1,163 @@
+#ifndef _RB_TREE_SITTER_MACROS_H
+#define _RB_TREE_SITTER_MACROS_H
+
+#define DECLARE_GETTER(klass, type, field)                                     \
+  rb_define_method(klass, #field, type##_get_##field, 0);
+
+#define DECLARE_SETTER(klass, type, field)                                     \
+  rb_define_method(klass, #field "=", type##_set_##field, 1);
+
+#define DECLARE_ACCESSOR(klass, type, field)                                   \
+  DECLARE_GETTER(klass, type, field)                                           \
+  DECLARE_SETTER(klass, type, field)
+
+// Plain DEFINE_GETTER/DEFINE_SETTER/etc are for TypedData structs, reaching
+// their top-level fields, and are of type VALUE
+//
+// DATA_* are for TypeData structs, raching their data field
+// which can be of an arbitraty tuype.
+
+#define DEFINE_GETTER(type, field)                                             \
+  static VALUE type##_get_##field(VALUE self) { return (unwrap(self))->field; }
+
+#define DEFINE_SETTER(type, field)                                             \
+  static VALUE type##_set_##field(VALUE self, VALUE val) {                     \
+    unwrap(self)->field = val;                                                 \
+    return Qnil;                                                               \
+  }
+
+#define DEFINE_ACCESSOR(type, field)                                           \
+  DEFINE_GETTER(type, field)                                                   \
+  DEFINE_SETTER(type, field)
+
+#define DATA_WRAP(base, type)                                                  \
+  DATA_TYPE(TS##base, type)                                                    \
+  DATA_FREE(type)                                                              \
+  DATA_MEMSIZE(type)                                                           \
+  DATA_DECLARE_DATA_TYPE(type)                                                 \
+  DATA_ALLOCATE(type)                                                          \
+  DATA_UNWRAP(type)                                                            \
+  DATA_NEW(c##base, TS##base, type)                                            \
+  DATA_FROM_VALUE(TS##base, type)
+
+#define DATA_PTR_WRAP(base, type)                                              \
+  DATA_TYPE(TS##base *, type)                                                  \
+  DATA_FREE_PTR(type)                                                          \
+  DATA_MEMSIZE(type)                                                           \
+  DATA_DECLARE_DATA_TYPE(type)                                                 \
+  DATA_ALLOCATE(type)                                                          \
+  DATA_UNWRAP(type)                                                            \
+  DATA_PTR_NEW(c##base, TS##base, type)                                        \
+  DATA_FROM_VALUE(TS##base *, type)
+
+#define DATA_TYPE(klass, type)                                                 \
+  typedef struct {                                                             \
+    klass data;                                                                \
+  } type##_t;
+
+#define DATA_FREE(type)                                                        \
+  static void type##_free(void *ptr) { xfree(ptr); }
+
+#define DATA_FREE_PTR(type)                                                    \
+  static void type##_free(void *ptr) {                                         \
+    type##_t *type = (type##_t *)ptr;                                          \
+    if (type->data != NULL) {                                                  \
+      ts_##type##_delete(type->data);                                          \
+    }                                                                          \
+    xfree(ptr);                                                                \
+  }
+
+#define DATA_MEMSIZE(type)                                                     \
+  static size_t type##_memsize(const void *ptr) {                              \
+    type##_t *type = (type##_t *)ptr;                                          \
+    return sizeof(type);                                                       \
+  }
+
+#define DATA_DECLARE_DATA_TYPE(type)                                           \
+  const rb_data_type_t type##_data_type = {                                    \
+      .wrap_struct_name = #type "",                                            \
+      .function =                                                              \
+          {                                                                    \
+              .dmark = NULL,                                                   \
+              .dfree = type##_free,                                            \
+              .dsize = type##_memsize,                                         \
+              .dcompact = NULL,                                                \
+          },                                                                   \
+      .flags = RUBY_TYPED_FREE_IMMEDIATELY,                                    \
+  };
+
+#define DATA_ALLOCATE(type)                                                    \
+  static VALUE type##_allocate(VALUE klass) {                                  \
+    type##_t *type;                                                            \
+    return TypedData_Make_Struct(klass, type##_t, &type##_data_type, type);    \
+  }
+
+#define DATA_UNWRAP(type)                                                      \
+  static type##_t *unwrap(VALUE self) {                                        \
+    type##_t *type;                                                            \
+    TypedData_Get_Struct(self, type##_t, &type##_data_type, type);             \
+    return type;                                                               \
+  }
+
+#define SELF unwrap(self)->data
+
+#define DATA_NEW(klass, struct, type)                                          \
+  VALUE new_##type(const struct *ptr) {                                        \
+    if (ptr == NULL) {                                                         \
+      return Qnil;                                                             \
+    }                                                                          \
+    VALUE res = type##_allocate(klass);                                        \
+    type##_t *type = unwrap(res);                                              \
+    type->data = *ptr;                                                         \
+    return res;                                                                \
+  }                                                                            \
+  VALUE new_##type##_by_val(struct ptr) {                                      \
+    VALUE res = type##_allocate(klass);                                        \
+    type##_t *type = unwrap(res);                                              \
+    type->data = ptr;                                                          \
+    return res;                                                                \
+  }
+
+#define DATA_FROM_VALUE(struct, type)                                          \
+  struct value_to_##type(VALUE self) {                                         \
+    return (unwrap(self))->data;                                               \
+  }
+
+#define DATA_PTR_NEW(klass, struct, type)                                      \
+  VALUE new_##type(struct *ptr) {                                              \
+    if (ptr == NULL) {                                                         \
+      return Qnil;                                                             \
+    }                                                                          \
+    VALUE res = type##_allocate(klass);                                        \
+    type##_t *type = unwrap(res);                                              \
+    type->data = ptr;                                                          \
+    return res;                                                                \
+  }
+
+#define DATA_DEFINE_GETTER(type, field, cast)                                  \
+  static VALUE type##_get_##field(VALUE self) {                                \
+    return cast((unwrap(self))->data.field);                                   \
+  }
+
+#define DATA_DEFINE_SETTER(type, field, cast)                                  \
+  static VALUE type##_set_##field(VALUE self, VALUE val) {                     \
+    type##_t *type = unwrap(self);                                             \
+    type->data.field = cast(val);                                              \
+    return Qnil;                                                               \
+  }
+
+#define DATA_DEFINE_ACCESSOR(type, field, cast_get, cast_set)                  \
+  DATA_DEFINE_GETTER(type, field, cast_get)                                    \
+  DATA_DEFINE_SETTER(type, field, cast_set)
+
+#define DATA_FAST_FORWARD_FNV(type, fn, field)                                 \
+  static VALUE type##_##fn(int argc, VALUE *argv, VALUE self) {                \
+    type##_t *type = unwrap(self);                                             \
+    if (!NIL_P(type->field)) {                                                 \
+      return rb_funcallv(type->field, rb_intern(#fn ""), argc, argv);          \
+    } else {                                                                   \
+      return Qnil;                                                             \
+    }                                                                          \
+  }
+
+#endif