types_parser.h File Reference

Go to the source code of this file.

Classes
struct	CParserAnonymousTypesState
struct	CParserState
struct	ParserTypePair

Functions
CParserState *	c_parser_state_new (HtPP *base_types, HtPP *callable_types)
void	c_parser_state_free (CParserState *state)
int	parse_type_nodes_save (CParserState *state, TSNode node, const char *text)
int	parse_type_node_single (CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, bool is_const)
int	parse_declaration_node (CParserState *state, TSNode node, const char *text, ParserTypePair **tpair)
int	parse_type_descriptor_single (CParserState *state, TSNode node, const char *text, ParserTypePair **tpair)
int	parse_type_declarator_node (CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, char **identifier)
int	parse_type_abstract_declarator_node (CParserState *state, TSNode node, const char *text, ParserTypePair **tpair)
void	parser_debug (CParserState *state, const char *fmt,...)
void	parser_error (CParserState *state, const char *fmt,...)
void	parser_warning (CParserState *state, const char *fmt,...)
RzBaseType *	c_parser_base_type_find (CParserState *state, RZ_NONNULL const char *name)
bool	c_parser_base_type_is_forward_definition (CParserState *state, RZ_NONNULL const char *name)
bool	c_parser_base_type_exists (CParserState *state, RZ_NONNULL const char *name)
bool	c_parser_base_type_store (CParserState *state, RZ_NONNULL const char *name, ParserTypePair *tpair)
bool	c_parser_forward_definition_store (CParserState *state, RZ_NONNULL const char *name)
bool	c_parser_forward_definition_remove (CParserState *state, RZ_NONNULL const char *name)
RzCallable *	c_parser_callable_type_find (CParserState *state, RZ_NONNULL const char *name)
bool	c_parser_callable_type_exists (CParserState *state, RZ_NONNULL const char *name)
bool	c_parser_callable_type_store (CParserState *state, RZ_NONNULL const char *name, RZ_NONNULL RzType *type)
RZ_OWN ParserTypePair *	c_parser_new_unspecified_naked_type (CParserState *state, RZ_NONNULL const char *name, bool is_const)
	Creates new unspecified naked type (without base type) based on the name. More...
RZ_OWN ParserTypePair *	c_parser_new_primitive_type (CParserState *state, RZ_NONNULL const char *name, bool is_const)
	Creates new primitive type based on the name. More...
RZ_OWN ParserTypePair *	c_parser_get_primitive_type (CParserState *state, RZ_NONNULL const char *name, bool is_const)
	Returns the primitive type if matching in the types hashtable. More...
RZ_OWN ParserTypePair *	c_parser_new_structure_naked_type (CParserState *state, RZ_NONNULL const char *name)
	Creates new structure naked type (without base type) based on the name. More...
RZ_OWN ParserTypePair *	c_parser_new_structure_type (CParserState *state, RZ_NONNULL const char *name, size_t members_count)
	Creates new structure "type + base type" pair based on the name. More...
RZ_OWN ParserTypePair *	c_parser_get_structure_type (CParserState *state, RZ_NONNULL const char *name)
	Returns the structure type if matching in the types hashtable. More...
RZ_OWN ParserTypePair *	c_parser_new_structure_forward_definition (CParserState *state, RZ_NONNULL const char *name)
	Creates new structure forward definition. More...
RZ_OWN ParserTypePair *	c_parser_new_union_naked_type (CParserState *state, RZ_NONNULL const char *name)
	Creates new union naked type (without base type) based on the name. More...
RZ_OWN ParserTypePair *	c_parser_new_union_type (CParserState *state, RZ_NONNULL const char *name, size_t members_count)
	Creates new union "type + base type" pair based on the name. More...
RZ_OWN ParserTypePair *	c_parser_get_union_type (CParserState *state, RZ_NONNULL const char *name)
	Returns the union type if matching in the types hashtable. More...
RZ_OWN ParserTypePair *	c_parser_new_union_forward_definition (CParserState *state, RZ_NONNULL const char *name)
	Creates new union forward definition. More...
RZ_OWN ParserTypePair *	c_parser_new_enum_naked_type (CParserState *state, RZ_NONNULL const char *name)
	Creates new enum naked type (without base type) based on the name. More...
RZ_OWN ParserTypePair *	c_parser_new_enum_type (CParserState *state, RZ_NONNULL const char *name, size_t cases_count)
	Creates new enumeration type based on the name. More...
RZ_OWN ParserTypePair *	c_parser_get_enum_type (CParserState *state, RZ_NONNULL const char *name)
	Returns the enum type if matching in the types hashtable. More...
RZ_OWN ParserTypePair *	c_parser_new_enum_forward_definition (CParserState *state, RZ_NONNULL const char *name)
	Creates new enum forward definition. More...
RZ_OWN ParserTypePair *	c_parser_new_typedef (CParserState *state, RZ_NONNULL const char *name, RZ_NONNULL const char *base)
	Creates new type alias based on the name. More...
RZ_OWN ParserTypePair *	c_parser_get_typedef (CParserState *state, RZ_NONNULL const char *name)
	Returns the type if matching in the types hashtable. More...
RZ_OWN RzType *	c_parser_new_naked_callable (CParserState *state)
	Creates new naked callable without storing it. More...
RZ_OWN RzType *	c_parser_new_callable (CParserState *state, RZ_NONNULL const char *name)
	Creates new callable based on the name. More...
bool	c_parser_new_callable_argument (CParserState *state, RZ_NONNULL RzCallable *callable, RZ_NONNULL const char *name, RZ_OWN RZ_NONNULL RzType *type)
	Adds a new argument to the callable. More...
RZ_OWN ParserTypePair *	c_parser_type_wrap_to_pointer (CParserState *state, ParserTypePair *tpair, bool is_const)
RZ_OWN ParserTypePair *	c_parser_type_wrap_to_array (CParserState *state, ParserTypePair *tpair, size_t size)
bool	c_parser_pointer_set_subtype (CParserState *state, RZ_BORROW ParserTypePair *tpair, RZ_OWN ParserTypePair *subpair)
bool	c_parser_array_set_subtype (CParserState *state, RZ_BORROW ParserTypePair *tpair, RZ_OWN ParserTypePair *subpair)
RZ_OWN char *	c_parser_new_anonymous_structure_name (CParserState *state)
RZ_OWN char *	c_parser_new_anonymous_union_name (CParserState *state)
RZ_OWN char *	c_parser_new_anonymous_enum_name (CParserState *state)
RZ_OWN char *	c_parser_new_anonymous_callable_name (CParserState *state)

Function Documentation

c_parser_array_set_subtype()

bool c_parser_array_set_subtype	(	CParserState *	state,
		RZ_BORROW ParserTypePair *	tpair,
		RZ_OWN ParserTypePair *	subpair
	)

Definition at line 889 of file types_storage.c.

                                                                                                                      {
    rz_return_val_if_fail(state && tpair, false);
    rz_return_val_if_fail(tpair->type->kind == RZ_TYPE_KIND_ARRAY, false);
    tpair->type->array.type = subpair->type;
    tpair->btype = subpair->btype;
    return true;
}

References rz_return_val_if_fail, and RZ_TYPE_KIND_ARRAY.

c_parser_base_type_exists()

bool c_parser_base_type_exists	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Definition at line 32 of file types_storage.c.

                                                                                 {
    return c_parser_base_type_find(state, name) != NULL;
}

References c_parser_base_type_find(), and NULL.

Referenced by c_parser_base_type_store(), c_parser_forward_definition_remove(), c_parser_forward_definition_store(), c_parser_new_enum_forward_definition(), c_parser_new_enum_type(), c_parser_new_primitive_type(), c_parser_new_structure_forward_definition(), c_parser_new_structure_type(), c_parser_new_typedef(), c_parser_new_typedef_forward_definition(), c_parser_new_union_forward_definition(), and c_parser_new_union_type().

c_parser_base_type_find()

RzBaseType* c_parser_base_type_find	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Definition at line 17 of file types_storage.c.

                                                                                      {
    bool found = false;
    RzBaseType *base_type = ht_pp_find(state->types, name, &found);
    if (!found || !base_type) {
        return NULL;
    }
    return base_type;
}

References found, and NULL.

Referenced by c_parser_base_type_exists(), c_parser_get_enum_type(), c_parser_get_primitive_type(), c_parser_get_structure_type(), c_parser_get_typedef(), and c_parser_get_union_type().

c_parser_base_type_is_forward_definition()

bool c_parser_base_type_is_forward_definition	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Definition at line 26 of file types_storage.c.

                                                                                                {
    bool found = false;
    ht_pp_find(state->forward, name, &found);
    return found;
}

References found.

Referenced by c_parser_forward_definition_store(), c_parser_new_enum_forward_definition(), c_parser_new_structure_forward_definition(), c_parser_new_typedef_forward_definition(), c_parser_new_union_forward_definition(), parse_enum_node(), parse_sole_type_name(), parse_struct_node(), parse_typedef_node(), and parse_union_node().

c_parser_base_type_store()

bool c_parser_base_type_store	(	CParserState *	state,
		RZ_NONNULL const char *	name,
		ParserTypePair *	tpair
	)

Definition at line 36 of file types_storage.c.

                                                                                                       {
    rz_return_val_if_fail(state && name && tpair && tpair->btype, -1);
 
    if (c_parser_base_type_exists(state, name)) {
        // We don't create the type if it exists already in the parser
        // state with the same name
        return false;
    }
 
    // We store only RzBaseType part of the type pair
    ht_pp_insert(state->types, name, tpair->btype);
    return true;
}

References ParserTypePair::btype, c_parser_base_type_exists(), and rz_return_val_if_fail.

Referenced by parse_enum_node(), parse_primitive_type(), parse_sized_primitive_type(), parse_struct_node(), parse_typedef_node(), and parse_union_node().

c_parser_callable_type_exists()

bool c_parser_callable_type_exists	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Definition at line 94 of file types_storage.c.

                                                                                     {
    return c_parser_callable_type_find(state, name) != NULL;
}

References c_parser_callable_type_find(), and NULL.

Referenced by c_parser_callable_type_store().

c_parser_callable_type_find()

RzCallable* c_parser_callable_type_find	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Definition at line 85 of file types_storage.c.

                                                                                          {
    bool found = false;
    RzCallable *callable = ht_pp_find(state->callables, name, &found);
    if (!found || !callable) {
        return NULL;
    }
    return callable;
}

References found, and NULL.

Referenced by c_parser_callable_type_exists().

c_parser_callable_type_store()

bool c_parser_callable_type_store	(	CParserState *	state,
		RZ_NONNULL const char *	name,
		RZ_NONNULL RzType *	type
	)

Definition at line 98 of file types_storage.c.

                                                                                                             {
    rz_return_val_if_fail(state && name && type, -1);
    rz_return_val_if_fail(type->kind == RZ_TYPE_KIND_CALLABLE, -1);
    rz_return_val_if_fail(type->callable, -1);
 
    if (c_parser_callable_type_exists(state, name)) {
        // We don't create the type if it exists already in the parser
        // state with the same name
        return false;
    }
 
    ht_pp_insert(state->callables, name, type->callable);
    parser_debug(state, "Stored \"%s\" callable type\n", name);
    return true;
}

References c_parser_callable_type_exists(), parser_debug(), rz_return_val_if_fail, RZ_TYPE_KIND_CALLABLE, and type.

Referenced by parse_type_abstract_declarator_node(), and parse_type_declarator_node().

c_parser_forward_definition_remove()

bool c_parser_forward_definition_remove	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Definition at line 70 of file types_storage.c.

                                                                                          {
    rz_return_val_if_fail(state && name, -1);
 
    if (c_parser_base_type_exists(state, name)) {
        // We don't create the forward definition if it exists already in the parser
        // types table state with the same name
        return false;
    }
 
    ht_pp_delete(state->forward, name);
    return true;
}

References c_parser_base_type_exists(), and rz_return_val_if_fail.

Referenced by parse_enum_node(), parse_struct_node(), parse_typedef_node(), and parse_union_node().

c_parser_forward_definition_store()

bool c_parser_forward_definition_store	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Definition at line 50 of file types_storage.c.

                                                                                         {
    rz_return_val_if_fail(state && name, -1);
 
    if (c_parser_base_type_exists(state, name)) {
        // We don't create the forward definition if it exists already in the parser
        // types table state with the same name
        return false;
    }
 
    if (c_parser_base_type_is_forward_definition(state, name)) {
        // We don't create the forward definition if it already stored
        // as the forward definition with the same name
        return false;
    }
 
    // We store only the type name
    ht_pp_insert(state->forward, name, NULL);
    return true;
}

References c_parser_base_type_exists(), c_parser_base_type_is_forward_definition(), NULL, and rz_return_val_if_fail.

Referenced by c_parser_new_typedef(), and parse_sole_type_name().

c_parser_get_enum_type()

RZ_OWN ParserTypePair* c_parser_get_enum_type	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Returns the enum type if matching in the types hashtable.

If the name matches with the name of one of the base types that are in the hashtable of the existing types in the parser state, then it creates new RzType with the found RzBaseType as a base. Then it wraps boths in the "type pair"

Parameters

state	The parser state
name	Name of the enum type to fetch

Definition at line 573 of file types_storage.c.

                                                                                                {
    rz_return_val_if_fail(state && name, NULL);
 
    RzBaseType *base_type = c_parser_base_type_find(state, name);
    if (!base_type || base_type->kind != RZ_BASE_TYPE_KIND_ENUM) {
        return NULL;
    }
 
    ParserTypePair *tpair = c_parser_new_enum_naked_type(state, name);
    if (!tpair) {
        return NULL;
    }
 
    tpair->btype = base_type;
    return tpair;
}

References ParserTypePair::btype, c_parser_base_type_find(), c_parser_new_enum_naked_type(), rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_ENUM, and rz_return_val_if_fail.

Referenced by parse_enum_node().

c_parser_get_primitive_type()

RZ_OWN ParserTypePair* c_parser_get_primitive_type	(	CParserState *	state,
		RZ_NONNULL const char *	name,
		bool	is_const
	)

Returns the primitive type if matching in the types hashtable.

If the name matches with the name of one of the base types that are in the hashtable of the existing types in the parser state, then it creates new RzType with the found RzBaseType as a base. Then it wraps boths in the "type pair"

Parameters

state	The parser state
name	Name of the primitive type to fetch
is_const	If the primitive type is const

Definition at line 209 of file types_storage.c.

                                                                                                                    {
    rz_return_val_if_fail(state && name, NULL);
 
    RzBaseType *base_type = c_parser_base_type_find(state, name);
    if (!base_type || base_type->kind != RZ_BASE_TYPE_KIND_ATOMIC) {
        return NULL;
    }
 
    RzType *type = RZ_NEW0(RzType);
    if (!type) {
        return NULL;
    }
    type->kind = RZ_TYPE_KIND_IDENTIFIER;
    type->identifier.is_const = is_const;
    type->identifier.name = strdup(name);
    type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED;
 
    ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
    if (!tpair) {
        rz_type_free(type);
        return NULL;
    }
    tpair->btype = base_type;
    tpair->type = type;
    return tpair;
}

References ParserTypePair::btype, c_parser_base_type_find(), rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_ATOMIC, RZ_NEW0, rz_return_val_if_fail, rz_type_free(), RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED, RZ_TYPE_KIND_IDENTIFIER, strdup(), type, and ParserTypePair::type.

Referenced by parse_primitive_type(), parse_sized_primitive_type(), and parse_sole_type_name().

c_parser_get_structure_type()

RZ_OWN ParserTypePair* c_parser_get_structure_type	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Returns the structure type if matching in the types hashtable.

If the name matches with the name of one of the base types that are in the hashtable of the existing types in the parser state, then it creates new RzType with the found RzBaseType as a base. Then it wraps boths in the "type pair"

Parameters

state	The parser state
name	Name of the structure type to fetch

Definition at line 317 of file types_storage.c.

                                                                                                     {
    rz_return_val_if_fail(state && name, NULL);
 
    RzBaseType *base_type = c_parser_base_type_find(state, name);
    if (!base_type || base_type->kind != RZ_BASE_TYPE_KIND_STRUCT) {
        return NULL;
    }
 
    ParserTypePair *tpair = c_parser_new_structure_naked_type(state, name);
    if (!tpair) {
        return NULL;
    }
 
    tpair->btype = base_type;
    return tpair;
}

References ParserTypePair::btype, c_parser_base_type_find(), c_parser_new_structure_naked_type(), rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_STRUCT, and rz_return_val_if_fail.

Referenced by parse_sole_type_name(), and parse_struct_node().

c_parser_get_typedef()

RZ_OWN ParserTypePair* c_parser_get_typedef	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Returns the type if matching in the types hashtable.

If the name matches with the name of one of the type aliases that are in the hashtable of the existing types in the parser state, then it creates new RzType with the found RzBaseType as a base. Then it wraps boths in the "type pair"

Parameters

state	The parser state
name	Name of the type alias to fetch

Definition at line 739 of file types_storage.c.

                                                                                              {
    rz_return_val_if_fail(state && name, NULL);
 
    RzBaseType *base_type = c_parser_base_type_find(state, name);
    if (!base_type || base_type->kind != RZ_BASE_TYPE_KIND_TYPEDEF) {
        return NULL;
    }
 
    RzType *type = RZ_NEW0(RzType);
    if (!type) {
        return NULL;
    }
    type->kind = RZ_TYPE_KIND_IDENTIFIER;
    type->identifier.is_const = false;
    type->identifier.name = strdup(name);
    type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED;
 
    ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
    if (!tpair) {
        rz_type_free(type);
        return NULL;
    }
    tpair->btype = base_type;
    tpair->type = type;
    return tpair;
}

References ParserTypePair::btype, c_parser_base_type_find(), rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_TYPEDEF, RZ_NEW0, rz_return_val_if_fail, rz_type_free(), RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED, RZ_TYPE_KIND_IDENTIFIER, strdup(), type, and ParserTypePair::type.

Referenced by parse_sole_type_name().

c_parser_get_union_type()

RZ_OWN ParserTypePair* c_parser_get_union_type	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Returns the union type if matching in the types hashtable.

If the name matches with the name of one of the base types that are in the hashtable of the existing types in the parser state, then it creates new RzType with the found RzBaseType as a base. Then it wraps boths in the "type pair"

Parameters

state	The parser state
name	Name of the union type to fetch

Definition at line 445 of file types_storage.c.

                                                                                                 {
    rz_return_val_if_fail(state && name, NULL);
 
    RzBaseType *base_type = c_parser_base_type_find(state, name);
    if (!base_type || base_type->kind != RZ_BASE_TYPE_KIND_UNION) {
        return NULL;
    }
 
    ParserTypePair *tpair = c_parser_new_union_naked_type(state, name);
    if (!tpair) {
        return NULL;
    }
 
    tpair->btype = base_type;
    return tpair;
}

References ParserTypePair::btype, c_parser_base_type_find(), c_parser_new_union_naked_type(), rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_UNION, and rz_return_val_if_fail.

Referenced by parse_sole_type_name(), and parse_union_node().

c_parser_new_anonymous_callable_name()

RZ_OWN char* c_parser_new_anonymous_callable_name

(

CParserState *

state

)

Definition at line 915 of file types_storage.c.

                                                                       {
    char *name = rz_str_newf("anonymous function %zu", state->anon.callables);
    state->anon.enums++;
    return name;
}

References name, and rz_str_newf().

Referenced by parse_type_abstract_declarator_node().

c_parser_new_anonymous_enum_name()

RZ_OWN char* c_parser_new_anonymous_enum_name

(

CParserState *

state

)

Definition at line 909 of file types_storage.c.

                                                                   {
    char *name = rz_str_newf("anonymous enum %zu", state->anon.enums);
    state->anon.enums++;
    return name;
}

References name, and rz_str_newf().

Referenced by parse_enum_node().

c_parser_new_anonymous_structure_name()

RZ_OWN char* c_parser_new_anonymous_structure_name

(

CParserState *

state

)

Definition at line 897 of file types_storage.c.

                                                                        {
    char *name = rz_str_newf("anonymous struct %zu", state->anon.structs);
    state->anon.structs++;
    return name;
}

References name, and rz_str_newf().

Referenced by parse_struct_node().

c_parser_new_anonymous_union_name()

RZ_OWN char* c_parser_new_anonymous_union_name

(

CParserState *

state

)

Definition at line 903 of file types_storage.c.

                                                                    {
    char *name = rz_str_newf("anonymous union %zu", state->anon.unions);
    state->anon.unions++;
    return name;
}

References name, and rz_str_newf().

Referenced by parse_union_node().

c_parser_new_callable()

RZ_OWN RzType* c_parser_new_callable	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Creates new callable based on the name.

If the name matches with the name of one of the base types that are in the hashtable of the existing types in the parser state, then it creates new RzType with the found RzCallable as a base.

In case of the callable found in the hashtable the ownership transfer doesn't happen. If not - it does.

Parameters

state	The parser state
name	Name of the callable type to create

Definition at line 802 of file types_storage.c.

                                                                                       {
    rz_return_val_if_fail(state && name, NULL);
    RzType *type = RZ_NEW0(RzType);
    if (!type) {
        return NULL;
    }
    // We check if there is already a callable in the hashtable with the same name
    bool found = false;
    RzCallable *callable = ht_pp_find(state->callables, name, &found);
    if (!found || !callable) {
        // If not found - create a new one
        callable = RZ_NEW0(RzCallable);
        if (!callable) {
            free(type);
            return NULL;
        }
        callable->name = strdup(name);
        callable->args = rz_pvector_new((RzPVectorFree)rz_type_callable_arg_free);
    }
    type->kind = RZ_TYPE_KIND_CALLABLE;
    type->callable = callable;
    return type;
}

References rz_callable_at::args, found, free(), rz_callable_at::name, NULL, RZ_NEW0, rz_pvector_new(), rz_return_val_if_fail, rz_type_callable_arg_free(), RZ_TYPE_KIND_CALLABLE, strdup(), and type.

Referenced by parse_type_abstract_declarator_node().

c_parser_new_callable_argument()

bool c_parser_new_callable_argument	(	CParserState *	state,
		RZ_NONNULL RzCallable *	callable,
		RZ_NONNULL const char *	name,
		RZ_OWN RZ_NONNULL RzType *	type
	)

Adds a new argument to the callable.

Parameters

state	The parser state
callable	Callable type
name	Name of the argument
type	Type of the argument

Definition at line 834 of file types_storage.c.

                                                                                                                                                       {
    rz_return_val_if_fail(state && callable && name && type, false);
    // At first we check if there is an argument with the same name already - error if yes
    void **it;
    rz_pvector_foreach (callable->args, it) {
        RzCallableArg *arg = *it;
        if (!strcmp(arg->name, name)) {
            return false;
        }
    }
    // And only if there is no argument with the same name - proceed to insert it
    RzCallableArg *arg = RZ_NEW0(RzCallableArg);
    if (!arg) {
        return false;
    }
    arg->name = strdup(name);
    arg->type = type;
    rz_pvector_push(callable->args, arg);
    return true;
}

References arg::name, RZ_NEW0, rz_pvector_foreach, rz_pvector_push(), rz_return_val_if_fail, strdup(), and type.

Referenced by parse_parameter_list().

c_parser_new_enum_forward_definition()

RZ_OWN ParserTypePair* c_parser_new_enum_forward_definition	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Creates new enum forward definition.

Parameters

state	The parser state
name	Name of the enum C type to create

Definition at line 596 of file types_storage.c.

                                                                                                              {
    rz_return_val_if_fail(state && name, NULL);
 
    if (c_parser_base_type_exists(state, name)) {
        // We don't create the enum if it exists already in the parser
        // state with the same name
        return NULL;
    }
 
    if (c_parser_base_type_is_forward_definition(state, name)) {
        // We don't create the enum if it exists already in the forward
        // definitions table with the same name
        return NULL;
    }
 
    ParserTypePair *tpair = c_parser_new_enum_naked_type(state, name);
    if (!tpair) {
        return NULL;
    }
 
    return tpair;
}

References c_parser_base_type_exists(), c_parser_base_type_is_forward_definition(), c_parser_new_enum_naked_type(), NULL, and rz_return_val_if_fail.

Referenced by parse_enum_node().

c_parser_new_enum_naked_type()

RZ_OWN ParserTypePair* c_parser_new_enum_naked_type	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Creates new enum naked type (without base type) based on the name.

Parameters

state	The parser state
name	Name of the enum C type to create

Definition at line 497 of file types_storage.c.

                                                                                                      {
    rz_return_val_if_fail(state && name, NULL);
 
    RzType *type = RZ_NEW0(RzType);
    if (!type) {
        return NULL;
    }
    type->kind = RZ_TYPE_KIND_IDENTIFIER;
    type->identifier.is_const = false;
    type->identifier.name = strdup(name);
    type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_ENUM;
 
    ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
    if (!tpair) {
        rz_type_free(type);
        return NULL;
    }
    tpair->btype = NULL;
    tpair->type = type;
    return tpair;
}

References ParserTypePair::btype, NULL, RZ_NEW0, rz_return_val_if_fail, rz_type_free(), RZ_TYPE_IDENTIFIER_KIND_ENUM, RZ_TYPE_KIND_IDENTIFIER, strdup(), type, and ParserTypePair::type.

Referenced by c_parser_get_enum_type(), c_parser_new_enum_forward_definition(), c_parser_new_enum_type(), and parse_enum_node().

c_parser_new_enum_type()

RZ_OWN ParserTypePair* c_parser_new_enum_type	(	CParserState *	state,
		RZ_NONNULL const char *	name,
		size_t	cases_count
	)

Creates new enumeration type based on the name.

Parameters

state	The parser state
name	Name of the primitive C type to create
cases_count	The count of the enum cases

Definition at line 526 of file types_storage.c.

                                                                                                                    {
    rz_return_val_if_fail(state && name, NULL);
 
    if (c_parser_base_type_exists(state, name)) {
        // We don't create the structure if it exists already in the parser
        // state with the same name
        parser_error(state, "Enum type \"%s\" already exists\n", name);
        return NULL;
    }
 
    ParserTypePair *tpair = c_parser_new_enum_naked_type(state, name);
    if (!tpair) {
        return NULL;
    }
 
    RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_ENUM);
    if (!base_type) {
        rz_type_free(tpair->type);
        free(tpair);
        return NULL;
    }
 
    base_type->name = strdup(name);
    base_type->type = NULL;
    tpair->btype = base_type;
 
    RzVector *cases = &base_type->enum_data.cases;
    if (cases_count > 0 && !rz_vector_reserve(cases, cases_count)) {
        rz_type_free(tpair->type);
        rz_type_base_type_free(tpair->btype);
        free(tpair);
        return NULL;
    }
    return tpair;
}

References ParserTypePair::btype, c_parser_base_type_exists(), c_parser_new_enum_naked_type(), rz_base_type_enum_t::cases, rz_base_type_t::enum_data, free(), rz_base_type_t::name, NULL, parser_error(), RZ_BASE_TYPE_KIND_ENUM, rz_return_val_if_fail, rz_type_base_type_free(), rz_type_base_type_new(), rz_type_free(), rz_vector_reserve(), strdup(), rz_base_type_t::type, and ParserTypePair::type.

Referenced by parse_enum_node().

c_parser_new_naked_callable()

RZ_OWN RzType* c_parser_new_naked_callable

(

CParserState *

state

)

Creates new naked callable without storing it.

Parameters

state

The parser state

Definition at line 771 of file types_storage.c.

                                                                {
    rz_return_val_if_fail(state, NULL);
    RzType *type = RZ_NEW0(RzType);
    if (!type) {
        return NULL;
    }
    RzCallable *callable = RZ_NEW0(RzCallable);
    if (!callable) {
        free(type);
        return NULL;
    }
    callable->name = NULL;
    callable->args = rz_pvector_new((RzPVectorFree)rz_type_callable_arg_free);
    type->kind = RZ_TYPE_KIND_CALLABLE;
    type->callable = callable;
    return type;
}

References rz_callable_at::args, free(), rz_callable_at::name, NULL, RZ_NEW0, rz_pvector_new(), rz_return_val_if_fail, rz_type_callable_arg_free(), RZ_TYPE_KIND_CALLABLE, and type.

Referenced by parse_type_declarator_node().

c_parser_new_primitive_type()

RZ_OWN ParserTypePair* c_parser_new_primitive_type	(	CParserState *	state,
		RZ_NONNULL const char *	name,
		bool	is_const
	)

Creates new primitive type based on the name.

Parameters

state	The parser state
name	Name of the primitive C type to create
is_const	If the primitive type is const

Definition at line 150 of file types_storage.c.

                                                                                                                    {
    rz_return_val_if_fail(state && name, NULL);
 
    if (c_parser_base_type_exists(state, name)) {
        // We don't create the type if it exists already in the parser
        // state with the same name
        parser_error(state, "Primitive type \"%s\" already exists\n", name);
        return NULL;
    }
 
    RzType *type = RZ_NEW0(RzType);
    if (!type) {
        return NULL;
    }
    type->kind = RZ_TYPE_KIND_IDENTIFIER;
    type->identifier.is_const = is_const;
    type->identifier.name = strdup(name);
    if (!type->identifier.name) {
        free(type);
        return NULL;
    }
    type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED;
 
    RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_ATOMIC);
    if (!base_type) {
        rz_type_free(type);
        return NULL;
    }
    base_type->name = strdup(name);
    if (!base_type->name) {
        rz_type_free(type);
        rz_type_base_type_free(base_type);
        return NULL;
    }
 
    ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
    if (!tpair) {
        rz_type_free(type);
        rz_type_base_type_free(base_type);
        return NULL;
    }
    tpair->btype = base_type;
    tpair->type = type;
 
    return tpair;
}

References ParserTypePair::btype, c_parser_base_type_exists(), free(), rz_base_type_t::name, NULL, parser_error(), RZ_BASE_TYPE_KIND_ATOMIC, RZ_NEW0, rz_return_val_if_fail, rz_type_base_type_free(), rz_type_base_type_new(), rz_type_free(), RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED, RZ_TYPE_KIND_IDENTIFIER, strdup(), type, and ParserTypePair::type.

Referenced by parse_primitive_type(), parse_sized_primitive_type(), and parse_sole_type_name().

c_parser_new_structure_forward_definition()

RZ_OWN ParserTypePair* c_parser_new_structure_forward_definition	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Creates new structure forward definition.

Parameters

state	The parser state
name	Name of the structure C type to create

Definition at line 340 of file types_storage.c.

                                                                                                                   {
    rz_return_val_if_fail(state && name, NULL);
 
    if (c_parser_base_type_exists(state, name)) {
        // We don't create the structure if it exists already in the parser
        // state with the same name
        return NULL;
    }
 
    if (c_parser_base_type_is_forward_definition(state, name)) {
        // We don't create the structure if it exists already in the forward
        // definitions table with the same name
        return NULL;
    }
 
    ParserTypePair *tpair = c_parser_new_structure_naked_type(state, name);
    if (!tpair) {
        return NULL;
    }
 
    return tpair;
}

References c_parser_base_type_exists(), c_parser_base_type_is_forward_definition(), c_parser_new_structure_naked_type(), NULL, and rz_return_val_if_fail.

Referenced by parse_struct_node().

c_parser_new_structure_naked_type()

RZ_OWN ParserTypePair* c_parser_new_structure_naked_type	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Creates new structure naked type (without base type) based on the name.

Parameters

state	The parser state
name	Name of the structure C type to create

Definition at line 242 of file types_storage.c.

                                                                                                           {
    rz_return_val_if_fail(state && name, NULL);
 
    RzType *type = RZ_NEW0(RzType);
    if (!type) {
        return NULL;
    }
    type->kind = RZ_TYPE_KIND_IDENTIFIER;
    type->identifier.is_const = false;
    type->identifier.name = strdup(name);
    type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_STRUCT;
 
    ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
    if (!tpair) {
        rz_type_free(type);
        return NULL;
    }
    tpair->btype = NULL;
    tpair->type = type;
    return tpair;
}

References ParserTypePair::btype, NULL, RZ_NEW0, rz_return_val_if_fail, rz_type_free(), RZ_TYPE_IDENTIFIER_KIND_STRUCT, RZ_TYPE_KIND_IDENTIFIER, strdup(), type, and ParserTypePair::type.

Referenced by c_parser_get_structure_type(), c_parser_new_structure_forward_definition(), c_parser_new_structure_type(), and parse_struct_node().

c_parser_new_structure_type()

RZ_OWN ParserTypePair* c_parser_new_structure_type	(	CParserState *	state,
		RZ_NONNULL const char *	name,
		size_t	members_count
	)

Creates new structure "type + base type" pair based on the name.

Parameters

state	The parser state
name	Name of the structure C type to create
members_count	The count of the structure members

Definition at line 271 of file types_storage.c.

                                                                                                                           {
    rz_return_val_if_fail(state && name, NULL);
 
    if (c_parser_base_type_exists(state, name)) {
        // We don't create the structure if it exists already in the parser
        // state with the same name
        parser_error(state, "Structure type \"%s\" already exists\n", name);
        return NULL;
    }
 
    ParserTypePair *tpair = c_parser_new_structure_naked_type(state, name);
    if (!tpair) {
        return NULL;
    }
 
    RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_STRUCT);
    if (!base_type) {
        rz_type_free(tpair->type);
        free(tpair);
        return NULL;
    }
    base_type->name = strdup(name);
    base_type->type = NULL;
    tpair->btype = base_type;
 
    RzVector *members = &base_type->struct_data.members;
    if (members_count > 0 && !rz_vector_reserve(members, members_count)) {
        rz_type_free(tpair->type);
        rz_type_base_type_free(tpair->btype);
        free(tpair);
        return NULL;
    }
    return tpair;
}

References ParserTypePair::btype, c_parser_base_type_exists(), c_parser_new_structure_naked_type(), free(), rz_base_type_struct_t::members, rz_base_type_t::name, NULL, parser_error(), RZ_BASE_TYPE_KIND_STRUCT, rz_return_val_if_fail, rz_type_base_type_free(), rz_type_base_type_new(), rz_type_free(), rz_vector_reserve(), strdup(), rz_base_type_t::struct_data, rz_base_type_t::type, and ParserTypePair::type.

Referenced by parse_struct_node().

c_parser_new_typedef()

RZ_OWN ParserTypePair* c_parser_new_typedef	(	CParserState *	state,
		RZ_NONNULL const char *	name,
		RZ_NONNULL const char *	base
	)

Creates new type alias based on the name.

Parameters

state	The parser state
name	Name of the primitive C type to create
cases_count	The count of the enum cases

Definition at line 683 of file types_storage.c.

                                                                                                                           {
    rz_return_val_if_fail(state && name, NULL);
 
    if (c_parser_base_type_exists(state, name)) {
        // We don't create the type alias if it exists already in the parser
        // state with the same name
        parser_error(state, "Typedef \"%s\" already exists\n", name);
        return NULL;
    }
 
    ParserTypePair *tpair = c_parser_new_typedef_naked_type(state, name);
    if (!tpair) {
        return NULL;
    }
 
    RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_TYPEDEF);
    if (!base_type) {
        rz_type_free(tpair->type);
        free(tpair);
        return NULL;
    }
    base_type->name = strdup(name);
 
    if (!c_parser_base_type_exists(state, base)) {
        // If it not exists already in the parser
        // we create a forward type
        base_type->type = NULL;
        c_parser_forward_definition_store(state, base);
    } else {
        RzType *type = RZ_NEW0(RzType);
        if (!type) {
            rz_type_base_type_free(base_type);
            free(tpair);
            return NULL;
        }
        type->kind = RZ_TYPE_KIND_IDENTIFIER;
        type->identifier.name = strdup(base);
        type->identifier.is_const = false;
        base_type->type = type;
    }
 
    tpair->btype = base_type;
    return tpair;
}

References ParserTypePair::btype, c_parser_base_type_exists(), c_parser_forward_definition_store(), c_parser_new_typedef_naked_type(), free(), rz_base_type_t::name, NULL, parser_error(), RZ_BASE_TYPE_KIND_TYPEDEF, RZ_NEW0, rz_return_val_if_fail, rz_type_base_type_free(), rz_type_base_type_new(), rz_type_free(), RZ_TYPE_KIND_IDENTIFIER, strdup(), type, rz_base_type_t::type, and ParserTypePair::type.

Referenced by parse_typedef_node().

c_parser_new_union_forward_definition()

RZ_OWN ParserTypePair* c_parser_new_union_forward_definition	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Creates new union forward definition.

Parameters

state	The parser state
name	Name of the union C type to create

Definition at line 468 of file types_storage.c.

                                                                                                               {
    rz_return_val_if_fail(state && name, NULL);
 
    if (c_parser_base_type_exists(state, name)) {
        // We don't create the union if it exists already in the parser
        // state with the same name
        return NULL;
    }
 
    if (c_parser_base_type_is_forward_definition(state, name)) {
        // We don't create the union if it exists already in the forward
        // definitions table with the same name
        return NULL;
    }
 
    ParserTypePair *tpair = c_parser_new_union_naked_type(state, name);
    if (!tpair) {
        return NULL;
    }
 
    return tpair;
}

References c_parser_base_type_exists(), c_parser_base_type_is_forward_definition(), c_parser_new_union_naked_type(), NULL, and rz_return_val_if_fail.

Referenced by parse_union_node().

c_parser_new_union_naked_type()

RZ_OWN ParserTypePair* c_parser_new_union_naked_type	(	CParserState *	state,
		RZ_NONNULL const char *	name
	)

Creates new union naked type (without base type) based on the name.

Parameters

state	The parser state
name	Name of the union C type to create

Definition at line 369 of file types_storage.c.

                                                                                                       {
    rz_return_val_if_fail(state && name, NULL);
 
    RzType *type = RZ_NEW0(RzType);
    if (!type) {
        return NULL;
    }
    type->kind = RZ_TYPE_KIND_IDENTIFIER;
    type->identifier.is_const = false;
    type->identifier.name = strdup(name);
    type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNION;
 
    ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
    if (!tpair) {
        rz_type_free(type);
        return NULL;
    }
    tpair->btype = NULL;
    tpair->type = type;
    return tpair;
}

References ParserTypePair::btype, NULL, RZ_NEW0, rz_return_val_if_fail, rz_type_free(), RZ_TYPE_IDENTIFIER_KIND_UNION, RZ_TYPE_KIND_IDENTIFIER, strdup(), type, and ParserTypePair::type.

Referenced by c_parser_get_union_type(), c_parser_new_union_forward_definition(), c_parser_new_union_type(), and parse_union_node().

c_parser_new_union_type()

RZ_OWN ParserTypePair* c_parser_new_union_type	(	CParserState *	state,
		RZ_NONNULL const char *	name,
		size_t	members_count
	)

Creates new union "type + base type" pair based on the name.

Parameters

state	The parser state
name	Name of the union C type to create
members_count	The count of the union members

Definition at line 398 of file types_storage.c.

                                                                                                                       {
    rz_return_val_if_fail(state && name, NULL);
 
    if (c_parser_base_type_exists(state, name)) {
        // We don't create the structure if it exists already in the parser
        // state with the same name
        parser_error(state, "Union type \"%s\" already exists\n", name);
        return NULL;
    }
 
    ParserTypePair *tpair = c_parser_new_union_naked_type(state, name);
    if (!tpair) {
        return NULL;
    }
 
    RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_UNION);
    if (!base_type) {
        rz_type_free(tpair->type);
        free(tpair);
        return NULL;
    }
 
    base_type->name = strdup(name);
    base_type->type = NULL;
    tpair->btype = base_type;
 
    RzVector *members = &base_type->union_data.members;
    if (members_count > 0 && !rz_vector_reserve(members, members_count)) {
        rz_type_free(tpair->type);
        rz_type_base_type_free(tpair->btype);
        free(tpair);
        return NULL;
    }
    return tpair;
}

References ParserTypePair::btype, c_parser_base_type_exists(), c_parser_new_union_naked_type(), free(), rz_base_type_union_t::members, rz_base_type_t::name, NULL, parser_error(), RZ_BASE_TYPE_KIND_UNION, rz_return_val_if_fail, rz_type_base_type_free(), rz_type_base_type_new(), rz_type_free(), rz_vector_reserve(), strdup(), rz_base_type_t::type, ParserTypePair::type, and rz_base_type_t::union_data.

Referenced by parse_union_node().

c_parser_new_unspecified_naked_type()

RZ_OWN ParserTypePair* c_parser_new_unspecified_naked_type	(	CParserState *	state,
		RZ_NONNULL const char *	name,
		bool	is_const
	)

Creates new unspecified naked type (without base type) based on the name.

Parameters

state	The parser state
name	Name of the type to create
is_const	If the identifier is constant

Definition at line 121 of file types_storage.c.

                                                                                                                            {
    rz_return_val_if_fail(state && name, NULL);
 
    RzType *type = RZ_NEW0(RzType);
    if (!type) {
        return NULL;
    }
    type->kind = RZ_TYPE_KIND_IDENTIFIER;
    type->identifier.is_const = is_const;
    type->identifier.name = strdup(name);
    type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED;
 
    ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
    if (!tpair) {
        rz_type_free(type);
        return NULL;
    }
    tpair->btype = NULL;
    tpair->type = type;
    return tpair;
}

References ParserTypePair::btype, NULL, RZ_NEW0, rz_return_val_if_fail, rz_type_free(), RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED, RZ_TYPE_KIND_IDENTIFIER, strdup(), type, and ParserTypePair::type.

Referenced by parse_sole_type_name().

c_parser_pointer_set_subtype()

bool c_parser_pointer_set_subtype	(	CParserState *	state,
		RZ_BORROW ParserTypePair *	tpair,
		RZ_OWN ParserTypePair *	subpair
	)

Definition at line 881 of file types_storage.c.

                                                                                                                        {
    rz_return_val_if_fail(state && tpair, false);
    rz_return_val_if_fail(tpair->type->kind == RZ_TYPE_KIND_POINTER, false);
    tpair->type->pointer.type = subpair->type;
    tpair->btype = subpair->btype;
    return true;
}

References rz_return_val_if_fail, and RZ_TYPE_KIND_POINTER.

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_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_type_wrap_to_array()

RZ_OWN ParserTypePair* c_parser_type_wrap_to_array	(	CParserState *	state,
		ParserTypePair *	tpair,
		size_t	size
	)

Definition at line 869 of file types_storage.c.

                                                                                                            {
    rz_return_val_if_fail(state && tpair, NULL);
    RzType *type = RZ_NEW0(RzType);
    type->kind = RZ_TYPE_KIND_ARRAY;
    type->array.count = size;
    type->array.type = tpair->type;
    ParserTypePair *newtpair = RZ_NEW0(ParserTypePair);
    newtpair->btype = tpair->btype;
    newtpair->type = type;
    return newtpair;
}

References ParserTypePair::btype, NULL, RZ_NEW0, rz_return_val_if_fail, RZ_TYPE_KIND_ARRAY, type, and ParserTypePair::type.

c_parser_type_wrap_to_pointer()

RZ_OWN ParserTypePair* c_parser_type_wrap_to_pointer	(	CParserState *	state,
		ParserTypePair *	tpair,
		bool	is_const
	)

Definition at line 857 of file types_storage.c.

                                                                                                                {
    rz_return_val_if_fail(state && tpair, NULL);
    RzType *type = RZ_NEW0(RzType);
    type->kind = RZ_TYPE_KIND_POINTER;
    type->pointer.is_const = is_const;
    type->pointer.type = tpair->type;
    ParserTypePair *newtpair = RZ_NEW0(ParserTypePair);
    newtpair->btype = tpair->btype;
    newtpair->type = type;
    return newtpair;
}

References ParserTypePair::btype, NULL, RZ_NEW0, rz_return_val_if_fail, RZ_TYPE_KIND_POINTER, type, and ParserTypePair::type.

parse_declaration_node()

int parse_declaration_node	(	CParserState *	state,
		TSNode	node,
		const char *	text,
		ParserTypePair **	tpair
	)

Definition at line 1788 of file types_parser.c.

                                                                                                       {
    rz_return_val_if_fail(state && text && tpair, -1);
    rz_return_val_if_fail(!ts_node_is_null(node), -1);
    // We skip simple nodes (e.g. conditions and braces)
    if (!ts_node_is_named(node)) {
        return 0;
    }
    const char *node_type = ts_node_type(node);
    int result = -1;
    if (strcmp(node_type, "declaration")) {
        return -1;
    }
    parser_debug(state, "parse_type_declaration_node()\n");
 
    int declaration_node_child_count = ts_node_named_child_count(node);
    if (declaration_node_child_count < 1) {
        node_malformed_error(state, node, text, "declaration");
        return -1;
    }
    // Type declaration has three fields:
    // 0. type qualifier (optional)
    // 1. type itself
    // 2. declarator field (optional)
 
    // Parse the type qualifier first
    // FIXME: There could be multiple different type qualifiers in one declaration
    bool is_const = false;
    TSNode first_leaf = ts_node_named_child(node, 0);
    if (ts_node_is_null(first_leaf)) {
        node_malformed_error(state, node, text, "declaration");
        return -1;
    }
    const char *leaf_type = ts_node_type(first_leaf);
    if (!strcmp(leaf_type, "type_qualifier")) {
        char *qualifier = ts_node_sub_string(first_leaf, text);
        parser_debug(state, "has qualifier \"%s\"\n", qualifier);
        if (!strcmp(qualifier, "const")) {
            parser_debug(state, "set const\n");
            is_const = true;
        }
        free(qualifier);
    }
 
    TSNode type_node = ts_node_child_by_field_name(node, "type", 4);
    if (ts_node_is_null(type_node)) {
        node_malformed_error(state, node, text, "declaration");
        parser_error(state, "declaration's type field cannot be NULL\n");
        return -1;
    }
    if (parse_type_node_single(state, type_node, text, tpair, is_const)) {
        node_malformed_error(state, node, text, "declaration");
        parser_error(state, "Cannot parse declaration's type field\n");
        return -1;
    }
    if (!*tpair) {
        parser_error(state, "Failed to parse declaration's type field\n");
        return -1;
    }
    // 2. Optional declarator field
    TSNode type_declarator = ts_node_child_by_field_name(node, "declarator", 10);
    if (!ts_node_is_null(type_declarator)) {
        char *identifier = NULL;
        return parse_type_declarator_node(state, type_declarator, text, tpair, &identifier);
    } else {
        result = 0;
    }
    return result;
}

References free(), node_malformed_error(), NULL, parse_type_declarator_node(), parse_type_node_single(), parser_debug(), parser_error(), rz_return_val_if_fail, create_tags_rz::text, ts_node_child_by_field_name(), ts_node_is_named(), ts_node_is_null(), ts_node_named_child(), ts_node_named_child_count(), ts_node_sub_string(), and ts_node_type().

Referenced by parse_type_nodes_save(), and rz_type_parse_string_declaration_single().

parse_type_abstract_declarator_node()

int parse_type_abstract_declarator_node	(	CParserState *	state,
		TSNode	node,
		const char *	text,
		ParserTypePair **	tpair
	)

Definition at line 1295 of file types_parser.c.

                                                                                                                    {
    rz_return_val_if_fail(state && text && tpair, -1);
    rz_return_val_if_fail(!ts_node_is_null(node), -1);
    rz_return_val_if_fail(ts_node_is_named(node), -1);
 
    parser_debug(state, "parse_type_abstract_declarator_node()\n");
 
    // Parse the type qualifier first (if present)
    // FIXME: There could be multiple different type qualifiers in one declaration
    bool is_const = false;
    bool has_qualifiers = false;
 
    int node_child_count = ts_node_named_child_count(node);
    if (node_child_count > 0) {
        TSNode first_leaf = ts_node_named_child(node, 0);
        if (ts_node_is_null(first_leaf)) {
            node_malformed_error(state, node, text, "type_declarator_node");
            return -1;
        }
        const char *leaf_type = ts_node_type(first_leaf);
        // If we have type qualifier in this position it is related to
        // the declarator itself, not the type, e.g. constant pointer,
        // not pointer to the constant
        if (!strcmp(leaf_type, "type_qualifier")) {
            char *qualifier = ts_node_sub_string(first_leaf, text);
            parser_debug(state, "has qualifier %s\n", qualifier);
            if (!strcmp(qualifier, "const")) {
                is_const = true;
            }
            has_qualifiers = true;
            free(qualifier);
        }
    }
 
    const char *node_type = ts_node_type(node);
    int result = -1;
    if (!strcmp(node_type, "abstract_pointer_declarator")) {
        parser_debug(state, "abstract pointer declarator\n");
 
        // Now we wrap the existing type into the new one
        // The base type in the type pair remains the same
        RzType *type = RZ_NEW0(RzType);
        if (!type) {
            return -1;
        }
        type->kind = RZ_TYPE_KIND_POINTER;
        type->pointer.is_const = is_const;
        type->pointer.type = (*tpair)->type;
        (*tpair)->type = type;
 
        // It can contain additional children as:
        // - "abstract_array_declarator"
        // - "abstract_pointer_declarator"
        // - "abstract_function_declarator"
        // - Or multiple "type qualifiers"
        int pointer_node_child_count = ts_node_named_child_count(node);
        if (pointer_node_child_count > 0) {
            TSNode pointer_declarator = ts_node_child_by_field_name(node, "declarator", 10);
            if (ts_node_is_null(pointer_declarator) && !has_qualifiers) {
                parser_error(state, "ERROR: Abstract pointer declarator AST should contain at least one node!\n");
                node_malformed_error(state, node, text, "pointer declarator");
                free(type);
                (*tpair)->type = NULL;
                return -1;
            }
            if (!ts_node_is_null(pointer_declarator)) {
                const char *declarator_type = ts_node_type(pointer_declarator);
                if (!declarator_type) {
                    node_malformed_error(state, pointer_declarator, text, "pointer declarator");
                    free(type);
                    (*tpair)->type = NULL;
                    return -1;
                }
                if (is_abstract_declarator(declarator_type)) {
                    result = parse_type_abstract_declarator_node(state, pointer_declarator, text, tpair);
                } else {
                    result = 0;
                }
            } else {
                result = 0;
            }
        } else {
            parser_debug(state, "abstract pointer declarator has no children\n");
            result = 0;
        }
    } else if (!strcmp(node_type, "abstract_array_declarator")) {
        // It can have two states - with and without number literal
        int array_node_child_count = ts_node_named_child_count(node);
        if (array_node_child_count < 0 || array_node_child_count > 2) {
            node_malformed_error(state, node, text, "abstract_array_declarator");
            return -1;
        }
        // Now we wrap the existing type into the new one
        // The base type in the type pair remains the same
        RzType *type = RZ_NEW0(RzType);
        if (!type) {
            return -1;
        }
 
        type->kind = RZ_TYPE_KIND_ARRAY;
        // Optional number_literal node
        TSNode array_size = ts_node_child_by_field_name(node, "size", 4);
        if (ts_node_is_null(array_size)) {
            type->array.count = 0;
        } else {
            char *real_array_size = ts_node_sub_string(array_size, text);
            if (!real_array_size) {
                node_malformed_error(state, array_size, text, "abstract array size");
                free(type);
                return -1;
            }
            int array_sz = rz_num_get(NULL, real_array_size);
            type->array.count = array_sz;
            free(real_array_size);
        }
        type->array.type = (*tpair)->type;
        (*tpair)->type = type;
 
        // It also can contain the following abstract declarators as a child:
        // - abstract_array_declarator
        // - abstract_pointer_declarator
        TSNode array_declarator = ts_node_child_by_field_name(node, "declarator", 10);
        if (!ts_node_is_null(array_declarator)) {
            const char *declarator_type = ts_node_type(array_declarator);
            if (!declarator_type) {
                node_malformed_error(state, array_declarator, text, "declarator");
                return -1;
            }
            if (is_abstract_declarator(declarator_type)) {
                result = parse_type_abstract_declarator_node(state, array_declarator, text, tpair);
            } else {
                result = 0;
            }
        } else {
            result = 0;
        }
    } else if (!strcmp(node_type, "abstract_function_declarator")) {
        // It can only contain two nodes:
        // - abstract_parenthesized_declarator (usually empty)
        // - parameter_list
        int function_node_child_count = ts_node_named_child_count(node);
        if (function_node_child_count != 1) {
            node_malformed_error(state, node, text, "abstract_function_declarator");
            return -1;
        }
        TSNode parenthesized_declarator = ts_node_child_by_field_name(node, "declarator", 10);
        if (ts_node_is_null(parenthesized_declarator) || !ts_node_is_named(parenthesized_declarator)) {
            node_malformed_error(state, parenthesized_declarator, text, "parenthesized_declarator");
            return -1;
        }
        const char *declarator_type = ts_node_type(parenthesized_declarator);
        if (strcmp(declarator_type, "parenthesized_declarator")) {
            node_malformed_error(state, parenthesized_declarator, text, "parenthesized_declarator");
            return -1;
        }
        // Parsing parameters list
        TSNode parameter_list = ts_node_child_by_field_name(node, "parameters", 10);
        if (ts_node_is_null(parameter_list) || !ts_node_is_named(parameter_list)) {
            node_malformed_error(state, parameter_list, text, "parameter_list");
            return -1;
        }
        const char *param_list_type = ts_node_type(parameter_list);
        if (strcmp(param_list_type, "parameter_list")) {
            node_malformed_error(state, parameter_list, text, "parameter_list");
            return -1;
        }
        // Generate a sequential function type name if it's not specified
        const char *name = c_parser_new_anonymous_callable_name(state);
        RzType *parent_type = (*tpair)->type;
        (*tpair)->type = c_parser_new_callable(state, name);
        if (!(*tpair)->type) {
            parser_error(state, "ERROR: creating new callable type: \"%s\"\n", name);
            return -1;
        }
 
        result = parse_parameter_list(state, parameter_list, text, tpair);
        if (result) {
            parser_error(state, "ERROR: parsing parameters for callable type: \"%s\"\n", name);
            return -1;
        }
        // The previously fetched type in this case is the callable return type
        (*tpair)->type->callable->ret = parent_type;
        if (!c_parser_callable_type_store(state, name, (*tpair)->type)) {
            parser_error(state, "ERROR: storing the new callable type: \"%s\"\n", name);
            return -1;
        }
    }
    return result;
}

References c_parser_callable_type_store(), c_parser_new_anonymous_callable_name(), c_parser_new_callable(), free(), is_abstract_declarator(), node_malformed_error(), NULL, parse_parameter_list(), parser_debug(), parser_error(), RZ_NEW0, rz_num_get(), rz_return_val_if_fail, RZ_TYPE_KIND_ARRAY, RZ_TYPE_KIND_POINTER, create_tags_rz::text, ts_node_child_by_field_name(), ts_node_is_named(), ts_node_is_null(), ts_node_named_child(), ts_node_named_child_count(), ts_node_sub_string(), ts_node_type(), type, and rz_type_t::type.

Referenced by parse_parameter_declaration_node(), and parse_type_descriptor_single().

parse_type_declarator_node()

int parse_type_declarator_node	(	CParserState *	state,
		TSNode	node,
		const char *	text,
		ParserTypePair **	tpair,
		char **	identifier
	)

Definition at line 1492 of file types_parser.c.

                                                                                                                              {
    rz_return_val_if_fail(state && text && tpair, -1);
    rz_return_val_if_fail(!ts_node_is_null(node), -1);
    rz_return_val_if_fail(ts_node_is_named(node), -1);
 
    parser_debug(state, "parse_type_declarator_node()\n");
    // Parse the type qualifier first
    // FIXME: There could be multiple different type qualifiers in one declaration
    bool is_const = false;
 
    int node_child_count = ts_node_named_child_count(node);
    if (node_child_count > 0) {
        TSNode first_leaf = ts_node_named_child(node, 0);
        if (ts_node_is_null(first_leaf)) {
            node_malformed_error(state, node, text, "type_declarator_node");
            return -1;
        }
        const char *leaf_type = ts_node_type(first_leaf);
        if (!strcmp(leaf_type, "type_qualifier")) {
            char *qualifier = ts_node_sub_string(first_leaf, text);
            parser_debug(state, "has qualifier %s\n", qualifier);
            if (!strcmp(qualifier, "const")) {
                is_const = true;
            }
            free(qualifier);
        }
    }
 
    const char *node_type = ts_node_type(node);
    int result = -1;
 
    if (is_identifier(node_type)) {
        // Identifier, usually the last leaf of the AST tree
        char *real_ident = ts_node_sub_string(node, text);
        parser_debug(state, "identifier: %s\n", real_ident);
        *identifier = real_ident;
        result = 0;
    } else if (!strcmp(node_type, "pointer_declarator")) {
        char *real_ident = ts_node_sub_string(node, text);
        parser_debug(state, "pointer declarator: %s\n", real_ident);
        // It can contain additional children recursively
        // - "array_declarator"
        // - "pointer_declarator"
        // - "function_declarator"
        // - "identifier"
        // Every pointer declarator should have at least declarator field
        TSNode pointer_declarator = ts_node_child_by_field_name(node, "declarator", 10);
        if (ts_node_is_null(pointer_declarator)) {
            parser_error(state, "ERROR: Pointer declarator AST should contain at least one node!\n");
            node_malformed_error(state, node, text, "pointer declarator");
            free(real_ident);
            return -1;
        }
        const char *declarator_type = ts_node_type(pointer_declarator);
        if (!declarator_type) {
            node_malformed_error(state, pointer_declarator, text, "pointer declarator");
            free(real_ident);
            return -1;
        }
 
        // Now we wrap the existing type into the new one
        // The base type in the type pair remains the same
        RzType *type = RZ_NEW0(RzType);
        if (!type) {
            free(real_ident);
            return -1;
        }
        type->kind = RZ_TYPE_KIND_POINTER;
        type->pointer.is_const = is_const;
        type->pointer.type = (*tpair)->type;
        (*tpair)->type = type;
 
        if (is_declarator(declarator_type) || is_identifier(declarator_type)) {
            result = parse_type_declarator_node(state, pointer_declarator, text, tpair, identifier);
        } else {
            result = 0;
        }
        free(real_ident);
    } else if (!strcmp(node_type, "array_declarator")) {
        char *real_ident = ts_node_sub_string(node, text);
        parser_debug(state, "array declarator: %s\n", real_ident);
        free(real_ident);
 
        // Every array declarator should have at least declarator field
        // The size field is optional
        TSNode array_declarator = ts_node_child_by_field_name(node, "declarator", 10);
        TSNode array_size = ts_node_child_by_field_name(node, "size", 4);
        if (ts_node_is_null(array_declarator)) {
            parser_error(state, "ERROR: Array declarator AST should contain at least one node!\n");
            node_malformed_error(state, node, text, "array declarator");
            return -1;
        }
 
        const char *declarator_type = ts_node_type(array_declarator);
        if (!declarator_type) {
            node_malformed_error(state, array_declarator, text, "array declarator");
            return -1;
        }
        // Now we wrap the existing type into the new one
        // The base type in the type pair remains the same
        RzType *type = RZ_NEW0(RzType);
        if (!type) {
            return -1;
        }
        type->kind = RZ_TYPE_KIND_ARRAY;
        if (ts_node_is_null(array_size)) {
            type->array.count = 0;
        } else {
            // number_literal node
            char *real_array_size = ts_node_sub_string(array_size, text);
            if (!real_array_size) {
                node_malformed_error(state, array_size, text, "array size");
                free(type);
                return -1;
            }
            int array_sz = rz_num_get(NULL, real_array_size);
            type->array.count = array_sz;
            free(real_array_size);
        }
        type->array.type = (*tpair)->type;
        (*tpair)->type = type;
 
        parser_debug(state, "array declarator type: %s\n", declarator_type);
        if (is_declarator(declarator_type) || is_identifier(declarator_type)) {
            result = parse_type_declarator_node(state, array_declarator, text, tpair, identifier);
        } else {
            return 0;
        }
    } else if (!strcmp(node_type, "function_declarator")) {
        char *real_ident = ts_node_sub_string(node, text);
        parser_debug(state, "function declarator: %s\n", real_ident);
        free(real_ident);
        // It can only contain two nodes:
        // - declarator
        // - parameters
        int function_node_child_count = ts_node_named_child_count(node);
        if (function_node_child_count > 2) {
            node_malformed_error(state, node, text, "function_declarator");
            return -1;
        }
        TSNode declarator = ts_node_child_by_field_name(node, "declarator", 10);
        if (ts_node_is_null(declarator) || !ts_node_is_named(declarator)) {
            node_malformed_error(state, declarator, text, "declarator");
            return -1;
        }
        const char *declarator_type = ts_node_type(declarator);
        // Declarator could be either parenthesized_declarator or identifier
        if (!is_function_declarator(declarator_type)) {
            node_malformed_error(state, declarator, text, "function declarator or identifier");
            return -1;
        }
        RzType *parent_type = (*tpair)->type;
        // At first we create "freestanding" unnamed callable
        RzType *naked_callable = c_parser_new_naked_callable(state);
        if (!naked_callable) {
            parser_error(state, "ERROR: creating naked callable type\n");
            return -1;
        }
        // The previously fetched type in this case is the callable return type
        naked_callable->callable->ret = parent_type;
        (*tpair)->type = naked_callable;
 
        // Declarator can be either "identifier" directly or have children
        if (is_identifier(declarator_type)) {
            parser_debug(state, "function declarator: simple identifier\n");
            if (parse_type_declarator_node(state, declarator, text, tpair, identifier)) {
                parser_error(state, "ERROR: parsing function declarator\n");
                node_malformed_error(state, declarator, text, "function identifier");
                return -1;
            }
        } else {
            TSNode function_declarator = ts_node_named_child(declarator, 0);
            const char *function_declarator_type = ts_node_type(function_declarator);
            if (!function_declarator_type) {
                node_malformed_error(state, function_declarator, text, "function declarator");
                return -1;
            }
 
            // Declarator can contain either "identifier" directly
            // Or the pointer_declarator instead (or multiple of them nested in each other)
            if (is_declarator(function_declarator_type) || is_identifier(function_declarator_type)) {
                if (parse_type_declarator_node(state, function_declarator, text, tpair, identifier)) {
                    parser_error(state, "ERROR: parsing function declarator\n");
                    node_malformed_error(state, function_declarator, text, "function declarator");
                    return -1;
                }
            } else {
                parser_error(state, "ERROR: missing function declarator\n");
                node_malformed_error(state, function_declarator, text, "function declarator");
                return -1;
            }
        }
 
        // Parsing parameters list
        TSNode parameter_list = ts_node_child_by_field_name(node, "parameters", 10);
        if (ts_node_is_null(parameter_list) || !ts_node_is_named(parameter_list)) {
            node_malformed_error(state, parameter_list, text, "parameter_list");
            return -1;
        }
        const char *param_list_type = ts_node_type(parameter_list);
        if (strcmp(param_list_type, "parameter_list")) {
            node_malformed_error(state, parameter_list, text, "parameter_list");
            return -1;
        }
        naked_callable->callable->name = strdup(*identifier);
        // Preserve the parent callable type
        parent_type = (*tpair)->type;
        // Then override with the naked callable type to proceed with parameter parsing
        (*tpair)->type = naked_callable;
        result = parse_parameter_list(state, parameter_list, text, tpair);
        if (result) {
            parser_error(state, "ERROR: parsing parameters for callable type: \"%s\"\n", *identifier);
            return -1;
        }
        // Restore the true parent type
        (*tpair)->type = parent_type;
        if (!c_parser_callable_type_store(state, *identifier, naked_callable)) {
            parser_error(state, "ERROR: storing the new callable type: \"%s\"\n", *identifier);
            return -1;
        }
    }
    return result;
}

References c_parser_callable_type_store(), c_parser_new_naked_callable(), rz_type_t::callable, free(), is_declarator(), is_function_declarator(), is_identifier(), rz_callable_at::name, node_malformed_error(), NULL, parse_parameter_list(), parser_debug(), parser_error(), rz_callable_at::ret, RZ_NEW0, rz_num_get(), rz_return_val_if_fail, RZ_TYPE_KIND_ARRAY, RZ_TYPE_KIND_POINTER, strdup(), create_tags_rz::text, ts_node_child_by_field_name(), ts_node_is_named(), ts_node_is_null(), ts_node_named_child(), ts_node_named_child_count(), ts_node_sub_string(), ts_node_type(), type, and rz_type_t::type.

Referenced by parse_declaration_node(), parse_parameter_declaration_node(), parse_struct_node(), parse_typedef_node(), and parse_union_node().

parse_type_descriptor_single()

int parse_type_descriptor_single	(	CParserState *	state,
		TSNode	node,
		const char *	text,
		ParserTypePair **	tpair
	)

Definition at line 1719 of file types_parser.c.

                                                                                                             {
    rz_return_val_if_fail(state && text && tpair, -1);
    rz_return_val_if_fail(!ts_node_is_null(node), -1);
    // We skip simple nodes (e.g. conditions and braces)
    if (!ts_node_is_named(node)) {
        return 0;
    }
    const char *node_type = ts_node_type(node);
    int result = -1;
    if (strcmp(node_type, "type_descriptor")) {
        return -1;
    }
    parser_debug(state, "parse_type_descriptor_single()\n");
 
    int typedesc_node_child_count = ts_node_named_child_count(node);
    if (typedesc_node_child_count < 1) {
        node_malformed_error(state, node, text, "type_descriptor");
        return -1;
    }
    // Type descriptor has three fields:
    // 0. type qualifier (optional)
    // 1. type itself
    // 2. declarator field (optional)
 
    // Parse the type qualifier first
    // FIXME: There could be multiple different type qualifiers in one declaration
    bool is_const = false;
    TSNode first_leaf = ts_node_named_child(node, 0);
    if (ts_node_is_null(first_leaf)) {
        node_malformed_error(state, node, text, "type_descriptor");
        return -1;
    }
    const char *leaf_type = ts_node_type(first_leaf);
    if (!strcmp(leaf_type, "type_qualifier")) {
        char *qualifier = ts_node_sub_string(first_leaf, text);
        parser_debug(state, "has qualifier \"%s\"\n", qualifier);
        if (!strcmp(qualifier, "const")) {
            parser_debug(state, "set const\n");
            is_const = true;
        }
        free(qualifier);
    }
 
    TSNode type_node = ts_node_child_by_field_name(node, "type", 4);
    if (ts_node_is_null(type_node)) {
        node_malformed_error(state, node, text, "type_descriptor");
        parser_error(state, "type_descriptor's type field cannot be NULL\n");
        return -1;
    }
    if (parse_type_node_single(state, type_node, text, tpair, is_const)) {
        node_malformed_error(state, node, text, "type_descriptor");
        parser_error(state, "Cannot parse type_descriptor's type field\n");
        return -1;
    }
    if (!*tpair) {
        parser_error(state, "Failed to parse type_descriptor's type field\n");
        return -1;
    }
    // 2. Optional declarator field
    TSNode type_declarator = ts_node_child_by_field_name(node, "declarator", 10);
    if (!ts_node_is_null(type_declarator)) {
        return parse_type_abstract_declarator_node(state, type_declarator, text, tpair);
    } else {
        result = 0;
    }
    return result;
}

References free(), node_malformed_error(), parse_type_abstract_declarator_node(), parse_type_node_single(), parser_debug(), parser_error(), rz_return_val_if_fail, create_tags_rz::text, ts_node_child_by_field_name(), ts_node_is_named(), ts_node_is_null(), ts_node_named_child(), ts_node_named_child_count(), ts_node_sub_string(), and ts_node_type().

Referenced by rz_type_parse_string_single().

parse_type_node_single()

int parse_type_node_single	(	CParserState *	state,
		TSNode	node,
		const char *	text,
		ParserTypePair **	tpair,
		bool	is_const
	)

Definition at line 1170 of file types_parser.c.

                                                                                                                      {
    rz_return_val_if_fail(state && text && tpair, -1);
    rz_return_val_if_fail(!ts_node_is_null(node), -1);
    // We skip simple nodes (e.g. conditions and braces)
    if (!ts_node_is_named(node)) {
        return 0;
    }
 
    const char *node_type = ts_node_type(node);
    int result = -1;
 
    parser_debug(state, "parse_type_node_single(\"%s\")\n", node_type);
 
    if (!strcmp(node_type, "struct_specifier")) {
        result = parse_struct_node(state, node, text, tpair, is_const);
        if (result || !*tpair) {
            return -1;
        }
    } else if (!strcmp(node_type, "union_specifier")) {
        result = parse_union_node(state, node, text, tpair, is_const);
        if (result || !*tpair) {
            return -1;
        }
    } else if (!strcmp(node_type, "enum_specifier")) {
        result = parse_enum_node(state, node, text, tpair, is_const);
        if (result || !*tpair) {
            return -1;
        }
    } else if (!strcmp(node_type, "type_definition")) {
        result = parse_typedef_node(state, node, text, tpair);
        if (result || !*tpair) {
            return -1;
        }
    } else if (!strcmp(node_type, "sized_type_specifier")) {
        result = parse_sized_primitive_type(state, node, text, tpair, is_const);
        if (result || !*tpair) {
            return -1;
        }
    } else if (!strcmp(node_type, "primitive_type")) {
        result = parse_primitive_type(state, node, text, tpair, is_const);
        if (result || !*tpair) {
            return -1;
        }
    } else if (!strcmp(node_type, "type_identifier")) {
        result = parse_sole_type_name(state, node, text, tpair, is_const);
        if (result || !*tpair) {
            return -1;
        }
    }
    // Another case where there is a declaration clause
    // In this case we should drop the declaration itself
    // and parse only the corresponding type
    // In case of anonymous type we could use identifier as a name for this type?
    //
    return result;
}

References parse_enum_node(), parse_primitive_type(), parse_sized_primitive_type(), parse_sole_type_name(), parse_struct_node(), parse_typedef_node(), parse_union_node(), parser_debug(), rz_return_val_if_fail, create_tags_rz::text, ts_node_is_named(), ts_node_is_null(), and ts_node_type().

Referenced by parse_declaration_node(), parse_parameter_declaration_node(), parse_struct_node(), parse_type_descriptor_single(), parse_typedef_node(), and parse_union_node().

parse_type_nodes_save()

int parse_type_nodes_save	(	CParserState *	state,
		TSNode	node,
		const char *	text
	)

Definition at line 1866 of file types_parser.c.

                                                                              {
    rz_return_val_if_fail(state && text, -1);
    rz_return_val_if_fail(!ts_node_is_null(node), -1);
    // We skip simple nodes (e.g. conditions and braces)
    if (!ts_node_is_named(node)) {
        return 0;
    }
    const char *node_type = ts_node_type(node);
    int result = -1;
    ParserTypePair *tpair = NULL;
    if (!strcmp(node_type, "struct_specifier")) {
        result = parse_struct_node(state, node, text, &tpair, false);
        if (result || !tpair) {
            return -1;
        }
    } else if (!strcmp(node_type, "union_specifier")) {
        result = parse_union_node(state, node, text, &tpair, false);
        if (result || !tpair) {
            return -1;
        }
    } else if (!strcmp(node_type, "enum_specifier")) {
        result = parse_enum_node(state, node, text, &tpair, false);
        if (result || !tpair) {
            return -1;
        }
    } else if (!strcmp(node_type, "type_definition")) {
        result = parse_typedef_node(state, node, text, &tpair);
        if (result || !tpair) {
            return -1;
        }
    }
 
    // Another case where there is a declaration clause
    // In this case we should drop the declaration itself
    // and parse only the corresponding type. An exception for this
    // rule is the function declaration.
    if (!strcmp(node_type, "declaration")) {
        result = parse_declaration_node(state, node, text, &tpair);
        if (result || !tpair) {
            return -1;
        }
    }
 
    if (result) {
        char *typetext = ts_node_sub_string(node, text);
        parser_error(state, "Unsupported type definition: %s\n", typetext);
        free(typetext);
    }
 
    // In case of anonymous type we could use identifier as a name for this type?
    return result;
}

References free(), NULL, parse_declaration_node(), parse_enum_node(), parse_struct_node(), parse_typedef_node(), parse_union_node(), parser_error(), rz_return_val_if_fail, create_tags_rz::text, ts_node_is_named(), ts_node_is_null(), ts_node_sub_string(), and ts_node_type().

Referenced by type_parse_string().

parser_debug()

void parser_debug	(	CParserState *	state,
		const char *	fmt,
			...
	)

Definition at line 37 of file types_parser.c.

                                                             {
    rz_return_if_fail(state && fmt);
    if (state->verbose) {
        va_list ap;
        va_start(ap, fmt);
        rz_strbuf_vappendf(state->debug, fmt, ap);
        va_end(ap);
    }
}

References rz_return_if_fail, and rz_strbuf_vappendf().

Referenced by c_parser_callable_type_store(), parse_declaration_node(), parse_enum_node(), parse_parameter_declaration_node(), parse_parameter_list(), parse_primitive_type(), parse_sized_primitive_type(), parse_sole_type_name(), parse_struct_node(), parse_type_abstract_declarator_node(), parse_type_declarator_node(), parse_type_descriptor_single(), parse_type_node_single(), parse_typedef_node(), parse_union_node(), rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), and type_parse_string().

parser_error()

void parser_error	(	CParserState *	state,
		const char *	fmt,
			...
	)

Definition at line 47 of file types_parser.c.

                                                             {
    rz_return_if_fail(state && fmt);
    va_list ap;
    va_start(ap, fmt);
    rz_strbuf_vappendf(state->errors, fmt, ap);
    va_end(ap);
}

References rz_return_if_fail, and rz_strbuf_vappendf().

Referenced by c_parser_new_enum_type(), c_parser_new_primitive_type(), c_parser_new_structure_type(), c_parser_new_typedef(), c_parser_new_union_type(), parse_declaration_node(), parse_enum_node(), parse_parameter_declaration_node(), parse_parameter_list(), parse_primitive_type(), parse_sized_primitive_type(), parse_sole_type_name(), parse_struct_node(), parse_type_abstract_declarator_node(), parse_type_declarator_node(), parse_type_descriptor_single(), parse_type_nodes_save(), parse_typedef_node(), and parse_union_node().

parser_warning()

void parser_warning	(	CParserState *	state,
		const char *	fmt,
			...
	)

Definition at line 55 of file types_parser.c.

                                                               {
    rz_return_if_fail(state && fmt);
    va_list ap;
    va_start(ap, fmt);
    rz_strbuf_vappendf(state->warnings, fmt, ap);
    va_end(ap);
}

References rz_return_if_fail, and rz_strbuf_vappendf().

Referenced by parse_enum_node(), parse_struct_node(), parse_union_node(), rz_type_parse_string_declaration_single(), rz_type_parse_string_single(), and type_parse_string().