racer-rb 0.1.0

data/ext/racer/racer.hh

@@ -0,0 +1,37 @@
+#ifndef RACER_H
+#define RACER_H 1
+
+#include "ruby.h"
+#include "ruby/ruby.h"
+#include "ruby/debug.h"
+#include "ruby/re.h"
+#include "pthread.h"
+#include "worker.hh"
+#include "tiny_queue.hh"
+#include "traces.hh"
+
+struct reg_onig_search_args {
+  long pos;
+  long range;
+};
+
+// Copied from ruby/re.c because the function is not exported in re.h
+static OnigPosition
+reg_onig_search(regex_t *reg, VALUE str, struct re_registers *regs, void *args_ptr)
+{
+    struct reg_onig_search_args *args = (struct reg_onig_search_args *)args_ptr;
+    const char *ptr;
+    long len;
+    RSTRING_GETMEM(str, ptr, len);
+
+    return onig_search(
+        reg,
+        (UChar *)ptr,
+        (UChar *)(ptr + len),
+        (UChar *)(ptr + args->pos),
+        (UChar *)(ptr + args->range),
+        regs,
+        ONIG_OPTION_NONE);
+}
+
+#endif /* RACER_H */

data/ext/racer/tiny_queue.cc

@@ -0,0 +1,103 @@
+#include "tiny_queue.hh"
+
+// Create a queue, return a pointer to tiny_queue_t or NULL on error
+tiny_queue_t *tiny_queue_create()
+{
+  struct tiny_queue_t *queue = (struct tiny_queue_t *)malloc(sizeof(struct tiny_queue_t));
+
+  if (queue == nullptr)
+  {
+    return nullptr;
+  }
+
+  queue->head = nullptr;
+  queue->tail = nullptr;
+
+  if (pthread_mutex_init(&queue->mutex, nullptr) == 0 &&
+      pthread_cond_init(&queue->wakeup, nullptr) == 0)
+  {
+    return queue;
+  }
+
+  free(queue);
+  return nullptr;
+}
+
+// Push a pointer onto the queue, return -1 on error
+int tiny_queue_push(tiny_queue_t *queue, tiny_queue_message_t *x)
+{
+  struct tiny_linked_list_t *new_node = (struct tiny_linked_list_t *)malloc(sizeof(struct tiny_linked_list_t));
+
+  if (new_node == nullptr)
+  {
+    return -1;
+  }
+
+  new_node->data = x;
+  new_node->next = nullptr;
+
+  pthread_mutex_lock(&queue->mutex);
+  if (queue->head == nullptr && queue->tail == nullptr)
+  {
+    queue->head = queue->tail = new_node;
+  }
+  else
+  {
+    queue->tail->next = new_node;
+    queue->tail = new_node;
+  }
+  pthread_mutex_unlock(&queue->mutex);
+  pthread_cond_signal(&queue->wakeup);
+
+  return 0;
+}
+
+// Pop a pointer from the queue
+void *tiny_queue_pop(tiny_queue_t *queue)
+{
+  pthread_mutex_lock(&queue->mutex);
+  while (queue->head == nullptr)
+  { // block if buffer is empty
+    pthread_cond_wait(&queue->wakeup, &queue->mutex);
+  }
+
+  struct tiny_linked_list_t *current_head = queue->head;
+  void *data = current_head->data;
+  if (queue->head == queue->tail)
+  {
+    queue->head = queue->tail = nullptr;
+  }
+  else
+  {
+    queue->head = queue->head->next;
+  }
+  free(current_head);
+  pthread_mutex_unlock(&queue->mutex);
+
+  return data;
+}
+
+// Destroy the queue with all elements
+int tiny_queue_destroy(tiny_queue_t *queue)
+{
+  if (pthread_mutex_destroy(&queue->mutex) != 0 ||
+      pthread_cond_destroy(&queue->wakeup) != 0)
+    return -1;
+
+  struct tiny_linked_list_t *node, *next;
+  node = queue->head;
+
+  if (node != nullptr)
+  {
+    while (node->next != nullptr)
+    {
+      next = node->next;
+      free(node);
+      node = next;
+    }
+  }
+
+  free(queue);
+
+  return 0;
+}

data/ext/racer/tiny_queue.hh

@@ -0,0 +1,39 @@
+// Taken from https://github.com/schneems/tiny_queue (MIT Licensed)
+#ifndef __TINY_QUEUE__
+#define __TINY_QUEUE__ 1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <sys/types.h>
+#include <string.h>
+
+typedef struct tiny_queue_t {
+  struct tiny_linked_list_t* head;
+  struct tiny_linked_list_t* tail;
+  pthread_mutex_t mutex;
+  pthread_cond_t wakeup;
+} tiny_queue_t;
+
+typedef struct tiny_queue_message_t {
+  int queue_state;
+  void* data;
+} tiny_queue_message_t;
+
+typedef struct tiny_linked_list_t {
+  void *data;
+  struct tiny_linked_list_t* next;
+} tiny_linked_list_t;
+
+// Create an instance of tiny_queue
+tiny_queue_t* tiny_queue_create();
+
+// Push pointer onto tiny_queue, return -1 on error
+int tiny_queue_push(tiny_queue_t *queue, tiny_queue_message_t *x);
+
+// Pop pointer from tiny_queue
+void *tiny_queue_pop(tiny_queue_t *queue);
+
+// Destroy the queue with all elements
+int tiny_queue_destroy(tiny_queue_t *queue);
+#endif

data/ext/racer/traces.cc

@@ -0,0 +1,70 @@
+#include "traces.hh"
+#include <stdlib.h>
+
+void free_constant_instance(ConstantInstance& instance) {
+  // Name is owned by "Constant" object
+
+  if(instance.generic_arguments) {
+    for(unsigned char i = 0; i < instance.generic_argument_count; ++i) {
+      for(auto generic_argument : instance.generic_arguments[i]) {
+        free_constant_instance(generic_argument);
+      }
+    }
+    delete[] instance.generic_arguments;
+  }
+}
+
+void free_param(Parameter& param) {
+  if(param.name) {
+    free(param.name);
+  }
+
+  free_constant_instance(param.type_name);
+}
+
+void free_block_param(BlockParameter& param) {
+  if(param.name) {
+    free(param.name);
+  }
+
+  for(auto trace : param.block_traces) {
+    if(trace) {
+      free_trace(trace);
+    }
+  }
+
+  for(auto trace : param.current_block_call_stack) {
+    if(trace) {
+      free_trace(trace);
+    }
+  }
+}
+
+void free_trace(ReturnTrace* trace) {
+  free_constant_instance(trace->method_owner);
+
+  if(trace->method_callee.has_value()) {
+    free_constant_instance(trace->method_callee.value());
+  }
+
+  if(trace->method_name) {
+    free(trace->method_name);
+  }
+
+  free_constant_instance(trace->return_type);
+
+  for(long i = 0; i < trace->params_size; ++i) {
+    free_param(trace->params[i]);
+  }
+  delete[] trace->params;
+
+  if(trace->block_param.has_value()) {
+    free_block_param(trace->block_param.value());
+  }
+
+  if(trace->block_self_type.has_value()) {
+    free_constant_instance(trace->block_self_type.value());
+  }
+
+  delete(trace);
+}

data/ext/racer/traces.hh

@@ -0,0 +1,95 @@
+
+#ifndef TRACES_H
+#define TRACES_H 1
+
+#include <vector>
+#include <optional>
+#include <memory>
+
+enum ParamType {
+  REQUIRED = 0,
+  OPTIONAL = 1,
+  REST = 2,
+  KEYWORD_REQUIRED = 3,
+  KEYWORD_OPTIONAL = 4,
+  KEYWORD_REST = 5
+};
+
+enum ClassType {
+  MODULE = 0,
+  CLASS = 1,
+};
+
+enum MethodKind {
+  INSTANCE = 0,
+  SINGLETON = 1,
+};
+
+enum MethodVisibility {
+  PUBLIC = 0,
+  PRIVATE = 1,
+  PROTECTED = 2,
+};
+
+typedef struct Constant {
+  char* name { nullptr };
+  bool anonymous { false };
+  ClassType type { MODULE };
+  std::optional<char*> superclass {};
+  std::vector<char*> included_modules {};
+  std::vector<char*> prepended_modules {};
+  std::vector<char*> extended_modules {};
+} Constant;
+
+typedef struct ConstantInstance {
+  char* name { nullptr };
+  unsigned char generic_argument_count { 0 };
+  std::vector<ConstantInstance>* generic_arguments { nullptr };
+  bool singleton { false };
+} ConstantInstance;
+
+typedef struct Parameter {
+  char* name { nullptr };
+  ConstantInstance type_name {};
+  ParamType param_type { REQUIRED };
+} Parameter;
+
+typedef struct ReturnTrace ReturnTrace;
+
+typedef struct BlockParameter {
+  char* name { nullptr };
+  unsigned long tracepoint_id { 0 };
+  std::vector<ReturnTrace*> block_traces {};
+  std::vector<ReturnTrace*> current_block_call_stack {};
+} BlockParameter;
+
+struct ReturnTrace
+{
+  ConstantInstance method_owner {};
+  // Won't be set if callee is equal to owner
+  std::optional<ConstantInstance> method_callee {};
+  char *method_name { nullptr };
+  MethodKind method_kind { INSTANCE };
+  MethodVisibility method_visibility { PUBLIC };
+  ConstantInstance return_type {};
+  long params_size { 0 };
+  Parameter *params { nullptr };
+  bool rescued { false };
+
+  std::vector<std::shared_ptr<Constant>> constant_updates {};
+
+  std::optional<BlockParameter> block_param {};
+  // only relevant for block traces, maybe we could reuse the method_owner Constant but I think it would
+  // be even better if we could split those two types anyway
+  std::optional<ConstantInstance> block_self_type {};
+};
+
+void free_constant_instance(ConstantInstance& instance);
+
+void free_param(Parameter& param);
+
+void free_block_param(BlockParameter& param);
+
+void free_trace(ReturnTrace* trace);
+
+#endif /* TRACES_H */

data/ext/racer/worker.cc

@@ -0,0 +1,188 @@
+#include "worker.hh"
+#include "unistd.h"
+#include <sys/socket.h>
+#include <json-c/json.h>
+
+void write_constant(json_object* json_array, std::shared_ptr<Constant> constant) {
+  json_object_array_add(json_array, json_object_new_string(constant->name));
+  json_object_array_add(json_array, json_object_new_boolean(constant->anonymous));
+  json_object_array_add(json_array, json_object_new_int(constant->type));
+
+  if(constant->superclass.has_value()) {
+    json_object_array_add(json_array, json_object_new_string(constant->superclass.value()));
+  } else {
+    json_object_array_add(json_array, json_object_new_null());
+  }
+
+  json_object_array_add(json_array, json_object_new_uint64(constant->included_modules.size()));
+  for(auto name : constant->included_modules) {
+    json_object_array_add(json_array, json_object_new_string(name));
+  }
+
+  json_object_array_add(json_array, json_object_new_uint64(constant->prepended_modules.size()));
+  for(auto name : constant->prepended_modules) {
+    json_object_array_add(json_array, json_object_new_string(name));
+  }
+
+  json_object_array_add(json_array, json_object_new_uint64(constant->extended_modules.size()));
+  for(auto name : constant->extended_modules) {
+    json_object_array_add(json_array, json_object_new_string(name));
+  }
+}
+
+void write_constant_instance(json_object* json_array, ConstantInstance& instance) {
+  json_object_array_add(json_array, json_object_new_string(instance.name));
+  json_object_array_add(json_array, json_object_new_boolean(instance.singleton));
+  json_object_array_add(json_array, json_object_new_uint64(instance.generic_argument_count));
+  for(int i = 0; i < instance.generic_argument_count; ++i) {
+    json_object_array_add(json_array, json_object_new_uint64(instance.generic_arguments[i].size()));
+    for(auto generic_instance : instance.generic_arguments[i]) {
+      write_constant_instance(json_array, generic_instance);
+    }
+  }
+}
+
+int size_of_constant(std::shared_ptr<Constant> constant) {
+  return 7 + constant->included_modules.size() + constant->prepended_modules.size() + constant->extended_modules.size();
+}
+
+int size_of_constant_updates(std::vector<std::shared_ptr<Constant>> &constant_updates) {
+  auto size = 1;
+  for(auto constant : constant_updates) {
+    size += size_of_constant(constant);
+  }
+  return size;
+}
+
+int size_of_constant_instance(ConstantInstance& instance) {
+  auto size = 3 + instance.generic_argument_count;
+  for(int i = 0; i < instance.generic_argument_count; ++i) {
+    for(auto generic_instance : instance.generic_arguments[i]) {
+      size += size_of_constant_instance(generic_instance);
+    }
+  }
+  return size;
+}
+
+int size_of_block_trace(ReturnTrace*);
+
+int size_of_params(ReturnTrace* trace) {
+  auto size = 2 + trace->params_size * 3;
+
+  if(trace->block_param.has_value()) {
+    size += 2;
+    for(auto block_trace : (*(trace->block_param)).block_traces) {
+      size += size_of_block_trace(block_trace);
+    }
+  }
+  return size;
+}
+
+int size_of_block_trace(ReturnTrace* trace) {
+  return 2 + size_of_params(trace);
+}
+
+void write_params(json_object*, ReturnTrace*);
+
+void write_block_trace(json_object* json_array, ReturnTrace* trace) {
+  write_constant_instance(json_array, trace->block_self_type.value());
+  write_constant_instance(json_array, trace->return_type);
+  write_params(json_array, trace);
+}
+
+void write_params(json_object* json_array, ReturnTrace* trace) {
+  json_object_array_add(json_array, json_object_new_int64(trace->params_size));
+
+  for (long i = 0; i < trace->params_size; ++i)
+  {
+    auto param = trace->params[i];
+    if(param.name) {
+      json_object_array_add(json_array, json_object_new_string(param.name));
+    } else {
+      json_object_array_add(json_array, json_object_new_null());
+    }
+    json_object_array_add(json_array, json_object_new_int(param.param_type));
+    write_constant_instance(json_array, param.type_name);
+  }
+
+  json_object_array_add(json_array, json_object_new_boolean(trace->block_param.has_value()));
+
+  if(trace->block_param.has_value()) {
+    auto block_param = *(trace->block_param);
+    if(block_param.name) {
+      json_object_array_add(json_array, json_object_new_string(block_param.name));
+    } else {
+      json_object_array_add(json_array, json_object_new_null());
+    }
+    json_object_array_add(json_array, json_object_new_uint64(block_param.block_traces.size()));
+    for(auto block_trace : block_param.block_traces) {
+      write_block_trace(json_array, block_trace);
+    }
+  }
+}
+
+void *init_worker(void *arg)
+{
+  auto *worker_data = static_cast<WorkerData *>(arg);
+  auto *tiny_queue = worker_data->queue;
+  auto socket_fd = worker_data->socket_fd;
+
+  // Worker Data is being allocated by the main thread
+  free(worker_data);
+
+  tiny_queue_message_t *message;
+  ReturnTrace *trace;
+
+
+  while (true)
+  {
+    message = static_cast<tiny_queue_message_t *>(tiny_queue_pop(tiny_queue));
+    if (message->queue_state == 0)
+      break;
+
+    trace = static_cast<ReturnTrace *>(message->data);
+
+    auto array_size = 2 + size_of_constant_instance(trace->return_type) + size_of_constant_instance(trace->method_owner) + size_of_params(trace) + size_of_constant_updates(trace->constant_updates);
+    if(trace->method_callee.has_value()) {
+      array_size += size_of_constant_instance(trace->method_callee.value());
+    } else {
+      array_size += 1;
+    }
+
+    auto* json_array = json_object_new_array_ext(array_size);
+
+    // method_name,return_type,owner_name,owner_type,namespace_size,[path_name,path_type,*],...
+    json_object_array_add(json_array, json_object_new_string(trace->method_name));
+    json_object_array_add(json_array, json_object_new_int(trace->method_kind));
+    json_object_array_add(json_array, json_object_new_int(trace->method_visibility));
+
+    write_constant_instance(json_array, trace->return_type);
+    write_constant_instance(json_array, trace->method_owner);
+    if(trace->method_callee.has_value()) {
+      write_constant_instance(json_array, trace->method_callee.value());
+    } else {
+      json_object_array_add(json_array, json_object_new_null());
+    }
+
+    json_object_array_add(json_array, json_object_new_uint64(trace->constant_updates.size()));
+    for(auto constant : trace->constant_updates) {
+      write_constant(json_array, constant);
+    }
+
+    write_params(json_array, trace);
+
+    auto json_string = json_object_to_json_string_ext(json_array, JSON_C_TO_STRING_PLAIN);
+
+    if(send(socket_fd, json_string, strlen(json_string) + 1, 0) < 0) {
+      perror("socket send");
+      return nullptr;
+    }
+
+    json_object_put(json_array);
+
+    free_trace(trace);
+    free(message);
+  }
+
+  return nullptr;
+}

data/ext/racer/worker.hh

@@ -0,0 +1,15 @@
+#ifndef WORKER_H
+#define WORKER_H 1
+
+#include <stdio.h>
+#include "tiny_queue.hh"
+#include "traces.hh"
+
+typedef struct WorkerData {
+  tiny_queue_t* queue;
+  int socket_fd;
+} WorkerData;
+
+void *init_worker(void *);
+
+#endif /* WORKER_H */