types_storage.c File Reference

#include <rz_types.h>
#include <rz_list.h>
#include <rz_util/rz_str.h>
#include <rz_util/rz_assert.h>
#include <rz_type.h>
#include <tree_sitter/api.h>
#include <types_parser.h>

Go to the source code of this file.

Functions
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_naked_type (CParserState *state, RZ_NONNULL const char *name)
	Creates new type alias naked type (without base type) based on the name. More...
RZ_OWN ParserTypePair *	c_parser_new_typedef_forward_definition (CParserState *state, RZ_NONNULL const char *name)
	Creates new type alias 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_typedef_forward_definition()

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

Creates new type alias forward definition.

Parameters

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

Definition at line 653 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 typedef 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 typedef if it exists already in the forward
        // definitions table with the same name
        return NULL;
    }
 
    ParserTypePair *tpair = c_parser_new_typedef_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_typedef_naked_type(), NULL, and rz_return_val_if_fail.

c_parser_new_typedef_naked_type()

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

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

Parameters

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

Definition at line 625 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_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 c_parser_new_typedef(), and c_parser_new_typedef_forward_definition().

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_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.