c_cpp_parser.c File Reference

#include <stdio.h>
#include <rz_types.h>
#include <rz_list.h>
#include <rz_util/rz_file.h>
#include <rz_type.h>
#include <tree_sitter/api.h>
#include <types_parser.h>

Go to the source code of this file.

Classes
struct	rz_type_parser_t

Macros
#define	TS_START_END(node, start, end)

Functions
static char *	ts_node_sub_string (TSNode node, const char *cstr)
TSLanguage *	tree_sitter_c ()
CParserState *	c_parser_state_new (HtPP *base_types, HtPP *callable_types)
void	c_parser_state_free (CParserState *state)
void	c_parser_state_free_keep_ht (CParserState *state)
void	c_parser_state_reset_keep_ht (CParserState *state)
RZ_API RZ_OWN RzTypeParser *	rz_type_parser_new ()
	Creates a new instance of the C type parser. More...
RZ_API RZ_OWN RzTypeParser *	rz_type_parser_init (HtPP *types, HtPP *callables)
	Creates a new instance of the C type parser. More...
RZ_API void	rz_type_parser_free (RZ_NONNULL RzTypeParser *parser)
	Frees the instance of the C type parser without destroying hashtables. More...
RZ_API void	rz_type_parser_free_purge (RZ_NONNULL RzTypeParser *parser)
	Frees the instance of the C type parser and destroy the hashtables. More...
static int	type_parse_string (CParserState *state, const char *code, char **error_msg)
RZ_API int	rz_type_parse_string_stateless (RzTypeParser *parser, const char *code, char **error_msg)
	Parses the C type string reusing the existing parser state. More...
RZ_API int	rz_type_parse_file_stateless (RzTypeParser *parser, const char *path, const char *dir, char **error_msg)
	Parses the C types file reusing the existing parser state. More...
RZ_API int	rz_type_parse_file (RzTypeDB *typedb, const char *path, const char *dir, char **error_msg)
	Parses the C types file creating the new parser state. More...
RZ_API int	rz_type_parse_string (RzTypeDB *typedb, const char *code, char **error_msg)
	Parses the C type string creating the new parser state. More...
RZ_API void	rz_type_parse_reset (RzTypeDB *typedb)
	Reset the C parser state. More...
RZ_API RZ_OWN RzType *	rz_type_parse_string_single (RzTypeParser *parser, const char *code, char **error_msg)
	Parses the single C type definition. More...
RZ_API RZ_OWN RzType *	rz_type_parse_string_declaration_single (RzTypeParser *parser, const char *code, char **error_msg)
	Parses the single C type declaration. More...

Macro Definition Documentation

TS_START_END

#define TS_START_END	(		node,
			start,
			end
	)

Value:

    do { \
        start = ts_node_start_byte(node); \
        end = ts_node_end_byte(node); \
    } while (0)

Definition at line 13 of file c_cpp_parser.c.

Function Documentation

c_parser_state_free()

void c_parser_state_free

(

CParserState *

state

)

Definition at line 55 of file c_cpp_parser.c.

                                              {
    ht_pp_free(state->forward);
    ht_pp_free(state->types);
    ht_pp_free(state->callables);
    rz_strbuf_free(state->debug);
    rz_strbuf_free(state->warnings);
    rz_strbuf_free(state->errors);
    free(state);
    return;
}

References free(), and rz_strbuf_free().

Referenced by rz_type_parser_free_purge().

c_parser_state_free_keep_ht()

void c_parser_state_free_keep_ht

(

CParserState *

state

)

Definition at line 66 of file c_cpp_parser.c.

                                                      {
    ht_pp_free(state->forward);
    rz_strbuf_free(state->debug);
    rz_strbuf_free(state->warnings);
    rz_strbuf_free(state->errors);
    free(state);
    return;
}

References free(), and rz_strbuf_free().

Referenced by rz_type_parser_free().

c_parser_state_new()

CParserState* c_parser_state_new	(	HtPP *	base_types,
		HtPP *	callable_types
	)

Definition at line 33 of file c_cpp_parser.c.

                                                                         {
    CParserState *state = RZ_NEW0(CParserState);
    if (!base_types) {
        state->types = ht_pp_new0();
    } else {
        state->types = base_types;
    }
    if (!callable_types) {
        state->callables = ht_pp_new0();
    } else {
        state->callables = callable_types;
    }
    // Forward definitions require to have a special hashtable
    state->forward = ht_pp_new0();
    // Initializing error/warning/debug messages buffers
    state->errors = rz_strbuf_new("");
    state->warnings = rz_strbuf_new("");
    state->debug = rz_strbuf_new("");
    state->verbose = false;
    return state;
}

References RZ_NEW0, and rz_strbuf_new().

Referenced by rz_type_parse_string(), rz_type_parser_init(), and rz_type_parser_new().

c_parser_state_reset_keep_ht()

void c_parser_state_reset_keep_ht

(

CParserState *

state

)

Definition at line 75 of file c_cpp_parser.c.

                                                       {
    rz_strbuf_free(state->debug);
    rz_strbuf_free(state->warnings);
    rz_strbuf_free(state->errors);
    // Initializing error/warning/debug messages buffers
    state->errors = rz_strbuf_new("");
    state->warnings = rz_strbuf_new("");
    state->debug = rz_strbuf_new("");
    return;
}

References rz_strbuf_free(), and rz_strbuf_new().

Referenced by rz_type_parse_string_declaration_single(), and rz_type_parse_string_single().

rz_type_parse_file()

RZ_API int rz_type_parse_file	(	RzTypeDB *	typedb,
		const char *	path,
		const char *	dir,
		char **	error_msg
	)

Parses the C types file creating the new parser state.

Parameters

typedb	RzTypeDB instance
path	The path to the C file to parse
dir	The directory where the C file is located
error_msg	A pointer where all error messages will be stored

Definition at line 260 of file c_cpp_parser.c.

                                                                                                     {
    size_t read_bytes = 0;
    char *source_code = rz_file_slurp(path, &read_bytes);
    if (!source_code || !read_bytes) {
        free(source_code);
        return -1;
    }
    RZ_LOG_DEBUG("File size is %" PFMT64d " bytes, read %zu bytes\n", rz_file_size(path), read_bytes);
    int result = rz_type_parse_string(typedb, source_code, error_msg);
    free(source_code);
    return result;
}

References free(), path, PFMT64d, rz_file_size(), rz_file_slurp(), RZ_LOG_DEBUG, and rz_type_parse_string().

Referenced by cmd_print_format(), and rz_core_run_script().

rz_type_parse_file_stateless()

RZ_API int rz_type_parse_file_stateless	(	RzTypeParser *	parser,
		const char *	path,
		const char *	dir,
		char **	error_msg
	)

Parses the C types file reusing the existing parser state.

Parameters

parser	RzTypeParser instance
path	The path to the C file to parse
dir	The directory where the C file is located
error_msg	A pointer where all error messages will be stored

Definition at line 239 of file c_cpp_parser.c.

                                                                                                                   {
    size_t read_bytes = 0;
    char *source_code = rz_file_slurp(path, &read_bytes);
    if (!source_code || !read_bytes) {
        free(source_code);
        return -1;
    }
    RZ_LOG_DEBUG("File size is %" PFMT64d " bytes, read %zu bytes\n", rz_file_size(path), read_bytes);
    int result = rz_type_parse_string_stateless(parser, source_code, error_msg);
    free(source_code);
    return result;
}

References free(), cmd_descs_generate::parser, path, PFMT64d, rz_file_size(), rz_file_slurp(), RZ_LOG_DEBUG, and rz_type_parse_string_stateless().

Referenced by rz_types_open_file().

rz_type_parse_reset()

RZ_API void rz_type_parse_reset

(

RzTypeDB *

typedb

)

Reset the C parser state.

Parameters

typedb

RzTypeDB instance

Definition at line 297 of file c_cpp_parser.c.

                                                  {
    rz_type_parser_free(typedb->parser);
    typedb->parser = rz_type_parser_new();
}

References rz_type_db_t::parser, rz_type_parser_free(), and rz_type_parser_new().

Referenced by rz_type_del_all_handler().

rz_type_parse_string()

RZ_API int rz_type_parse_string	(	RzTypeDB *	typedb,
		const char *	code,
		char **	error_msg
	)

Parses the C type string creating the new parser state.

Parameters

typedb	RzTypeDB instance
code	The C type itself
error_msg	A pointer where all error messages will be stored

Definition at line 280 of file c_cpp_parser.c.

                                                                                      {
    bool verbose = true;
    // Create new C parser state
    CParserState *state = c_parser_state_new(typedb->types, typedb->callables);
    if (!state) {
        eprintf("CParserState initialization error!\n");
        return -1;
    }
    state->verbose = verbose;
    return type_parse_string(state, code, error_msg);
}

References c_parser_state_new(), rz_type_db_t::callables, eprintf, type_parse_string(), rz_type_db_t::types, and verbose.

Referenced by rz_type_parse_file().

rz_type_parse_string_declaration_single()

RZ_API RZ_OWN RzType* rz_type_parse_string_declaration_single	(	RzTypeParser *	parser,
		const char *	code,
		char **	error_msg
	)

Parses the single C type declaration.

Parameters

parser	RzTypeParser parser instance
code	The C type itself
error_msg	A pointer where all error messages will be stored

Definition at line 411 of file c_cpp_parser.c.

                                                                                                                        {
    if (error_msg) {
        *error_msg = NULL;
    }
    // Create a parser.
    TSParser *tsparser = ts_parser_new();
    // Set the parser's language (C in this case)
    ts_parser_set_language(tsparser, tree_sitter_c());
 
    TSTree *tree = ts_parser_parse_string(tsparser, NULL, code, strlen(code));
 
    // Get the root node of the syntax tree.
    TSNode root_node = ts_tree_root_node(tree);
    int root_node_child_count = ts_node_named_child_count(root_node);
    if (!root_node_child_count) {
        parser_warning(parser->state, "Root node is empty!\n");
        ts_tree_delete(tree);
        ts_parser_delete(tsparser);
        return NULL;
    }
 
    // Some debugging
    if (parser->state->verbose) {
        parser_debug(parser->state, "code: \"%s\"\n", code);
        parser_debug(parser->state, "root_node (%d children): %s\n", root_node_child_count, ts_node_type(root_node));
        // Print the syntax tree as an S-expression.
        char *string = ts_node_string(root_node);
        parser_debug(parser->state, "Syntax tree: %s\n", string);
        free(string);
    }
 
    // At first step we should handle defines
    // #define
    // #if / #ifdef
    // #else
    // #endif
    // After that, we should process include files and #error/#warning/#pragma
    // Temporarily we could just run preprocessing step using tccpp code
    //
    // And only after that - run the normal C/C++ syntax parsing
 
    // Filter types function prototypes and start parsing
    int i = 0, result = 0;
    ParserTypePair *tpair = NULL;
    for (i = 0; i < root_node_child_count; i++) {
        parser_debug(parser->state, "Processing %d child...\n", i);
        TSNode child = ts_node_named_child(root_node, i);
        if (!parse_declaration_node(parser->state, child, code, &tpair)) {
            break;
        }
    }
 
    // If there were errors during the parser then the result is different from 0
    if (result || !tpair) {
        char *error_msgs = rz_strbuf_drain_nofree(parser->state->errors);
        RZ_LOG_DEBUG("Errors:\n");
        RZ_LOG_DEBUG("%s", error_msgs);
        char *warning_msgs = rz_strbuf_drain_nofree(parser->state->warnings);
        RZ_LOG_DEBUG("Warnings:\n");
        RZ_LOG_DEBUG("%s", warning_msgs);
        if (error_msg) {
            *error_msg = strdup(error_msgs);
        }
        free(error_msgs);
        free(warning_msgs);
    }
    if (parser->state->verbose) {
        char *debug_msgs = rz_strbuf_drain_nofree(parser->state->debug);
        RZ_LOG_DEBUG("%s", debug_msgs);
        free(debug_msgs);
    }
 
    // After everything parsed, we should preserve the base type database
    // Also we don't free the parser state, just reset the buffers for new use
    c_parser_state_reset_keep_ht(parser->state);
    ts_tree_delete(tree);
    ts_parser_delete(tsparser);
    return tpair ? tpair->type : NULL;
}

References c_parser_state_reset_keep_ht(), free(), i, NULL, parse_declaration_node(), cmd_descs_generate::parser, parser_debug(), parser_warning(), RZ_LOG_DEBUG, rz_strbuf_drain_nofree(), strdup(), tree_sitter_c(), ts_node_named_child(), ts_node_named_child_count(), ts_node_string(), ts_node_type(), ts_parser_delete(), ts_parser_new(), ts_parser_parse_string(), ts_parser_set_language(), ts_tree_delete(), ts_tree_root_node(), and ParserTypePair::type.

Referenced by rz_analysis_function_set_type_str().

rz_type_parse_string_single()

RZ_API RZ_OWN RzType* rz_type_parse_string_single	(	RzTypeParser *	parser,
		const char *	code,
		char **	error_msg
	)

Parses the single C type definition.

Parameters

parser	RzTypeParser parser instance
code	The C type itself
error_msg	A pointer where all error messages will be stored

Definition at line 309 of file c_cpp_parser.c.

                                                                                                            {
    rz_return_val_if_fail(parser && code, NULL);
    if (error_msg) {
        *error_msg = NULL;
    }
    // Create a parser.
    TSParser *tsparser = ts_parser_new();
    // Set the parser's language (C in this case)
    ts_parser_set_language(tsparser, tree_sitter_c());
 
    // Note, that the original C grammar doesn't have support for alternate roots,
    // see:
    // - https://github.com/tree-sitter/tree-sitter-c/issues/65
    // - https://github.com/tree-sitter/tree-sitter/issues/1105
    // Thus, we use our own patched C grammar that has an additional rule
    // for type descriptor, but we use the `__TYPE_EXPRESSION` prefix for every
    // such type descriptor expression.
    char *patched_code = rz_str_newf("__TYPE_EXPRESSION %s", code);
 
    TSTree *tree = ts_parser_parse_string(tsparser, NULL, patched_code, strlen(patched_code));
 
    // Get the root node of the syntax tree.
    TSNode root_node = ts_tree_root_node(tree);
    int root_node_child_count = ts_node_named_child_count(root_node);
    if (!root_node_child_count) {
        parser_warning(parser->state, "Root node is empty!\n");
        ts_tree_delete(tree);
        ts_parser_delete(tsparser);
        free(patched_code);
        return NULL;
    }
 
    // Some debugging
    if (parser->state->verbose) {
        parser_debug(parser->state, "code: \"%s\"\n", code);
        parser_debug(parser->state, "patched code: \"%s\"\n", patched_code);
        parser_debug(parser->state, "root_node (%d children): %s\n", root_node_child_count, ts_node_type(root_node));
        // Print the syntax tree as an S-expression.
        char *string = ts_node_string(root_node);
        parser_debug(parser->state, "Syntax tree: %s\n", string);
        free(string);
    }
 
    // At first step we should handle defines
    // #define
    // #if / #ifdef
    // #else
    // #endif
    // After that, we should process include files and #error/#warning/#pragma
    // Temporarily we could just run preprocessing step using tccpp code
    //
    // And only after that - run the normal C/C++ syntax parsing
 
    // Filter types function prototypes and start parsing
    int i = 0, result = 0;
    ParserTypePair *tpair = NULL;
    for (i = 0; i < root_node_child_count; i++) {
        parser_debug(parser->state, "Processing %d child...\n", i);
        TSNode child = ts_node_named_child(root_node, i);
        if (!parse_type_descriptor_single(parser->state, child, patched_code, &tpair)) {
            break;
        }
    }
 
    // If there were errors during the parser then the result is different from 0
    if (result || !tpair) {
        char *error_msgs = rz_strbuf_drain_nofree(parser->state->errors);
        RZ_LOG_DEBUG("Errors:\n");
        RZ_LOG_DEBUG("%s", error_msgs);
        char *warning_msgs = rz_strbuf_drain_nofree(parser->state->warnings);
        RZ_LOG_DEBUG("Warnings:\n");
        RZ_LOG_DEBUG("%s", warning_msgs);
        if (error_msg) {
            *error_msg = strdup(error_msgs);
        }
        free(error_msgs);
        free(warning_msgs);
    }
    if (parser->state->verbose) {
        char *debug_msgs = rz_strbuf_drain_nofree(parser->state->debug);
        RZ_LOG_DEBUG("%s", debug_msgs);
        free(debug_msgs);
    }
 
    // After everything parsed, we should preserve the base type database
    // Also we don't free the parser state, just reset the buffers for new use
    c_parser_state_reset_keep_ht(parser->state);
    ts_tree_delete(tree);
    ts_parser_delete(tsparser);
    free(patched_code);
    RzType *ret = tpair ? tpair->type : NULL;
    free(tpair);
    return ret;
}

References c_parser_state_reset_keep_ht(), free(), i, NULL, parse_type_descriptor_single(), cmd_descs_generate::parser, parser_debug(), parser_warning(), RZ_LOG_DEBUG, rz_return_val_if_fail, rz_str_newf(), rz_strbuf_drain_nofree(), strdup(), tree_sitter_c(), ts_node_named_child(), ts_node_named_child_count(), ts_node_string(), ts_node_type(), ts_parser_delete(), ts_parser_new(), ts_parser_parse_string(), ts_parser_set_language(), ts_tree_delete(), ts_tree_root_node(), and ParserTypePair::type.

Referenced by get_struct_type(), get_typedef_type(), get_union_type(), parse_enum_type(), parse_struct_member(), parse_type(), parse_type_string_cached(), parse_typedef(), rz_analysis_dwarf_integrate_functions(), rz_analysis_function_signature_type_handler(), rz_analysis_function_vars_bp_handler(), rz_analysis_function_vars_regs_handler(), rz_analysis_function_vars_sp_handler(), rz_analysis_function_vars_type_handler(), rz_analysis_global_variable_add_handler(), rz_analysis_global_variable_retype_handler(), rz_core_types_link(), type_match(), typelinks_load_sdb(), types_xrefs(), var_type_clone_or_default_type(), var_type_set_str(), and variable_set_type().

rz_type_parse_string_stateless()

RZ_API int rz_type_parse_string_stateless	(	RzTypeParser *	parser,
		const char *	code,
		char **	error_msg
	)

Parses the C type string reusing the existing parser state.

Parameters

parser	RzTypeParser instance
code	The C type itself
error_msg	A pointer where all error messages will be stored

Definition at line 227 of file c_cpp_parser.c.

                                                                                                    {
    return type_parse_string(parser->state, code, error_msg);
}

References cmd_descs_generate::parser, and type_parse_string().

Referenced by rz_core_bin_export_info(), rz_type_db_edit_base_type(), rz_type_parse_file_stateless(), rz_types_define(), and rz_types_open_file().

rz_type_parser_free()

RZ_API void rz_type_parser_free

(

RZ_NONNULL RzTypeParser *

parser

)

Frees the instance of the C type parser without destroying hashtables.

Definition at line 127 of file c_cpp_parser.c.

                                                                 {
    // We do not destroy HT by default since it might be used after
    c_parser_state_free_keep_ht(parser->state);
    free(parser);
}

References c_parser_state_free_keep_ht(), free(), and cmd_descs_generate::parser.

Referenced by rz_type_db_free(), rz_type_db_purge(), and rz_type_parse_reset().

rz_type_parser_free_purge()

RZ_API void rz_type_parser_free_purge

(

RZ_NONNULL RzTypeParser *

parser

)

Frees the instance of the C type parser and destroy the hashtables.

Definition at line 136 of file c_cpp_parser.c.

                                                                       {
    c_parser_state_free(parser->state);
    free(parser);
}

References c_parser_state_free(), free(), and cmd_descs_generate::parser.

rz_type_parser_init()

RZ_API RZ_OWN RzTypeParser* rz_type_parser_init	(	HtPP *	types,
		HtPP *	callables
	)

Creates a new instance of the C type parser.

Creates the new instance of the C types parser preloaded hashtables for RzBaseTypes and RzCallable types. It will use provided hashtables for storing the parsed types as well.

Parameters

type	RzBaseTypes hashtable to preload into the parser state
type	RzCallable hashtable to preload into the parser state

Definition at line 115 of file c_cpp_parser.c.

                                                                              {
    RzTypeParser *parser = RZ_NEW0(RzTypeParser);
    if (!parser) {
        return NULL;
    }
    parser->state = c_parser_state_new(types, callables);
    return parser;
}

References c_parser_state_new(), NULL, cmd_descs_generate::parser, RZ_NEW0, and types.

Referenced by rz_type_db_new(), and rz_type_db_purge().

rz_type_parser_new()

RZ_API RZ_OWN RzTypeParser* rz_type_parser_new

(

)

Creates a new instance of the C type parser.

Creates the new instance of the C types parser with empty hashtables for RzBaseTypes and RzCallable types.

Definition at line 96 of file c_cpp_parser.c.

                                                 {
    RzTypeParser *parser = RZ_NEW0(RzTypeParser);
    if (!parser) {
        return NULL;
    }
    parser->state = c_parser_state_new(NULL, NULL);
    return parser;
}

References c_parser_state_new(), NULL, cmd_descs_generate::parser, and RZ_NEW0.

Referenced by rz_type_parse_reset().

tree_sitter_c()

TSLanguage* tree_sitter_c

(

)

Definition at line 79645 of file parser.c.

                                             {
  static const TSLanguage language = {
    .version = LANGUAGE_VERSION,
    .symbol_count = SYMBOL_COUNT,
    .alias_count = ALIAS_COUNT,
    .token_count = TOKEN_COUNT,
    .external_token_count = EXTERNAL_TOKEN_COUNT,
    .state_count = STATE_COUNT,
    .large_state_count = LARGE_STATE_COUNT,
    .production_id_count = PRODUCTION_ID_COUNT,
    .field_count = FIELD_COUNT,
    .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH,
    .parse_table = &ts_parse_table[0][0],
    .small_parse_table = ts_small_parse_table,
    .small_parse_table_map = ts_small_parse_table_map,
    .parse_actions = ts_parse_actions,
    .symbol_names = ts_symbol_names,
    .field_names = ts_field_names,
    .field_map_slices = ts_field_map_slices,
    .field_map_entries = ts_field_map_entries,
    .symbol_metadata = ts_symbol_metadata,
    .public_symbol_map = ts_symbol_map,
    .alias_map = ts_non_terminal_alias_map,
    .alias_sequences = &ts_alias_sequences[0][0],
    .lex_modes = ts_lex_modes,
    .lex_fn = ts_lex,
    .keyword_lex_fn = ts_lex_keywords,
    .keyword_capture_token = sym_identifier,
  };
  return &language;
}

References ALIAS_COUNT, EXTERNAL_TOKEN_COUNT, FIELD_COUNT, LANGUAGE_VERSION, LARGE_STATE_COUNT, MAX_ALIAS_SEQUENCE_LENGTH, PRODUCTION_ID_COUNT, STATE_COUNT, sym_identifier, SYMBOL_COUNT, TOKEN_COUNT, ts_alias_sequences, ts_field_map_entries, ts_field_map_slices, ts_field_names, ts_lex(), ts_lex_keywords(), ts_lex_modes, ts_non_terminal_alias_map, ts_parse_actions, ts_parse_table, ts_small_parse_table, ts_small_parse_table_map, ts_symbol_map, ts_symbol_metadata, ts_symbol_names, and TSLanguage::version.

Referenced by rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), and type_parse_string().

ts_node_sub_string()

static char* ts_node_sub_string ( TSNode  node, const char *  cstr  )

static

Definition at line 19 of file c_cpp_parser.c.

                                                               {
    ut32 start, end;
    TS_START_END(node, start, end);
    return rz_str_newf("%.*s", end - start, cstr + start);
}

References test_evm::end, rz_str_newf(), start, and TS_START_END.

Referenced by type_parse_string().

type_parse_string()

static int type_parse_string ( CParserState *  state, const char *  code, char **  error_msg  )

static

Definition at line 141 of file c_cpp_parser.c.

                                                                                      {
    // Create a parser.
    TSParser *parser = ts_parser_new();
    // Set the parser's language (C in this case)
    ts_parser_set_language(parser, tree_sitter_c());
 
    TSTree *tree = ts_parser_parse_string(parser, NULL, code, strlen(code));
 
    // Get the root node of the syntax tree.
    TSNode root_node = ts_tree_root_node(tree);
    int root_node_child_count = ts_node_named_child_count(root_node);
    if (!root_node_child_count) {
        parser_warning(state, "Root node is empty!\n");
        ts_tree_delete(tree);
        ts_parser_delete(parser);
        return 0;
    }
 
    // Some debugging
    if (state->verbose) {
        parser_debug(state, "root_node (%d children): %s\n", root_node_child_count, ts_node_type(root_node));
        // Print the syntax tree as an S-expression.
        char *string = ts_node_string(root_node);
        parser_debug(state, "Syntax tree: %s\n", string);
        free(string);
    }
 
    // At first step we should handle defines
    // #define
    // #if / #ifdef
    // #else
    // #endif
    // After that, we should process include files and #error/#warning/#pragma
    // Temporarily we could just run preprocessing step using tccpp code
    //
    // And only after that - run the normal C/C++ syntax parsing
 
    // Filter types function prototypes and start parsing
    int i = 0, result = 0;
    for (i = 0; i < root_node_child_count; i++) {
        TSNode child = ts_node_named_child(root_node, i);
        // We skip ";" or "," - empty expressions
        char *node_code = ts_node_sub_string(child, code);
        if (!strcmp(node_code, ";") || !strcmp(node_code, ",")) {
            free(node_code);
            continue;
        }
        free(node_code);
        parser_debug(state, "Processing %d child...\n", i);
        result += parse_type_nodes_save(state, child, code);
    }
 
    // If there were errors during the parser then the result is different from 0
    if (result) {
        char *error_msgs = rz_strbuf_drain_nofree(state->errors);
        RZ_LOG_DEBUG("Errors:\n");
        RZ_LOG_DEBUG("%s", error_msgs);
        char *warning_msgs = rz_strbuf_drain_nofree(state->warnings);
        RZ_LOG_DEBUG("Warnings:\n");
        RZ_LOG_DEBUG("%s", warning_msgs);
        if (error_msg) {
            *error_msg = strdup(error_msgs);
        }
        free(error_msgs);
        free(warning_msgs);
    }
    if (state->verbose) {
        char *debug_msgs = rz_strbuf_drain_nofree(state->debug);
        RZ_LOG_DEBUG("%s", debug_msgs);
        free(debug_msgs);
    }
 
    // After everything parsed, we should preserve the base type database
    // And the state of the parser - anonymous structs, forward declarations, etc
    ts_tree_delete(tree);
    ts_parser_delete(parser);
    return result;
}

References free(), i, NULL, parse_type_nodes_save(), cmd_descs_generate::parser, parser_debug(), parser_warning(), RZ_LOG_DEBUG, rz_strbuf_drain_nofree(), strdup(), tree_sitter_c(), ts_node_named_child(), ts_node_named_child_count(), ts_node_string(), ts_node_sub_string(), ts_node_type(), ts_parser_delete(), ts_parser_new(), ts_parser_parse_string(), ts_parser_set_language(), ts_tree_delete(), and ts_tree_root_node().

Referenced by rz_type_parse_string(), and rz_type_parse_string_stateless().