feat(lib)!: remove deprecated functions
This commit is contained in:
Amaan Qureshi
Amaan Qureshi
parent
917895e6a3
commit
821cf797f2
5 changed files with 8 additions and 288 deletions
|
|
@ -299,16 +299,7 @@ const TSRange *ts_parser_included_ranges(
|
|||
* are four possible reasons for failure:
|
||||
* 1. The parser does not have a language assigned. Check for this using the
|
||||
[`ts_parser_language`] function.
|
||||
* 2. Parsing was cancelled due to a timeout that was set by an earlier call to
|
||||
* the [`ts_parser_set_timeout_micros`] function. You can resume parsing from
|
||||
* where the parser left out by calling [`ts_parser_parse`] again with the
|
||||
* same arguments. Or you can start parsing from scratch by first calling
|
||||
* [`ts_parser_reset`].
|
||||
* 3. Parsing was cancelled using a cancellation flag that was set by an
|
||||
* earlier call to [`ts_parser_set_cancellation_flag`]. You can resume parsing
|
||||
* from where the parser left out by calling [`ts_parser_parse`] again with
|
||||
* the same arguments.
|
||||
* 4. Parsing was cancelled due to the progress callback returning true. This callback
|
||||
* 2. Parsing was cancelled due to the progress callback returning true. This callback
|
||||
* is passed in [`ts_parser_parse_with_options`] inside the [`TSParseOptions`] struct.
|
||||
*
|
||||
* [`read`]: TSInput::read
|
||||
|
|
@ -366,7 +357,7 @@ TSTree *ts_parser_parse_string_encoding(
|
|||
/**
|
||||
* Instruct the parser to start the next parse from the beginning.
|
||||
*
|
||||
* If the parser previously failed because of a timeout or a cancellation, then
|
||||
* If the parser previously failed because of the progress callback, then
|
||||
* by default, it will resume where it left off on the next call to
|
||||
* [`ts_parser_parse`] or other parsing functions. If you don't want to resume,
|
||||
* and instead intend to use this parser to parse some other document, you must
|
||||
|
|
@ -374,42 +365,6 @@ TSTree *ts_parser_parse_string_encoding(
|
|||
*/
|
||||
void ts_parser_reset(TSParser *self);
|
||||
|
||||
/**
|
||||
* @deprecated use [`ts_parser_parse_with_options`] and pass in a callback instead, this will be removed in 0.26.
|
||||
*
|
||||
* Set the maximum duration in microseconds that parsing should be allowed to
|
||||
* take before halting.
|
||||
*
|
||||
* If parsing takes longer than this, it will halt early, returning NULL.
|
||||
* See [`ts_parser_parse`] for more information.
|
||||
*/
|
||||
void ts_parser_set_timeout_micros(TSParser *self, uint64_t timeout_micros);
|
||||
|
||||
/**
|
||||
* @deprecated use [`ts_parser_parse_with_options`] and pass in a callback instead, this will be removed in 0.26.
|
||||
*
|
||||
* Get the duration in microseconds that parsing is allowed to take.
|
||||
*/
|
||||
uint64_t ts_parser_timeout_micros(const TSParser *self);
|
||||
|
||||
/**
|
||||
* @deprecated use [`ts_parser_parse_with_options`] and pass in a callback instead, this will be removed in 0.26.
|
||||
*
|
||||
* Set the parser's current cancellation flag pointer.
|
||||
*
|
||||
* If a non-null pointer is assigned, then the parser will periodically read
|
||||
* from this pointer during parsing. If it reads a non-zero value, it will
|
||||
* halt early, returning NULL. See [`ts_parser_parse`] for more information.
|
||||
*/
|
||||
void ts_parser_set_cancellation_flag(TSParser *self, const size_t *flag);
|
||||
|
||||
/**
|
||||
* @deprecated use [`ts_parser_parse_with_options`] and pass in a callback instead, this will be removed in 0.26.
|
||||
*
|
||||
* Get the parser's current cancellation flag pointer.
|
||||
*/
|
||||
const size_t *ts_parser_cancellation_flag(const TSParser *self);
|
||||
|
||||
/**
|
||||
* Set the logger that a parser should use during parsing.
|
||||
*
|
||||
|
|
@ -1094,26 +1049,6 @@ bool ts_query_cursor_did_exceed_match_limit(const TSQueryCursor *self);
|
|||
uint32_t ts_query_cursor_match_limit(const TSQueryCursor *self);
|
||||
void ts_query_cursor_set_match_limit(TSQueryCursor *self, uint32_t limit);
|
||||
|
||||
/**
|
||||
* @deprecated use [`ts_query_cursor_exec_with_options`] and pass in a callback instead, this will be removed in 0.26.
|
||||
*
|
||||
* Set the maximum duration in microseconds that query execution should be allowed to
|
||||
* take before halting.
|
||||
*
|
||||
* If query execution takes longer than this, it will halt early, returning NULL.
|
||||
* See [`ts_query_cursor_next_match`] or [`ts_query_cursor_next_capture`] for more information.
|
||||
*/
|
||||
void ts_query_cursor_set_timeout_micros(TSQueryCursor *self, uint64_t timeout_micros);
|
||||
|
||||
/**
|
||||
* @deprecated use [`ts_query_cursor_exec_with_options`] and pass in a callback instead, this will be removed in 0.26.
|
||||
*
|
||||
* Get the duration in microseconds that query execution is allowed to take.
|
||||
*
|
||||
* This is set via [`ts_query_cursor_set_timeout_micros`].
|
||||
*/
|
||||
uint64_t ts_query_cursor_timeout_micros(const TSQueryCursor *self);
|
||||
|
||||
/**
|
||||
* Set the range of bytes in which the query will be executed.
|
||||
*
|
||||
|
|
@ -1264,17 +1199,6 @@ const char *ts_language_symbol_name(const TSLanguage *self, TSSymbol symbol);
|
|||
*/
|
||||
TSSymbolType ts_language_symbol_type(const TSLanguage *self, TSSymbol symbol);
|
||||
|
||||
/**
|
||||
* @deprecated use [`ts_language_abi_version`] instead, this will be removed in 0.26.
|
||||
*
|
||||
* 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 also [`ts_parser_set_language`].
|
||||
*/
|
||||
uint32_t ts_language_version(const TSLanguage *self);
|
||||
|
||||
/**
|
||||
* Get the ABI version number for this language. This version number is used
|
||||
* to ensure that languages were generated by a compatible version of
|
||||
|
|
|
|||
146
lib/src/clock.h
146
lib/src/clock.h
|
|
@ -1,146 +0,0 @@
|
|||
#ifndef TREE_SITTER_CLOCK_H_
|
||||
#define TREE_SITTER_CLOCK_H_
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
typedef uint64_t TSDuration;
|
||||
|
||||
#ifdef _WIN32
|
||||
|
||||
// Windows:
|
||||
// * Represent a time as a performance counter value.
|
||||
// * Represent a duration as a number of performance counter ticks.
|
||||
|
||||
#include <windows.h>
|
||||
typedef uint64_t TSClock;
|
||||
|
||||
static inline TSDuration duration_from_micros(uint64_t micros) {
|
||||
LARGE_INTEGER frequency;
|
||||
QueryPerformanceFrequency(&frequency);
|
||||
return micros * (uint64_t)frequency.QuadPart / 1000000;
|
||||
}
|
||||
|
||||
static inline uint64_t duration_to_micros(TSDuration self) {
|
||||
LARGE_INTEGER frequency;
|
||||
QueryPerformanceFrequency(&frequency);
|
||||
return self * 1000000 / (uint64_t)frequency.QuadPart;
|
||||
}
|
||||
|
||||
static inline TSClock clock_null(void) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline TSClock clock_now(void) {
|
||||
LARGE_INTEGER result;
|
||||
QueryPerformanceCounter(&result);
|
||||
return (uint64_t)result.QuadPart;
|
||||
}
|
||||
|
||||
static inline TSClock clock_after(TSClock base, TSDuration duration) {
|
||||
return base + duration;
|
||||
}
|
||||
|
||||
static inline bool clock_is_null(TSClock self) {
|
||||
return !self;
|
||||
}
|
||||
|
||||
static inline bool clock_is_gt(TSClock self, TSClock other) {
|
||||
return self > other;
|
||||
}
|
||||
|
||||
#elif defined(CLOCK_MONOTONIC)
|
||||
|
||||
// POSIX with monotonic clock support (Linux, macOS)
|
||||
// * Represent a time as a monotonic (seconds, nanoseconds) pair.
|
||||
// * Represent a duration as a number of microseconds.
|
||||
//
|
||||
// On these platforms, parse timeouts will correspond accurately to
|
||||
// real time, regardless of what other processes are running.
|
||||
|
||||
#include <time.h>
|
||||
typedef struct timespec TSClock;
|
||||
|
||||
static inline TSDuration duration_from_micros(uint64_t micros) {
|
||||
return micros;
|
||||
}
|
||||
|
||||
static inline uint64_t duration_to_micros(TSDuration self) {
|
||||
return self;
|
||||
}
|
||||
|
||||
static inline TSClock clock_now(void) {
|
||||
TSClock result;
|
||||
clock_gettime(CLOCK_MONOTONIC, &result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline TSClock clock_null(void) {
|
||||
return (TSClock) {0, 0};
|
||||
}
|
||||
|
||||
static inline TSClock clock_after(TSClock base, TSDuration duration) {
|
||||
TSClock result = base;
|
||||
result.tv_sec += duration / 1000000;
|
||||
result.tv_nsec += (duration % 1000000) * 1000;
|
||||
if (result.tv_nsec >= 1000000000) {
|
||||
result.tv_nsec -= 1000000000;
|
||||
++(result.tv_sec);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline bool clock_is_null(TSClock self) {
|
||||
return !self.tv_sec && !self.tv_nsec;
|
||||
}
|
||||
|
||||
static inline bool clock_is_gt(TSClock self, TSClock other) {
|
||||
if (self.tv_sec > other.tv_sec) return true;
|
||||
if (self.tv_sec < other.tv_sec) return false;
|
||||
return self.tv_nsec > other.tv_nsec;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
// POSIX without monotonic clock support
|
||||
// * Represent a time as a process clock value.
|
||||
// * Represent a duration as a number of process clock ticks.
|
||||
//
|
||||
// On these platforms, parse timeouts may be affected by other processes,
|
||||
// which is not ideal, but is better than using a non-monotonic time API
|
||||
// like `gettimeofday`.
|
||||
|
||||
#include <time.h>
|
||||
typedef uint64_t TSClock;
|
||||
|
||||
static inline TSDuration duration_from_micros(uint64_t micros) {
|
||||
return micros * (uint64_t)CLOCKS_PER_SEC / 1000000;
|
||||
}
|
||||
|
||||
static inline uint64_t duration_to_micros(TSDuration self) {
|
||||
return self * 1000000 / (uint64_t)CLOCKS_PER_SEC;
|
||||
}
|
||||
|
||||
static inline TSClock clock_null(void) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline TSClock clock_now(void) {
|
||||
return (uint64_t)clock();
|
||||
}
|
||||
|
||||
static inline TSClock clock_after(TSClock base, TSDuration duration) {
|
||||
return base + duration;
|
||||
}
|
||||
|
||||
static inline bool clock_is_null(TSClock self) {
|
||||
return !self;
|
||||
}
|
||||
|
||||
static inline bool clock_is_gt(TSClock self, TSClock other) {
|
||||
return self > other;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif // TREE_SITTER_CLOCK_H_
|
||||
|
|
@ -49,10 +49,6 @@ const TSSymbol *ts_language_subtypes(
|
|||
return &self->supertype_map_entries[slice.index];
|
||||
}
|
||||
|
||||
uint32_t ts_language_version(const TSLanguage *self) {
|
||||
return self->abi_version;
|
||||
}
|
||||
|
||||
uint32_t ts_language_abi_version(const TSLanguage *self) {
|
||||
return self->abi_version;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
#include <time.h>
|
||||
#include <stdio.h>
|
||||
#include <limits.h>
|
||||
#include <stdbool.h>
|
||||
|
|
@ -6,8 +5,6 @@
|
|||
#include "tree_sitter/api.h"
|
||||
#include "./alloc.h"
|
||||
#include "./array.h"
|
||||
#include "./atomic.h"
|
||||
#include "./clock.h"
|
||||
#include "./error_costs.h"
|
||||
#include "./get_changed_ranges.h"
|
||||
#include "./language.h"
|
||||
|
|
@ -81,7 +78,7 @@ static const unsigned MAX_VERSION_COUNT = 6;
|
|||
static const unsigned MAX_VERSION_COUNT_OVERFLOW = 4;
|
||||
static const unsigned MAX_SUMMARY_DEPTH = 16;
|
||||
static const unsigned MAX_COST_DIFFERENCE = 18 * ERROR_COST_PER_SKIPPED_TREE;
|
||||
static const unsigned OP_COUNT_PER_PARSER_TIMEOUT_CHECK = 100;
|
||||
static const unsigned OP_COUNT_PER_PARSER_CALLBACK_CHECK = 100;
|
||||
|
||||
typedef struct {
|
||||
Subtree token;
|
||||
|
|
@ -104,11 +101,8 @@ struct TSParser {
|
|||
ReusableNode reusable_node;
|
||||
void *external_scanner_payload;
|
||||
FILE *dot_graph_file;
|
||||
TSClock end_clock;
|
||||
TSDuration timeout_duration;
|
||||
unsigned accept_count;
|
||||
unsigned operation_count;
|
||||
const volatile size_t *cancellation_flag;
|
||||
Subtree old_tree;
|
||||
TSRangeArray included_range_differences;
|
||||
TSParseOptions parse_options;
|
||||
|
|
@ -1537,7 +1531,7 @@ static void ts_parser__handle_error(
|
|||
|
||||
static bool ts_parser__check_progress(TSParser *self, Subtree *lookahead, const uint32_t *position, unsigned operations) {
|
||||
self->operation_count += operations;
|
||||
if (self->operation_count >= OP_COUNT_PER_PARSER_TIMEOUT_CHECK) {
|
||||
if (self->operation_count >= OP_COUNT_PER_PARSER_CALLBACK_CHECK) {
|
||||
self->operation_count = 0;
|
||||
}
|
||||
if (position != NULL) {
|
||||
|
|
@ -1546,12 +1540,7 @@ static bool ts_parser__check_progress(TSParser *self, Subtree *lookahead, const
|
|||
}
|
||||
if (
|
||||
self->operation_count == 0 &&
|
||||
(
|
||||
// TODO(amaanq): remove cancellation flag & clock checks before 0.26
|
||||
(self->cancellation_flag && atomic_load(self->cancellation_flag)) ||
|
||||
(!clock_is_null(self->end_clock) && clock_is_gt(clock_now(), self->end_clock)) ||
|
||||
(self->parse_options.progress_callback && self->parse_options.progress_callback(&self->parse_state))
|
||||
)
|
||||
(self->parse_options.progress_callback && self->parse_options.progress_callback(&self->parse_state))
|
||||
) {
|
||||
if (lookahead && lookahead->ptr) {
|
||||
ts_subtree_release(&self->tree_pool, *lookahead);
|
||||
|
|
@ -1611,7 +1600,7 @@ static bool ts_parser__advance(
|
|||
}
|
||||
}
|
||||
|
||||
// If a cancellation flag, timeout, or progress callback was provided, then check every
|
||||
// If a progress callback was provided, then check every
|
||||
// time a fixed number of parse actions has been processed.
|
||||
if (!ts_parser__check_progress(self, &lookahead, &position, 1)) {
|
||||
return false;
|
||||
|
|
@ -1949,14 +1938,11 @@ TSParser *ts_parser_new(void) {
|
|||
self->finished_tree = NULL_SUBTREE;
|
||||
self->reusable_node = reusable_node_new();
|
||||
self->dot_graph_file = NULL;
|
||||
self->cancellation_flag = NULL;
|
||||
self->timeout_duration = 0;
|
||||
self->language = NULL;
|
||||
self->has_scanner_error = false;
|
||||
self->has_error = false;
|
||||
self->canceled_balancing = false;
|
||||
self->external_scanner_payload = NULL;
|
||||
self->end_clock = clock_null();
|
||||
self->operation_count = 0;
|
||||
self->old_tree = NULL_SUBTREE;
|
||||
self->included_range_differences = (TSRangeArray) array_new();
|
||||
|
|
@ -2042,22 +2028,6 @@ void ts_parser_print_dot_graphs(TSParser *self, int fd) {
|
|||
}
|
||||
}
|
||||
|
||||
const size_t *ts_parser_cancellation_flag(const TSParser *self) {
|
||||
return (const size_t *)self->cancellation_flag;
|
||||
}
|
||||
|
||||
void ts_parser_set_cancellation_flag(TSParser *self, const size_t *flag) {
|
||||
self->cancellation_flag = (const volatile size_t *)flag;
|
||||
}
|
||||
|
||||
uint64_t ts_parser_timeout_micros(const TSParser *self) {
|
||||
return duration_to_micros(self->timeout_duration);
|
||||
}
|
||||
|
||||
void ts_parser_set_timeout_micros(TSParser *self, uint64_t timeout_micros) {
|
||||
self->timeout_duration = duration_from_micros(timeout_micros);
|
||||
}
|
||||
|
||||
bool ts_parser_set_included_ranges(
|
||||
TSParser *self,
|
||||
const TSRange *ranges,
|
||||
|
|
@ -2115,11 +2085,6 @@ TSTree *ts_parser_parse(
|
|||
self->included_range_difference_index = 0;
|
||||
|
||||
self->operation_count = 0;
|
||||
if (self->timeout_duration) {
|
||||
self->end_clock = clock_after(clock_now(), self->timeout_duration);
|
||||
} else {
|
||||
self->end_clock = clock_null();
|
||||
}
|
||||
|
||||
if (ts_parser_has_outstanding_parse(self)) {
|
||||
LOG("resume_parsing");
|
||||
|
|
|
|||
|
|
@ -10,7 +10,6 @@
|
|||
#include "tree_sitter/api.h"
|
||||
#include "./alloc.h"
|
||||
#include "./array.h"
|
||||
#include "./clock.h"
|
||||
#include "./language.h"
|
||||
#include "./point.h"
|
||||
#include "./tree_cursor.h"
|
||||
|
|
@ -324,8 +323,6 @@ struct TSQueryCursor {
|
|||
TSPoint start_point;
|
||||
TSPoint end_point;
|
||||
uint32_t next_state_id;
|
||||
TSClock end_clock;
|
||||
TSDuration timeout_duration;
|
||||
const TSQueryCursorOptions *query_options;
|
||||
TSQueryCursorState query_state;
|
||||
unsigned operation_count;
|
||||
|
|
@ -339,7 +336,7 @@ static const TSQueryError PARENT_DONE = -1;
|
|||
static const uint16_t PATTERN_DONE_MARKER = UINT16_MAX;
|
||||
static const uint16_t NONE = UINT16_MAX;
|
||||
static const TSSymbol WILDCARD_SYMBOL = 0;
|
||||
static const unsigned OP_COUNT_PER_QUERY_TIMEOUT_CHECK = 100;
|
||||
static const unsigned OP_COUNT_PER_QUERY_CALLBACK_CHECK = 100;
|
||||
|
||||
/**********
|
||||
* Stream
|
||||
|
|
@ -3099,8 +3096,6 @@ TSQueryCursor *ts_query_cursor_new(void) {
|
|||
.start_point = {0, 0},
|
||||
.end_point = POINT_MAX,
|
||||
.max_start_depth = UINT32_MAX,
|
||||
.timeout_duration = 0,
|
||||
.end_clock = clock_null(),
|
||||
.operation_count = 0,
|
||||
};
|
||||
array_reserve(&self->states, 8);
|
||||
|
|
@ -3128,14 +3123,6 @@ void ts_query_cursor_set_match_limit(TSQueryCursor *self, uint32_t limit) {
|
|||
self->capture_list_pool.max_capture_list_count = limit;
|
||||
}
|
||||
|
||||
uint64_t ts_query_cursor_timeout_micros(const TSQueryCursor *self) {
|
||||
return duration_to_micros(self->timeout_duration);
|
||||
}
|
||||
|
||||
void ts_query_cursor_set_timeout_micros(TSQueryCursor *self, uint64_t timeout_micros) {
|
||||
self->timeout_duration = duration_from_micros(timeout_micros);
|
||||
}
|
||||
|
||||
#ifdef DEBUG_EXECUTE_QUERY
|
||||
#define LOG(...) fprintf(stderr, __VA_ARGS__)
|
||||
#else
|
||||
|
|
@ -3185,11 +3172,6 @@ void ts_query_cursor_exec(
|
|||
self->query = query;
|
||||
self->did_exceed_match_limit = false;
|
||||
self->operation_count = 0;
|
||||
if (self->timeout_duration) {
|
||||
self->end_clock = clock_after(clock_now(), self->timeout_duration);
|
||||
} else {
|
||||
self->end_clock = clock_null();
|
||||
}
|
||||
self->query_options = NULL;
|
||||
self->query_state = (TSQueryCursorState) {0};
|
||||
}
|
||||
|
|
@ -3614,7 +3596,7 @@ static inline bool ts_query_cursor__advance(
|
|||
}
|
||||
}
|
||||
|
||||
if (++self->operation_count == OP_COUNT_PER_QUERY_TIMEOUT_CHECK) {
|
||||
if (++self->operation_count == OP_COUNT_PER_QUERY_CALLBACK_CHECK) {
|
||||
self->operation_count = 0;
|
||||
}
|
||||
|
||||
|
|
@ -3627,7 +3609,6 @@ static inline bool ts_query_cursor__advance(
|
|||
(
|
||||
self->operation_count == 0 &&
|
||||
(
|
||||
(!clock_is_null(self->end_clock) && clock_is_gt(clock_now(), self->end_clock)) ||
|
||||
(self->query_options && self->query_options->progress_callback && self->query_options->progress_callback(&self->query_state))
|
||||
)
|
||||
)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue