projects
/
cparser
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
renamed declaration_type_t to declaration_kind_t
[cparser]
/
type_hash.c
diff --git
a/type_hash.c
b/type_hash.c
index
1e07c1f
..
344d458
100644
(file)
--- a/
type_hash.c
+++ b/
type_hash.c
@@
-53,7
+53,7
@@
static unsigned hash_type(const type_t *type);
static unsigned hash_function_type(const function_type_t *type)
{
static unsigned hash_function_type(const function_type_t *type)
{
- unsigned result = hash_ptr(type->re
sult
_type);
+ unsigned result = hash_ptr(type->re
turn
_type);
function_parameter_t *parameter = type->parameters;
while(parameter != NULL) {
function_parameter_t *parameter = type->parameters;
while(parameter != NULL) {
@@
-81,42
+81,42
@@
static unsigned hash_type(const type_t *type)
{
unsigned hash = 0;
{
unsigned hash = 0;
- switch(type->
type
) {
+ switch(type->
kind
) {
case TYPE_INVALID:
panic("internalizing void or invalid types not possible");
return 0;
case TYPE_ATOMIC:
case TYPE_INVALID:
panic("internalizing void or invalid types not possible");
return 0;
case TYPE_ATOMIC:
- hash = hash_atomic_type(
(const atomic_type_t*) type
);
+ hash = hash_atomic_type(
&type->atomic
);
break;
case TYPE_ENUM:
break;
case TYPE_ENUM:
- hash = hash_enum_type(
(const enum_type_t*) type
);
+ hash = hash_enum_type(
&type->enumt
);
break;
case TYPE_COMPOUND_STRUCT:
case TYPE_COMPOUND_UNION:
break;
case TYPE_COMPOUND_STRUCT:
case TYPE_COMPOUND_UNION:
- hash = hash_compound_type(
(const compound_type_t*) type
);
+ hash = hash_compound_type(
&type->compound
);
break;
case TYPE_FUNCTION:
break;
case TYPE_FUNCTION:
- hash = hash_function_type(
(const function_type_t*) type
);
+ hash = hash_function_type(
&type->function
);
break;
case TYPE_POINTER:
break;
case TYPE_POINTER:
- hash = hash_pointer_type(
(const pointer_type_t*) type
);
+ hash = hash_pointer_type(
&type->pointer
);
break;
case TYPE_ARRAY:
break;
case TYPE_ARRAY:
- hash = hash_array_type(
(const array_type_t*) type
);
+ hash = hash_array_type(
&type->array
);
break;
case TYPE_BUILTIN:
break;
case TYPE_BUILTIN:
- hash = hash_ptr(
((const builtin_type_t*) type)->
symbol);
+ hash = hash_ptr(
type->builtin.
symbol);
break;
case TYPE_TYPEDEF:
break;
case TYPE_TYPEDEF:
- hash = hash_ptr(
((const compound_type_t*) type)->
declaration);
+ hash = hash_ptr(
type->typedeft.
declaration);
break;
case TYPE_TYPEOF:
break;
case TYPE_TYPEOF:
- hash = hash_typeof_type(
(const typeof_type_t*) type
);
+ hash = hash_typeof_type(
&type->typeoft
);
break;
}
unsigned some_prime = 99991;
break;
}
unsigned some_prime = 99991;
- hash ^= some_prime * type->qualifiers;
+ hash ^= some_prime * type->
base.
qualifiers;
return hash;
}
return hash;
}
@@
-130,12
+130,14
@@
static bool atomic_types_equal(const atomic_type_t *type1,
static bool function_types_equal(const function_type_t *type1,
const function_type_t *type2)
{
static bool function_types_equal(const function_type_t *type1,
const function_type_t *type2)
{
- if(type1->re
sult_type != type2->result
_type)
+ if(type1->re
turn_type != type2->return
_type)
return false;
if(type1->variadic != type2->variadic)
return false;
if(type1->unspecified_parameters != type2->unspecified_parameters)
return false;
return false;
if(type1->variadic != type2->variadic)
return false;
if(type1->unspecified_parameters != type2->unspecified_parameters)
return false;
+ if(type1->kr_style_parameters != type2->kr_style_parameters)
+ return false;
function_parameter_t *param1 = type1->parameters;
function_parameter_t *param2 = type2->parameters;
function_parameter_t *param1 = type1->parameters;
function_parameter_t *param2 = type2->parameters;
@@
-212,42
+214,33
@@
static bool types_equal(const type_t *type1, const type_t *type2)
{
if(type1 == type2)
return true;
{
if(type1 == type2)
return true;
- if(type1->
type != type2->type
)
+ if(type1->
kind != type2->kind
)
return false;
return false;
- if(type1->
qualifiers != type2->
qualifiers)
+ if(type1->
base.qualifiers != type2->base.
qualifiers)
return false;
return false;
- switch(type1->
type
) {
+ switch(type1->
kind
) {
case TYPE_INVALID:
return false;
case TYPE_ATOMIC:
case TYPE_INVALID:
return false;
case TYPE_ATOMIC:
- return atomic_types_equal((const atomic_type_t*) type1,
- (const atomic_type_t*) type2);
+ return atomic_types_equal(&type1->atomic, &type2->atomic);
case TYPE_ENUM:
case TYPE_ENUM:
- return enum_types_equal((const enum_type_t*) type1,
- (const enum_type_t*) type2);
+ return enum_types_equal(&type1->enumt, &type2->enumt);
case TYPE_COMPOUND_STRUCT:
case TYPE_COMPOUND_UNION:
case TYPE_COMPOUND_STRUCT:
case TYPE_COMPOUND_UNION:
- return compound_types_equal((const compound_type_t*) type1,
- (const compound_type_t*) type2);
+ return compound_types_equal(&type1->compound, &type2->compound);
case TYPE_FUNCTION:
case TYPE_FUNCTION:
- return function_types_equal((const function_type_t*) type1,
- (const function_type_t*) type2);
+ return function_types_equal(&type1->function, &type2->function);
case TYPE_POINTER:
case TYPE_POINTER:
- return pointer_types_equal((const pointer_type_t*) type1,
- (const pointer_type_t*) type2);
+ return pointer_types_equal(&type1->pointer, &type2->pointer);
case TYPE_ARRAY:
case TYPE_ARRAY:
- return array_types_equal((const array_type_t*) type1,
- (const array_type_t*) type2);
+ return array_types_equal(&type1->array, &type2->array);
case TYPE_BUILTIN:
case TYPE_BUILTIN:
- return builtin_types_equal((const builtin_type_t*) type1,
- (const builtin_type_t*) type2);
+ return builtin_types_equal(&type1->builtin, &type2->builtin);
case TYPE_TYPEOF:
case TYPE_TYPEOF:
- return typeof_types_equal((const typeof_type_t*) type1,
- (const typeof_type_t*) type2);
+ return typeof_types_equal(&type1->typeoft, &type2->typeoft);
case TYPE_TYPEDEF:
case TYPE_TYPEDEF:
- return typedef_types_equal((const typedef_type_t*) type1,
- (const typedef_type_t*) type2);
+ return typedef_types_equal(&type1->typedeft, &type2->typedeft);
}
abort();
}
abort();