language.h File Reference

#include "./subtree.h"
#include "tree_sitter/parser.h"

Go to the source code of this file.

Classes
struct	TableEntry
struct	LookaheadIterator

Macros
#define	ts_builtin_sym_error_repeat   (ts_builtin_sym_error - 1)

Functions
void	ts_language_table_entry (const TSLanguage *, TSStateId, TSSymbol, TableEntry *)
TSSymbolMetadata	ts_language_symbol_metadata (const TSLanguage *, TSSymbol)
TSSymbol	ts_language_public_symbol (const TSLanguage *, TSSymbol)
static bool	ts_language_is_symbol_external (const TSLanguage *self, TSSymbol symbol)
static const TSParseAction *	ts_language_actions (const TSLanguage *self, TSStateId state, TSSymbol symbol, uint32_t *count)
static bool	ts_language_has_reduce_action (const TSLanguage *self, TSStateId state, TSSymbol symbol)
static uint16_t	ts_language_lookup (const TSLanguage *self, TSStateId state, TSSymbol symbol)
static bool	ts_language_has_actions (const TSLanguage *self, TSStateId state, TSSymbol symbol)
static LookaheadIterator	ts_language_lookaheads (const TSLanguage *self, TSStateId state)
static bool	ts_lookahead_iterator_next (LookaheadIterator *self)
static TSStateId	ts_language_next_state (const TSLanguage *self, TSStateId state, TSSymbol symbol)
static bool	ts_language_state_is_primary (const TSLanguage *self, TSStateId state)
static const bool *	ts_language_enabled_external_tokens (const TSLanguage *self, unsigned external_scanner_state)
static const TSSymbol *	ts_language_alias_sequence (const TSLanguage *self, uint32_t production_id)
static TSSymbol	ts_language_alias_at (const TSLanguage *self, uint32_t production_id, uint32_t child_index)
static void	ts_language_field_map (const TSLanguage *self, uint32_t production_id, const TSFieldMapEntry **start, const TSFieldMapEntry **end)
static void	ts_language_aliases_for_symbol (const TSLanguage *self, TSSymbol original_symbol, const TSSymbol **start, const TSSymbol **end)

Macro Definition Documentation

ts_builtin_sym_error_repeat

#define ts_builtin_sym_error_repeat   (ts_builtin_sym_error - 1)

Definition at line 11 of file language.h.

Function Documentation

ts_language_actions()

static const TSParseAction* ts_language_actions ( const TSLanguage *  self, TSStateId  state, TSSymbol  symbol, uint32_t *  count  )

inlinestatic

Definition at line 45 of file language.h.

  {
  TableEntry entry;
  ts_language_table_entry(self, state, symbol, &entry);
  *count = entry.action_count;
  return entry.actions;
}

References count, and ts_language_table_entry().

Referenced by parser__reductions_after_sequence(), parser__repair_error_callback(), parser__skip_preceding_trees_callback(), ts_language_next_state(), and ts_parser__recover().

ts_language_alias_at()

static TSSymbol ts_language_alias_at ( const TSLanguage *  self, uint32_t  production_id, uint32_t  child_index  )

inlinestatic

Definition at line 236 of file language.h.

  {
  return production_id ?
    self->alias_sequences[production_id * self->max_alias_sequence_length + child_index] :
    0;
}

Referenced by iterator_get_visible_state(), iterator_tree_is_visible(), ts_query__analyze_patterns(), ts_tree_cursor_current_field_id(), ts_tree_cursor_current_node(), ts_tree_cursor_goto_parent(), and ts_tree_cursor_parent_node().

ts_language_alias_sequence()

static const TSSymbol* ts_language_alias_sequence ( const TSLanguage *  self, uint32_t  production_id  )

inlinestatic

Definition at line 227 of file language.h.

  {
  return production_id ?
    &self->alias_sequences[production_id * self->max_alias_sequence_length] :
    NULL;
}

References NULL.

Referenced by ts_node_iterate_children(), ts_subtree__write_to_string(), ts_subtree_summarize_children(), ts_tree_cursor_current_status(), and ts_tree_cursor_iterate_children().

ts_language_aliases_for_symbol()

static void ts_language_aliases_for_symbol ( const TSLanguage *  self, TSSymbol  original_symbol, const TSSymbol **  start, const TSSymbol **  end  )

inlinestatic

Definition at line 263 of file language.h.

  {
  *start = &self->public_symbol_map[original_symbol];
  *end = *start + 1;
 
  unsigned i = 0;
  for (;;) {
    TSSymbol symbol = self->alias_map[i++];
    if (symbol == 0 || symbol > original_symbol) break;
    uint16_t count = self->alias_map[i++];
    if (symbol == original_symbol) {
      *start = &self->alias_map[i];
      *end = &self->alias_map[i + count];
      break;
    }
    i += count;
  }
}

References count, test_evm::end, i, and start.

Referenced by ts_query__analyze_patterns().

ts_language_enabled_external_tokens()

static const bool* ts_language_enabled_external_tokens ( const TSLanguage *  self, unsigned  external_scanner_state  )

inlinestatic

Definition at line 216 of file language.h.

  {
  if (external_scanner_state == 0) {
    return NULL;
  } else {
    return self->external_scanner.states + self->external_token_count * external_scanner_state;
  }
}

References NULL.

Referenced by parser__lex(), and ts_parser__lex().

ts_language_field_map()

static void ts_language_field_map ( const TSLanguage *  self, uint32_t  production_id, const TSFieldMapEntry **  start, const TSFieldMapEntry **  end  )

inlinestatic

Definition at line 246 of file language.h.

  {
  if (self->field_count == 0) {
    *start = NULL;
    *end = NULL;
    return;
  }
 
  TSFieldMapSlice slice = self->field_map_slices[production_id];
  *start = &self->field_map_entries[slice.index];
  *end = &self->field_map_entries[slice.index] + slice.length;
}

References test_evm::end, TSFieldMapSlice::index, TSFieldMapSlice::length, NULL, and start.

Referenced by ts_node_child_by_field_id(), ts_node_field_name_for_child(), ts_query__analyze_patterns(), ts_subtree__write_to_string(), ts_tree_cursor_current_field_id(), and ts_tree_cursor_current_status().

ts_language_has_actions()

static bool ts_language_has_actions ( const TSLanguage *  self, TSStateId  state, TSSymbol  symbol  )

inlinestatic

Definition at line 96 of file language.h.

  {
  return ts_language_lookup(self, state, symbol) != 0;
}

References ts_language_lookup().

Referenced by ts_parser__lex(), and ts_parser__recover().

ts_language_has_reduce_action()

static bool ts_language_has_reduce_action ( const TSLanguage *  self, TSStateId  state, TSSymbol  symbol  )

inlinestatic

Definition at line 57 of file language.h.

  {
  TableEntry entry;
  ts_language_table_entry(self, state, symbol, &entry);
  return entry.action_count > 0 && entry.actions[0].type == TSParseActionTypeReduce;
}

References ts_language_table_entry(), and TSParseActionTypeReduce.

Referenced by ts_parser__handle_error().

ts_language_is_symbol_external()

static bool ts_language_is_symbol_external ( const TSLanguage *  self, TSSymbol  symbol  )

inlinestatic

Definition at line 41 of file language.h.

                                                                                           {
  return 0 < symbol && symbol < self->external_token_count + 1;
}

ts_language_lookaheads()

static LookaheadIterator ts_language_lookaheads ( const TSLanguage *  self, TSStateId  state  )

inlinestatic

Definition at line 110 of file language.h.

  {
  bool is_small_state = state >= self->large_state_count;
  const uint16_t *data;
  const uint16_t *group_end = NULL;
  uint16_t group_count = 0;
  if (is_small_state) {
    uint32_t index = self->small_parse_table_map[state - self->large_state_count];
    data = &self->small_parse_table[index];
    group_end = data + 1;
    group_count = *data;
  } else {
    data = &self->parse_table[state * self->symbol_count] - 1;
  }
  return (LookaheadIterator) {
    .language = self,
    .data = data,
    .group_end = group_end,
    .group_count = group_count,
    .is_small_state = is_small_state,
    .symbol = UINT16_MAX,
    .next_state = 0,
  };
}

References NULL, and UINT16_MAX.

Referenced by ts_query__analyze_patterns().

ts_language_lookup()

static uint16_t ts_language_lookup ( const TSLanguage *  self, TSStateId  state, TSSymbol  symbol  )

inlinestatic

Definition at line 74 of file language.h.

  {
  if (state >= self->large_state_count) {
    uint32_t index = self->small_parse_table_map[state - self->large_state_count];
    const uint16_t *data = &self->small_parse_table[index];
    uint16_t group_count = *(data++);
    for (unsigned i = 0; i < group_count; i++) {
      uint16_t section_value = *(data++);
      uint16_t symbol_count = *(data++);
      for (unsigned i = 0; i < symbol_count; i++) {
        if (*(data++) == symbol) return section_value;
      }
    }
    return 0;
  } else {
    return self->parse_table[state * self->symbol_count + symbol];
  }
}

References i.

Referenced by ts_language_has_actions(), ts_language_next_state(), and ts_language_table_entry().

ts_language_next_state()

static TSStateId ts_language_next_state ( const TSLanguage *  self, TSStateId  state, TSSymbol  symbol  )

inlinestatic

Definition at line 181 of file language.h.

  {
  if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
    return 0;
  } else if (symbol < self->token_count) {
    uint32_t count;
    const TSParseAction *actions = ts_language_actions(self, state, symbol, &count);
    if (count > 0) {
      TSParseAction action = actions[count - 1];
      if (action.type == TSParseActionTypeShift) {
        return action.shift.extra ? state : action.shift.state;
      }
    }
    return 0;
  } else {
    return ts_language_lookup(self, state, symbol);
  }
}

References test-lz4-speed::action, count, ts_builtin_sym_error, ts_builtin_sym_error_repeat, ts_language_actions(), ts_language_lookup(), and TSParseActionTypeShift.

Referenced by parser__advance(), parser__breakdown_top_of_stack(), parser__reduce(), parser__reductions_after_sequence(), parser__repair_error_callback(), ts_parser__advance(), ts_parser__breakdown_top_of_stack(), ts_parser__handle_error(), and ts_parser__reduce().

ts_language_public_symbol()

TSSymbol ts_language_public_symbol	(	const TSLanguage *	self,
		TSSymbol	symbol
	)

Definition at line 51 of file language.c.

  {
  if (symbol == ts_builtin_sym_error) return symbol;
  return self->public_symbol_map[symbol];
}

References ts_builtin_sym_error.

Referenced by ts_node_symbol().

ts_language_state_is_primary()

static bool ts_language_state_is_primary ( const TSLanguage *  self, TSStateId  state  )

inlinestatic

Definition at line 205 of file language.h.

  {
  if (self->version >= 14) {
    return state == self->primary_state_ids[state];
  } else {
    return true;
  }
}

Referenced by ts_query__analyze_patterns().

ts_language_symbol_metadata()

TSSymbolMetadata ts_language_symbol_metadata	(	const TSLanguage *	self,
		TSSymbol	symbol
	)

Definition at line 38 of file language.c.

  {
  if (symbol == ts_builtin_sym_error)  {
    return (TSSymbolMetadata) {.visible = true, .named = true};
  } else if (symbol == ts_builtin_sym_error_repeat) {
    return (TSSymbolMetadata) {.visible = false, .named = false};
  } else {
    return self->symbol_metadata[symbol];
  }
}

References ts_builtin_sym_error, ts_builtin_sym_error_repeat, and TSSymbolMetadata::visible.

Referenced by parser__halt_parse(), parser__lex(), parser__recover(), parser__reduce(), parser__repair_error(), parser__shift(), ts_language_symbol_for_name(), ts_language_symbol_type(), ts_node__is_relevant(), ts_node_is_named(), ts_query__analyze_patterns(), ts_query__parse_pattern(), ts_subtree__write_to_string(), ts_subtree_new_leaf(), ts_subtree_new_node(), ts_subtree_set_symbol(), ts_subtree_summarize_children(), and ts_tree_cursor_current_status().

ts_language_table_entry()

void ts_language_table_entry	(	const TSLanguage *	self,
		TSStateId	state,
		TSSymbol	symbol,
		TableEntry *	result
	)

Definition at line 18 of file language.c.

  {
  if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
    result->action_count = 0;
    result->is_reusable = false;
    result->actions = NULL;
  } else {
    assert(symbol < self->token_count);
    uint32_t action_index = ts_language_lookup(self, state, symbol);
    const TSParseActionEntry *entry = &self->parse_actions[action_index];
    result->action_count = entry->entry.count;
    result->is_reusable = entry->entry.reusable;
    result->actions = (const TSParseAction *)(entry + 1);
  }
}

References TableEntry::action_count, TableEntry::actions, assert(), TableEntry::is_reusable, NULL, ts_builtin_sym_error, ts_builtin_sym_error_repeat, and ts_language_lookup().

Referenced by parser__advance(), parser__do_potential_reductions(), ts_language_actions(), ts_language_has_reduce_action(), ts_parser__advance(), ts_parser__do_all_potential_reductions(), ts_parser__get_cached_token(), and ts_parser__reuse_node().

ts_lookahead_iterator_next()

static bool ts_lookahead_iterator_next ( LookaheadIterator *  self )

inlinestatic

Definition at line 137 of file language.h.

                                                                       {
  // For small parse states, valid symbols are listed explicitly,
  // grouped by their value. There's no need to look up the actions
  // again until moving to the next group.
  if (self->is_small_state) {
    self->data++;
    if (self->data == self->group_end) {
      if (self->group_count == 0) return false;
      self->group_count--;
      self->table_value = *(self->data++);
      unsigned symbol_count = *(self->data++);
      self->group_end = self->data + symbol_count;
      self->symbol = *self->data;
    } else {
      self->symbol = *self->data;
      return true;
    }
  }
 
  // For large parse states, iterate through every symbol until one
  // is found that has valid actions.
  else {
    do {
      self->data++;
      self->symbol++;
      if (self->symbol >= self->language->symbol_count) return false;
      self->table_value = *self->data;
    } while (!self->table_value);
  }
 
  // Depending on if the symbols is terminal or non-terminal, the table value either
  // represents a list of actions or a successor state.
  if (self->symbol < self->language->token_count) {
    const TSParseActionEntry *entry = &self->language->parse_actions[self->table_value];
    self->action_count = entry->entry.count;
    self->actions = (const TSParseAction *)(entry + 1);
    self->next_state = 0;
  } else {
    self->action_count = 0;
    self->next_state = self->table_value;
  }
  return true;
}

Referenced by ts_query__analyze_patterns().