1#define _POSIX_C_SOURCE 200112L
  2
  3#include "api.h"
  4#include "./array.h"
  5#include "./get_changed_ranges.h"
  6#include "./length.h"
  7#include "./subtree.h"
  8#include "./tree_cursor.h"
  9#include "./tree.h"
 10
 11TSTree *ts_tree_new(
 12  Subtree root, const TSLanguage *language,
 13  const TSRange *included_ranges, unsigned included_range_count
 14) {
 15  TSTree *result = ts_malloc(sizeof(TSTree));
 16  result->root = root;
 17  result->language = ts_language_copy(language);
 18  result->included_ranges = ts_calloc(included_range_count, sizeof(TSRange));
 19  memcpy(result->included_ranges, included_ranges, included_range_count * sizeof(TSRange));
 20  result->included_range_count = included_range_count;
 21  return result;
 22}
 23
 24TSTree *ts_tree_copy(const TSTree *self) {
 25  ts_subtree_retain(self->root);
 26  return ts_tree_new(self->root, self->language, self->included_ranges, self->included_range_count);
 27}
 28
 29void ts_tree_delete(TSTree *self) {
 30  if (!self) return;
 31
 32  SubtreePool pool = ts_subtree_pool_new(0);
 33  ts_subtree_release(&pool, self->root);
 34  ts_subtree_pool_delete(&pool);
 35  ts_language_delete(self->language);
 36  ts_free(self->included_ranges);
 37  ts_free(self);
 38}
 39
 40TSNode ts_tree_root_node(const TSTree *self) {
 41  return ts_node_new(self, &self->root, ts_subtree_padding(self->root), 0);
 42}
 43
 44TSNode ts_tree_root_node_with_offset(
 45  const TSTree *self,
 46  uint32_t offset_bytes,
 47  TSPoint offset_extent
 48) {
 49  Length offset = {offset_bytes, offset_extent};
 50  return ts_node_new(self, &self->root, length_add(offset, ts_subtree_padding(self->root)), 0);
 51}
 52
 53const TSLanguage *ts_tree_language(const TSTree *self) {
 54  return self->language;
 55}
 56
 57void ts_tree_edit(TSTree *self, const TSInputEdit *edit) {
 58  for (unsigned i = 0; i < self->included_range_count; i++) {
 59    TSRange *range = &self->included_ranges[i];
 60    if (range->end_byte >= edit->old_end_byte) {
 61      if (range->end_byte != UINT32_MAX) {
 62        range->end_byte = edit->new_end_byte + (range->end_byte - edit->old_end_byte);
 63        range->end_point = point_add(
 64          edit->new_end_point,
 65          point_sub(range->end_point, edit->old_end_point)
 66        );
 67        if (range->end_byte < edit->new_end_byte) {
 68          range->end_byte = UINT32_MAX;
 69          range->end_point = POINT_MAX;
 70        }
 71      }
 72    } else if (range->end_byte > edit->start_byte) {
 73      range->end_byte = edit->start_byte;
 74      range->end_point = edit->start_point;
 75    }
 76    if (range->start_byte >= edit->old_end_byte) {
 77      range->start_byte = edit->new_end_byte + (range->start_byte - edit->old_end_byte);
 78      range->start_point = point_add(
 79        edit->new_end_point,
 80        point_sub(range->start_point, edit->old_end_point)
 81      );
 82      if (range->start_byte < edit->new_end_byte) {
 83        range->start_byte = UINT32_MAX;
 84        range->start_point = POINT_MAX;
 85      }
 86    } else if (range->start_byte > edit->start_byte) {
 87      range->start_byte = edit->start_byte;
 88      range->start_point = edit->start_point;
 89    }
 90  }
 91
 92  SubtreePool pool = ts_subtree_pool_new(0);
 93  self->root = ts_subtree_edit(self->root, edit, &pool);
 94  ts_subtree_pool_delete(&pool);
 95}
 96
 97TSRange *ts_tree_included_ranges(const TSTree *self, uint32_t *length) {
 98  *length = self->included_range_count;
 99  TSRange *ranges = ts_calloc(self->included_range_count, sizeof(TSRange));
100  memcpy(ranges, self->included_ranges, self->included_range_count * sizeof(TSRange));
101  return ranges;
102}
103
104TSRange *ts_tree_get_changed_ranges(const TSTree *old_tree, const TSTree *new_tree, uint32_t *length) {
105  TreeCursor cursor1 = {NULL, array_new(), 0};
106  TreeCursor cursor2 = {NULL, array_new(), 0};
107  ts_tree_cursor_init(&cursor1, ts_tree_root_node(old_tree));
108  ts_tree_cursor_init(&cursor2, ts_tree_root_node(new_tree));
109
110  TSRangeArray included_range_differences = array_new();
111  ts_range_array_get_changed_ranges(
112    old_tree->included_ranges, old_tree->included_range_count,
113    new_tree->included_ranges, new_tree->included_range_count,
114    &included_range_differences
115  );
116
117  TSRange *result;
118  *length = ts_subtree_get_changed_ranges(
119    &old_tree->root, &new_tree->root, &cursor1, &cursor2,
120    old_tree->language, &included_range_differences, &result
121  );
122
123  array_delete(&included_range_differences);
124  array_delete(&cursor1.stack);
125  array_delete(&cursor2.stack);
126  return result;
127}
128
129#ifdef _WIN32
130
131#include <io.h>
132#include <windows.h>
133
134int _ts_dup(HANDLE handle) {
135  HANDLE dup_handle;
136  if (!DuplicateHandle(
137    GetCurrentProcess(), handle,
138    GetCurrentProcess(), &dup_handle,
139    0, FALSE, DUPLICATE_SAME_ACCESS
140  )) return -1;
141
142  return _open_osfhandle((intptr_t)dup_handle, 0);
143}
144
145void ts_tree_print_dot_graph(const TSTree *self, int fd) {
146  FILE *file = _fdopen(_ts_dup((HANDLE)_get_osfhandle(fd)), "a");
147  ts_subtree_print_dot_graph(self->root, self->language, file);
148  fclose(file);
149}
150
151#else
152
153#include <unistd.h>
154
155int _ts_dup(int file_descriptor) {
156  return dup(file_descriptor);
157}
158
159void ts_tree_print_dot_graph(const TSTree *self, int file_descriptor) {
160  FILE *file = fdopen(_ts_dup(file_descriptor), "a");
161  ts_subtree_print_dot_graph(self->root, self->language, file);
162  fclose(file);
163}
164
165#endif