tree-sitter/src/runtime/parser.h

#ifndef RUNTIME_PARSER_H_
#define RUNTIME_PARSER_H_

#ifdef __cplusplus
extern "C" {
#endif

#include "runtime/stack.h"
#include "runtime/array.h"
#include "runtime/lexer.h"
#include "runtime/reduce_action.h"

typedef struct {
  Tree *tree;
  uint32_t byte_index;
} ReusableNode;

typedef struct {
  Lexer lexer;
  Stack *stack;
  const TSLanguage *language;
  ReduceActionSet reduce_actions;
  Tree *finished_tree;
  bool is_split;
  bool print_debugging_graphs;
  Tree scratch_tree;
  Tree *cached_token;
  uint32_t cached_token_byte_index;
  ReusableNode reusable_node;
  TreePath tree_path1;
  TreePath tree_path2;
  void *external_scanner_payload;
  Tree *last_external_token;
} Parser;

bool parser_init(Parser *);
void parser_destroy(Parser *);
Tree *parser_parse(Parser *, TSInput, Tree *);
void parser_set_language(Parser *, const TSLanguage *);

#ifdef __cplusplus
}
#endif

#endif  // RUNTIME_PARSER_H_
Remove generated parsers' dependency on the runtime library Generated parsers no longer export a parser constructor function. They now export an opaque Language object which can be set on Documents directly. This way, the logic for constructing parsers lives entirely in the runtime. The Languages are just structs which have no load-time dependency on the runtime 2014-07-30 23:40:02 -07:00			`#ifndef RUNTIME_PARSER_H_`
			`#define RUNTIME_PARSER_H_`

			`#ifdef __cplusplus`
			`extern "C" {`
			`#endif`

Rename ParseStack -> Stack 2015-09-18 18:04:52 -07:00			`#include "runtime/stack.h"`
Rename Vector -> Array 2016-02-17 20:41:29 -08:00			`#include "runtime/array.h"`
Remove generated parsers' dependency on runtime.h 2016-10-05 14:02:49 -07:00			`#include "runtime/lexer.h"`
Discard tokens after error detection to find the best repair * Use GLR stack-splitting to try all numbers of tokens to discard until a repair is found. * Check the validity of repairs by looking at the child trees, rather than the statically-computed 'in-progress symbols' list 2016-05-09 14:31:44 -07:00			`#include "runtime/reduce_action.h"`
Make vector struct type-safe 2016-02-17 14:45:00 -08:00
Allow lookahead to be broken down further after performing reductions 2016-07-01 15:08:19 -07:00			`typedef struct {`
Remove the TS prefix from some internal type/function names 2016-11-09 20:59:05 -08:00			`Tree *tree;`
Represent byte, char and tree counts as 32 bit numbers The parser spends the majority of its time allocating and freeing trees and stack nodes. Also, the memory footprint of the AST is a significant concern when using tree-sitter with large files. This library is already unlikely to work very well with source files larger than 4GB, so representing rows, columns, byte lengths and child indices as unsigned 32 bit integers seems like the right choice. 2016-11-14 12:15:24 -08:00			`uint32_t byte_index;`
Allow lookahead to be broken down further after performing reductions 2016-07-01 15:08:19 -07:00			`} ReusableNode;`

Remove generated parsers' dependency on the runtime library Generated parsers no longer export a parser constructor function. They now export an opaque Language object which can be set on Documents directly. This way, the logic for constructing parsers lives entirely in the runtime. The Languages are just structs which have no load-time dependency on the runtime 2014-07-30 23:40:02 -07:00			`typedef struct {`
Remove generated parsers' dependency on runtime.h 2016-10-05 14:02:49 -07:00			`Lexer lexer;`
Rename ParseStack -> Stack 2015-09-18 18:04:52 -07:00			`Stack *stack;`
Remove generated parsers' dependency on the runtime library Generated parsers no longer export a parser constructor function. They now export an opaque Language object which can be set on Documents directly. This way, the logic for constructing parsers lives entirely in the runtime. The Languages are just structs which have no load-time dependency on the runtime 2014-07-30 23:40:02 -07:00			`const TSLanguage *language;`
Discard tokens after error detection to find the best repair * Use GLR stack-splitting to try all numbers of tokens to discard until a repair is found. * Check the validity of repairs by looking at the child trees, rather than the statically-computed 'in-progress symbols' list 2016-05-09 14:31:44 -07:00			`ReduceActionSet reduce_actions;`
Remove the TS prefix from some internal type/function names 2016-11-09 20:59:05 -08:00			`Tree *finished_tree;`
Track whether parse stack was split before consuming each lookahead 2015-12-09 14:33:54 -08:00			`bool is_split;`
Add a public function for printing debugging graphs 2016-02-23 11:16:50 -08:00			`bool print_debugging_graphs;`
Remove the TS prefix from some internal type/function names 2016-11-09 20:59:05 -08:00			`Tree scratch_tree;`
			`Tree *cached_token;`
Represent byte, char and tree counts as 32 bit numbers The parser spends the majority of its time allocating and freeing trees and stack nodes. Also, the memory footprint of the AST is a significant concern when using tree-sitter with large files. This library is already unlikely to work very well with source files larger than 4GB, so representing rows, columns, byte lengths and child indices as unsigned 32 bit integers seems like the right choice. 2016-11-14 12:15:24 -08:00			`uint32_t cached_token_byte_index;`
Allow lookahead to be broken down further after performing reductions 2016-07-01 15:08:19 -07:00			`ReusableNode reusable_node;`
Implement ts_document_parse_and_get_changed_ranges 2016-09-22 18:02:11 -07:00			`TreePath tree_path1;`
			`TreePath tree_path2;`
Call external scanner functions when lexing 2016-12-02 22:03:48 -08:00			`void *external_scanner_payload;`
Start work toward maintaining external scanner's state during incremental parses 2016-12-20 17:06:20 -08:00			`Tree *last_external_token;`
Replace ts_parser -> parser 2016-08-29 12:08:58 -07:00			`} Parser;`
Remove generated parsers' dependency on the runtime library Generated parsers no longer export a parser constructor function. They now export an opaque Language object which can be set on Documents directly. This way, the logic for constructing parsers lives entirely in the runtime. The Languages are just structs which have no load-time dependency on the runtime 2014-07-30 23:40:02 -07:00
Replace ts_parser -> parser 2016-08-29 12:08:58 -07:00			`bool parser_init(Parser *);`
			`void parser_destroy(Parser *);`
Remove the TS prefix from some internal type/function names 2016-11-09 20:59:05 -08:00			`Tree parser_parse(Parser , TSInput, Tree *);`
Call external scanner functions when lexing 2016-12-02 22:03:48 -08:00			`void parser_set_language(Parser , const TSLanguage );`
Remove generated parsers' dependency on the runtime library Generated parsers no longer export a parser constructor function. They now export an opaque Language object which can be set on Documents directly. This way, the logic for constructing parsers lives entirely in the runtime. The Languages are just structs which have no load-time dependency on the runtime 2014-07-30 23:40:02 -07:00
			`#ifdef __cplusplus`
			`}`
			`#endif`

			`#endif // RUNTIME_PARSER_H_`