reusable_node.h File Reference

#include "./subtree.h"

Go to the source code of this file.

Classes
struct	StackEntry
struct	ReusableNode

Functions
static ReusableNode	reusable_node_new (void)
static void	reusable_node_clear (ReusableNode *self)
static Subtree	reusable_node_tree (ReusableNode *self)
static uint32_t	reusable_node_byte_offset (ReusableNode *self)
static void	reusable_node_delete (ReusableNode *self)
static void	reusable_node_advance (ReusableNode *self)
static bool	reusable_node_descend (ReusableNode *self)
static void	reusable_node_advance_past_leaf (ReusableNode *self)
static void	reusable_node_reset (ReusableNode *self, Subtree tree)

Function Documentation

reusable_node_advance()

static void reusable_node_advance ( ReusableNode *  self )

inlinestatic

Definition at line 39 of file reusable_node.h.

                                                             {
  StackEntry last_entry = *array_back(&self->stack);
  uint32_t byte_offset = last_entry.byte_offset + ts_subtree_total_bytes(last_entry.tree);
  if (ts_subtree_has_external_tokens(last_entry.tree)) {
    self->last_external_token = ts_subtree_last_external_token(last_entry.tree);
  }
 
  Subtree tree;
  uint32_t next_index;
  do {
    StackEntry popped_entry = array_pop(&self->stack);
    next_index = popped_entry.child_index + 1;
    if (self->stack.size == 0) return;
    tree = array_back(&self->stack)->tree;
  } while (ts_subtree_child_count(tree) <= next_index);
 
  array_push(&self->stack, ((StackEntry) {
    .tree = ts_subtree_children(tree)[next_index],
    .child_index = next_index,
    .byte_offset = byte_offset,
  }));
}

References array_back, array_pop, array_push, StackEntry::byte_offset, StackEntry::child_index, StackEntry::tree, ts_subtree_child_count(), ts_subtree_has_external_tokens(), ts_subtree_last_external_token(), and ts_subtree_total_bytes().

Referenced by reusable_node_advance_past_leaf(), ts_parser__advance(), and ts_parser__reuse_node().

reusable_node_advance_past_leaf()

static void reusable_node_advance_past_leaf ( ReusableNode *  self )

inlinestatic

Definition at line 76 of file reusable_node.h.

                                                                       {
  while (reusable_node_descend(self)) {}
  reusable_node_advance(self);
}

References reusable_node_advance(), and reusable_node_descend().

Referenced by ts_parser__reuse_node().

reusable_node_byte_offset()

static uint32_t reusable_node_byte_offset ( ReusableNode *  self )

inlinestatic

Definition at line 29 of file reusable_node.h.

                                                                     {
  return self->stack.size > 0
    ? self->stack.contents[self->stack.size - 1].byte_offset
    : UINT32_MAX;
}

References UINT32_MAX.

Referenced by ts_parser__reuse_node().

reusable_node_clear()

static void reusable_node_clear ( ReusableNode *  self )

inlinestatic

Definition at line 18 of file reusable_node.h.

                                                           {
  array_clear(&self->stack);
  self->last_external_token = NULL_SUBTREE;
}

References array_clear, and NULL_SUBTREE.

Referenced by reusable_node_reset(), ts_parser_parse(), and ts_parser_reset().

reusable_node_delete()

static void reusable_node_delete ( ReusableNode *  self )

inlinestatic

Definition at line 35 of file reusable_node.h.

                                                            {
  array_delete(&self->stack);
}

References array_delete.

Referenced by ts_parser_delete().

reusable_node_descend()

static bool reusable_node_descend ( ReusableNode *  self )

inlinestatic

Definition at line 62 of file reusable_node.h.

                                                             {
  StackEntry last_entry = *array_back(&self->stack);
  if (ts_subtree_child_count(last_entry.tree) > 0) {
    array_push(&self->stack, ((StackEntry) {
      .tree = ts_subtree_children(last_entry.tree)[0],
      .child_index = 0,
      .byte_offset = last_entry.byte_offset,
    }));
    return true;
  } else {
    return false;
  }
}

References array_back, array_push, StackEntry::tree, and ts_subtree_child_count().

Referenced by reusable_node_advance_past_leaf(), reusable_node_reset(), ts_parser__breakdown_lookahead(), and ts_parser__reuse_node().

reusable_node_new()

static ReusableNode reusable_node_new ( void  )

inlinestatic

Definition at line 14 of file reusable_node.h.

                                                   {
  return (ReusableNode) {array_new(), NULL_SUBTREE};
}

References array_new, and NULL_SUBTREE.

Referenced by parser__start(), and ts_parser_new().

reusable_node_reset()

static void reusable_node_reset ( ReusableNode *  self, Subtree  tree  )

inlinestatic

Definition at line 81 of file reusable_node.h.

                                                                         {
  reusable_node_clear(self);
  array_push(&self->stack, ((StackEntry) {
    .tree = tree,
    .child_index = 0,
    .byte_offset = 0,
  }));
 
  // Never reuse the root node, because it has a non-standard internal structure
  // due to transformations that are applied when it is accepted: adding the EOF
  // child and any extra children.
  if (!reusable_node_descend(self)) {
    reusable_node_clear(self);
  }
}

References array_push, reusable_node_clear(), and reusable_node_descend().

Referenced by ts_parser_parse().

reusable_node_tree()

static Subtree reusable_node_tree ( ReusableNode *  self )

inlinestatic

Definition at line 23 of file reusable_node.h.

                                                             {
  return self->stack.size > 0
    ? self->stack.contents[self->stack.size - 1].tree
    : NULL_SUBTREE;
}

References NULL_SUBTREE.

Referenced by ts_parser__breakdown_lookahead(), and ts_parser__reuse_node().