WONKY

#ifndef WONKY_TYPE_C 
#define WONKY_TYPE_C WONKY_TYPE_C
#include "type.h"

struct Type* get_type_error(struct Type *type)
{
	struct Type_Error *ret;

	ret=wonky_calloc(1,sizeof(struct Type_Error));

	ret->specifier=TS_ERROR;
	ret->error=type;

	return (struct Type*)ret;
	
}
struct Type* get_struct_union_type(struct Denotation_Prototype *prototype)
{
	struct Type_Struct_Union *ret;
	
	wonky_assert(prototype->denotation=DT_Prototype);
	prototype->denotation=DT_Object;

	ret=wonky_calloc(1,sizeof(struct Type_Struct_Union));
	ret->specifier=prototype->specifier;
	ret->struct_union=prototype->struct_union;

	ret->is_const=prototype->is_const;
	ret->is_volatile=prototype->is_volatile;

	if(prototype->constraint!=TC_NONE || prototype->sign!=TSIGN_NONE || (prototype->specifier!=TS_UNION && prototype->specifier!=TS_STRUCT))
	{
		return get_type_error((struct Type*)ret);
	}else
	{
		return (struct Type*)ret;
	}
}
struct Struct_Union* get_struct_union_base(struct Scope *scope ,enum Type_Specifier struct_or_union,struct identifier *id)
{
	struct Struct_Union *ret;


	ret=wonky_calloc(1,sizeof(struct Struct_Union));
	ret->specifier=struct_or_union;
	ret->members=wonky_malloc(sizeof(struct Queue));
	Queue_Init(ret->members);

	ret->inner_namespace=(struct Normal_Scope*)get_normal_scope(NULL,BLOCK_SCOPE);
	ret->is_finished=0;
	ret->has_constant_member=0;
	ret->id=id;

	return ret;
}
struct Enum *get_enum_base(struct identifier *id)
{
	struct Enum *ret;
	ret=wonky_malloc(sizeof(struct Enum));
	ret->specifier=TS_ENUM;
	ret->consts=wonky_malloc(sizeof(struct Queue));
	Queue_Init(ret->consts);

	ret->is_finished=0;
	ret->id;

	return ret;
}
struct Type* get_basic_type(struct Denotation_Prototype *prototype)
{
	struct Type_Basic *ret;
	ret=wonky_calloc(1,sizeof(struct Type_Basic));


	wonky_assert(prototype->denotation==DT_Prototype);
	prototype->denotation=DT_Object;

	ret->size=prototype->size;
	ret->is_const=prototype->is_const;
	ret->is_volatile=prototype->is_volatile;
	ret->constraint=prototype->constraint;
	ret->sign=prototype->sign;
	

	if(prototype->specifier==TS_NONE)
	{
		ret->specifier=TS_INT;
	}else
	{
		ret->specifier=prototype->specifier;

	}

	switch(ret->specifier)
	{
		case TS_DOUBLE:
			if(ret->constraint==TC_LONG_LONG 
				|| prototype->constraint==TC_SHORT
				|| prototype->sign!=TSIGN_NONE)
			{
				return get_type_error((struct Type*)ret);
			}
			break;
		case TS_CHAR:
			if(prototype->constraint!=TC_NONE)
			{
				return get_type_error((struct Type*)ret);
			}
			break;
		case TS_INT:
			break;
		default:
			if(prototype->constraint!=TC_NONE || prototype->sign!=TSIGN_NONE)
			{
				return get_type_error((struct Type*)ret);
			}
			
	}
	return (struct Type*)ret;

}
struct Type* get_pointer_type(struct Type *points_to,_Bool is_const,_Bool is_volatile)
{
	struct Type_Pointer *ret;
	ret=wonky_calloc(1,sizeof(struct Type_Pointer));
	ret->specifier=TS_POINTER;
	ret->size=PTR_SIZE;
	ret->points_to=points_to;
	ret->is_const=is_const;
	ret->is_volatile=is_volatile;

	return (struct Type*)ret;

}
struct Type* get_array_type(struct Type *array_of,struct AST* number_of_elements,struct Translation_Data *translation_data)
{
	struct Type_Array *ret;
	ret=wonky_calloc(1,sizeof(struct Type_Array));
	ret->specifier=TS_ARRAY;
	ret->size=0;
	if(number_of_elements!=NULL)
	{
		ret->number_of_elements=evaluate_const_expression_integer(number_of_elements,translation_data);
		delete_ast(number_of_elements);
	}else
	{
		ret->number_of_elements=0;
	}
	ret->is_array_of=array_of;

	return (struct Type*)ret;


}
struct Type* get_array_type_raw(struct Type *array_of,size_t size)
{
	struct Type_Array *ret;
	ret=wonky_calloc(1,sizeof(struct Type_Array));
	ret->specifier=TS_ARRAY;
	ret->size=size;
	ret->is_array_of=array_of;

	return (struct Type*)ret;
}
struct Type* get_enum_type(struct Denotation_Prototype *prototype)
{
	struct Type_Enum *ret;

	wonky_assert(prototype->denotation==DT_Prototype);
	prototype->denotation=DT_Object;

	ret=wonky_calloc(1,sizeof(struct Type_Enum));
	ret->specifier=TS_ENUM;
	ret->enumeration=prototype->enumerator;
	ret->is_const=prototype->is_const;
	ret->is_volatile=prototype->is_volatile;

	if(prototype->sign!=TSIGN_NONE || prototype->constraint!=TC_NONE)
	{
		return get_type_error((struct Type*)ret);
	}

	return (struct Type*)ret;
}

struct Type* get_function_type(struct Type *return_type,struct Queue *parameters,struct Normal_Scope* function_prototype_scope,_Bool is_variadic,struct Translation_Data *translation_data)
{
	struct Type_Function *ret;
	size_t i;
	struct Map *hold_node;

	ret=wonky_calloc(1,sizeof(struct Type_Function));
	ret->specifier=TS_FUNC;

	ret->return_type=return_type;


	ret->function_prototype_scope=function_prototype_scope;


	ret->number_of_arguments=parameters->size;
	ret->arguments=wonky_malloc(sizeof(struct Denoted_Object*)*ret->number_of_arguments);
	ret->is_variadic=is_variadic;
	for(i=0;parameters->size>0;++i)
	{
		ret->arguments[i]=(struct Denoted_Object*)Queue_Pop(parameters);
	}
	wonky_free(parameters);

	if(is_variadic && ret->number_of_arguments==0)
	{
		push_generic_error(translation_data->program,"variadic function needs atleast one named argument");
		return (struct Type*)get_type_error((struct Type*)ret);
	}

	wonky_assert(is_valid_type_function(ret));
	return (struct Type*)ret;
}
_Bool rebase_type(struct Type *rebase,struct Type *onto)
{
	switch(rebase->specifier)
	{
		case TS_POINTER:
			((struct Type_Pointer*)rebase)->points_to=onto;
			return 1;
		case TS_ARRAY:
			((struct Type_Array*)rebase)->is_array_of=onto;
		        return 1;
		case TS_VARIABLE_LENGTH_ARRAY:
			((struct Type_Variable_Length_Array*)rebase)->is_array_of=onto;
			return 1;
		case TS_FUNC:
			((struct Type_Function*)rebase)->return_type=onto;
		default:
			return 0;
	}
	wonky_assert(SHOULD_NOT_REACH_HERE);
}
_Bool is_type_name(struct Translation_Data *translation_data,struct Scope *scope)
{
	struct token *hold;
	struct Denoted *thing;

	hold=token_ptr_check_next_normal_token(translation_data->token_pointer);
	switch(hold->type)
	{
		case KW_ID:
			thing=check_ordinary(scope,((struct token_identifier*)hold)->id);
			if(thing!=NULL && thing->denotation==DT_Typedef) 
				return 1;
			else return 0;
		case KW_CONST:
		case KW_VOLATILE:
		case KW_INT:
		case KW_VOID:
		case KW_CHAR:
		case KW_DOUBLE:
		case KW_FLOAT:
		case KW_LONG:
		case KW_SHORT:
		case KW_EXTERN:
		case KW_STATIC:
		case KW_TYPEDEF:
		case KW_STRUCT:
		case KW_UNION:
		case KW_ENUM:
		case KW_SIGNED:
		case KW_UNSIGNED:
			return 1;
		default:
			return 0;

	}
}
size_t get_type_size(struct Type *type)
{
	switch(type->specifier)
	{
		case TS_VOID:
			return 0;
		case TS_CHAR:
			return 1;
		case TS_INT:
			return INT_SIZE;
		case TS_FLOAT:
			return FLOAT_SIZE;
		case TS_DOUBLE:
			return FLOAT_SIZE*2;
		case TS_STRUCT:
			return ((struct Type_Struct_Union*)type)->struct_union->size;
		case TS_ENUM:
			return INT_SIZE;
		case TS_UNION:
			return ((struct Type_Struct_Union*)type)->struct_union->size;
		case TS_POINTER:
			return PTR_SIZE;
		case TS_ARRAY:
			return ((struct Type_Array*)type)->size;
		case TS_FUNC:
			return 0;
		case TS_NONE:
			return 0;
		case TS_ERROR:
			return 0;

	}	
}


void delete_enum(struct Enum *enumeration)
{
	if(enumeration->id!=NULL)
		wonky_free(enumeration->id);

	while(enumeration->consts->size>0)
		Queue_Pop(enumeration->consts);
	wonky_free(enumeration);
}
void delete_struct_union(struct Struct_Union *su)
{
	if(su->id!=NULL)
		wonky_free(su->id);
	delete_scope((struct Scope*)su->inner_namespace);
	while(su->members->size>0)
		Queue_Pop(su->members);

	wonky_free(su);
}

void delete_type(void *type)
{
	if(((struct Type*)type)->specifier!=TS_FUNC)
	{
		wonky_free(type);
	}else
	{
		delete_normal_scope(AS_TYPE_FUNC_PTR(type)->function_prototype_scope);
		wonky_free(AS_TYPE_FUNC_PTR(type)->arguments);
		wonky_free(type);
	}
}



struct Type_Basic* get_type_insecure(enum Type_Specifier type_specifier,enum Type_Signedness sign,enum Type_Constraint constraint,size_t type_size)
{
	struct Type_Basic *ret;
	ret=wonky_calloc(1,sizeof(struct Type_Basic));

	ret->specifier=type_specifier;
	ret->size=type_size;
	ret->constraint=constraint;
	ret->sign=sign;

	return ret;
}
_Bool types_are_identical(struct Type *a,struct Type *b)
{
	if(a->specifier!=b->specifier)
		return 0;

	switch(a->specifier)
	{
		case TS_VOID:
		case TS_CHAR:
		case TS_INT:
		case TS_FLOAT:
		case TS_DOUBLE:
			return 1;

		case TS_UNION:
		case TS_STRUCT:
			return 1;
		case TS_ENUM:
			return 1;
		case TS_POINTER:
			{
				struct Type_Pointer *ap,*bp;
				ap=(struct Type_Pointer*)a;
				bp=(struct Type_Pointer*)b;

				return 
					types_are_identical(ap->points_to,bp->points_to)
					&&
					ap->is_const==bp->is_const
					&&
					ap->is_volatile==bp->is_volatile
					;
					
			}
		case TS_ARRAY:
			{
				struct Type_Array *aa,*ba;
				aa=(struct Type_Array*)a;
				ba=(struct Type_Array*)b;
				return
					types_are_identical(aa->is_array_of,ba->is_array_of)
					&&
					aa->number_of_elements==ba->number_of_elements
					;
			}
		case TS_FUNC:
		{
			struct Type_Function *af,*bf;
			size_t i;

			af=(struct Type_Function*)a;
			bf=(struct Type_Function*)b;

			if(af->number_of_arguments!=bf->number_of_arguments 
					|| !types_are_identical(af->return_type,bf->return_type))
				return 0;

			for(i=0;i<af->number_of_arguments;++i)
			{
				if(!types_are_identical(af->arguments[i]->object->type,bf->arguments[i]->object->type))
					return 0;
			}
			return 1;
		}
		default:
			return 0;
	}
	wonky_assert(SHOULD_NOT_REACH_HERE);
}

/* 6.2.7 
 * two types have compatible type if their types are the same.
 * Additionally ... TODO
 * 
 * */
_Bool types_are_compatible(struct Type *a,struct Type *b)
{
	return types_are_identical(a,b) || ( type_is_constant(a)==type_is_constant(b) && type_is_volatile(a)==type_is_volatile(b) 
		&& types_are_compatible_inner(a,b) );
}
_Bool types_are_compatible_unqualified(struct Type *a,struct Type *b)
{
	return types_are_identical(a,b) || types_are_compatible_inner(a,b);
}
_Bool types_are_compatible_inner(struct Type *a,struct Type *b)
{
	switch(a->specifier)
	{
		case TS_STRUCT:
		case TS_UNION:
			if(b->specifier!=a->specifier)
				return 0;
			else
				return types_of_struct_unions_are_compatible_unqualified(
						((struct Type_Struct_Union*)a)->struct_union,
						((struct Type_Struct_Union*)b)->struct_union);
		case TS_POINTER:
			if(b->specifier!=TS_POINTER)
				return 0;
			else
				return types_of_pointers_are_compatible_unqualified((struct Type_Pointer*)a,(struct Type_Pointer*)b);
		case TS_ARRAY:
			if(b->specifier!=TS_ARRAY)
				return 0;
			else
				return types_of_arrays_are_compatible_unqualified((struct Type_Array*)a,(struct Type_Array*)b);
		case TS_FUNC:
			if(b->specifier!=TS_FUNC)
				return 0;
			else 
				return types_of_functions_are_compatible_unqualified((struct Type_Function*)a,(struct Type_Function*)b);
		case TS_VOID:
		case TS_CHAR:
		case TS_INT:
		case TS_FLOAT:
		case TS_DOUBLE:
			if(b->specifier!=a->specifier)
			{
				return 0;
			}
			else
			{
				struct Type_Basic *basic_a;
				struct Type_Basic *basic_b;

				basic_a=(struct Type_Basic*)a;
				basic_b=(struct Type_Basic*)b;

				if(basic_a->constraint!=basic_b->constraint)
					return 0;
				if(basic_a->sign!=basic_b->sign)
					return 0;

				return 1; 
			}
	}
	wonky_assert(SHOULD_NOT_REACH_HERE);
	return 0;
}
_Bool types_of_pointers_are_compatible_unqualified(struct Type_Pointer *a,struct Type_Pointer *b)
{
	return types_are_compatible(a->points_to,b->points_to);
}
_Bool types_of_arrays_are_compatible_unqualified(struct Type_Array *a,struct Type_Array *b)
{
	if(!types_are_compatible(a->is_array_of,b->is_array_of))
		return 0;
	/*0 number of elements means incomplete array type*/
	if(a->number_of_elements==0 || b->number_of_elements==0)
		return 1;
	return a->number_of_elements==b->number_of_elements;
}
_Bool types_of_functions_are_compatible_unqualified(struct Type_Function *a,struct Type_Function *b)
{
	size_t current_argument;

	if(!types_are_compatible(a->return_type,b->return_type))
		return 0;
	/*TODO add check for variadic function*/
	if(a->number_of_arguments!=b->number_of_arguments)
		return 0;

	for(current_argument=0;current_argument<a->number_of_arguments;++current_argument)
	{
		if(!types_are_compatible(a->arguments[current_argument]->object->type,b->arguments[current_argument]->object->type))
			return 0;
	}
	return 1;
}
_Bool types_of_struct_unions_are_compatible_unqualified(struct Struct_Union *a,struct Struct_Union *b)
{
	struct Queue_Node *it_a;
	struct Queue_Node *it_b;

	if( (a->id==NULL || b->id==NULL ) && b->id!=a->id)
		return 0;
	if(a->id!=NULL && a->id!=b->id)
		return 0;
	if(a->members->size!=b->members->size)
		return 0;
	for(it_a=a->members->first,it_b=a->members->first;it_a!=NULL && it_b!=NULL; it_a=it_a->prev,it_b=it_b->prev)
	{
		struct Denoted_Object *object_a;
		struct Denoted_Object *object_b;

		object_a=(struct Denoted_Object*)it_a->data;
		object_b=(struct Denoted_Object*)it_b->data;

		if(!types_are_compatible( object_a->object->type, object_b->object->type))
			return 0;
		if((object_a->id==NULL || object_b->id==NULL) && object_b->id!=object_a->id)
			return 0;
		if(object_a->id!=NULL && a->id!=b->id)
			return 0;
	}
	return 1;
}
_Bool types_of_bitfields_are_compatible_unqalified(struct Type_Bit_Field *a,struct Type_Bit_Field *b)
{
	return 1;
}
_Bool types_of_enum_are_compatible_unqualified(struct Type_Enum *a,struct Type_Enum *b)
{
	return 1;
}


_Bool type_is_scalar(struct Type *type)
{
	return (type->specifier==TS_CHAR || type->specifier==TS_INT || type->specifier==TS_FLOAT || type->specifier==TS_DOUBLE || type->specifier==TS_POINTER);
}

_Bool type_is_a_plain_signed_int(struct Type *type)
{

	return type->specifier==TS_INT && ((struct Type_Basic*)type)->constraint==TC_NONE && ((struct Type_Basic*)type)->sign==TSIGN_SIGNED;
}
_Bool type_is_of_object(struct Type *type)
{
	return !(type->specifier==TS_VOID || type->specifier==TS_FUNC || type->specifier==TS_NONE || type->specifier==TS_ERROR);
}
_Bool type_is_complete(struct Type *type)
{
	if(type->specifier==TS_ENUM)
	{
		return ((struct Type_Enum*)type)->enumeration->is_finished;
	}else if(type->specifier==TS_UNION || type->specifier==TS_STRUCT)
	{
		return ((struct Type_Struct_Union*)type)->struct_union->is_finished;
	}else
	{
		return 1;
	}
}
_Bool type_is_integer_type(struct Type *type)
{
	return type->specifier==TS_INT || type->specifier==TS_CHAR;
}
_Bool type_is_basic(struct Type *type)
{
	return (type->specifier==TS_INT || type->specifier==TS_CHAR || type->specifier==TS_DOUBLE || type->specifier==TS_FLOAT || type->specifier==TS_VOID);
}
_Bool type_is_character(struct Type *type)
{
	return type->specifier==TS_CHAR;
}
_Bool type_is_arithmetic(struct Type *type)
{
	return (type->specifier==TS_CHAR || type->specifier==TS_INT || type->specifier==TS_FLOAT || type->specifier==TS_DOUBLE );
}
_Bool type_is_aggregate(struct Type *type)
{
	return (type->specifier==TS_ARRAY || type->specifier==TS_UNION || type->specifier==TS_STRUCT);
}
_Bool type_is_struct_union(struct Type *type)
{
	return (type->specifier==TS_STRUCT || type->specifier==TS_UNION);
}
_Bool type_is_constant_or_has_constant_member(struct Type *type)
{
	if(type->specifier==TS_STRUCT || type->specifier==TS_UNION)
	{
		if( ((struct Type_Struct_Union*)type)->is_const)
		{
			return 1;
		}else
		{
			struct Queue_Node *it;
			for(it=((struct Type_Struct_Union*)type)->struct_union->members->first;it!=NULL;it=it->prev)
			{
				if( type_is_constant_or_has_constant_member(((struct Denoted_Object*)it->data)->object->type))
					return 1;
			}
			return 0;
		}
	}else if(type_is_basic(type))
	{
		return ((struct Type_Basic*)type)->is_const;
	}else if(type->specifier==TS_POINTER)
	{
		return ((struct Type_Pointer*)type)->is_const;
	}else{
		return 0;
	}
}

_Bool type_is_qualified(struct Type *type)
{
	return 1;
}
struct Type* get_type_for_promotion(struct Type *type)
{
	if(type->specifier==TS_CHAR)
	{
		return (struct Type*)get_type_insecure(TS_INT,TSIGN_NONE,TC_NONE,INT_SIZE);
	}
	else if(type->specifier==TS_INT)
	{
		struct Type_Basic *cache_type;
		cache_type=(struct Type_Basic*)type;
		if(cache_type->constraint==TC_SHORT)
			return (struct Type*)get_type_insecure(TS_INT,TSIGN_NONE,TC_NONE,INT_SIZE);
		else
			return type;

	}else
	{
		return type;
	}


	
}
/*TODO*/
struct Type* get_unqualified_version_of_type(struct Type *type)
{
	struct Type *hold_unqualified_type;

	return type;

	/*
	switch(type->specifier)
	{
		case TS_VOID:
		case TS_CHAR:
		case TS_INT:
		case TS_FLOAT:
		case TS_DOUBLE:

			hold_unqualified_type=type;
			break;
		case TS_STRUCT:
		case TS_UNION:
			prototype->specifier=type->specifier;
			prototype->struct_union=((struct Type_Struct_Union*)type)->struct_union;
			hold_unqualified_type=get_struct_union_type(prototype,translation_data);
			break;
		case TS_ENUM:
			prototype->specifier=TS_ENUM;
			prototype->enumerator=((struct Type_Enum*)type)->enumeration;

			hold_unqualified_type=get_enum_type(prototype,translation_data);
			break;
		case TS_POINTER:
			hold_unqualified_type=get_pointer_type(((struct Type_Pointer*)type)->points_to,0,0,translation_data);
			break;
		case TS_ARRAY:
			hold_unqualified_type=type;
			break;
		case TS_FUNC:
			hold_unqualified_type=type;
			break;
		default:
			return NULL;

	}
	delete_denoted_prototype(prototype);
	return hold_unqualified_type;
	*/
}
/*TODO*/
int type_get_integer_conversion_rank(struct Type_Basic *type)
{
	switch(type->specifier)
	{
		case TS_CHAR:
			return 0;
		case TS_INT:
			switch(type->constraint)
			{
				case TC_LONG_LONG:
					return 4;
				case TC_LONG:
					return 3;
				case TC_NONE:
					return 2;
				case TC_SHORT:
					return 1;
				default:
					wonky_assert(SHOULD_NOT_REACH_HERE);
			}
		default:
			wonky_assert(SHOULD_NOT_REACH_HERE);
	}
}
_Bool type_is_pointer(struct Type *type)
{
	return (type->specifier==TS_POINTER);
}
_Bool type_is_pointer_to_object(struct Type *type)
{
	return (type->specifier==TS_POINTER && type_is_of_object(AS_TYPE_PTR_PTR(type)->points_to));
}
_Bool type_is_pointer_to_incomplete_type(struct Type *type)
{
	return (type->specifier==TS_POINTER && !type_is_complete(AS_TYPE_PTR_PTR(type)->points_to));
}
_Bool type_is_pointer_to_void(struct Type *type)
{
	return (type->specifier==TS_POINTER && type_is_basic(AS_TYPE_PTR_PTR(type)->points_to) && AS_BASIC_TYPE_PTR(AS_TYPE_PTR_PTR(type)->points_to)->specifier==TS_VOID);
}
_Bool type_is_pointer_to_function(struct Type *type)
{
	return (type->specifier==TS_POINTER && AS_TYPE_PTR_PTR(type)->points_to->specifier==TS_FUNC);
}

_Bool type_is_real(struct Type *type)
{
	/*TODO add _Complex keyword and check for it here*/
	return type_is_floating(type) || type_is_integer_type(type);
}
_Bool type_is_floating(struct Type *type)
{
	return (type->specifier==TS_FLOAT || type->specifier==TS_DOUBLE);
}
_Bool type_is_derivative(struct Type *type)
{
	return (type->specifier==TS_POINTER || type->specifier==TS_ARRAY || type->specifier==TS_FUNC);
}
_Bool type_is_a_normal_string(struct Type *type)
{
	return type_is_an_array(type) && type_is_character(((struct Type_Array*)type)->is_array_of);
}
_Bool type_is_a_variable_length_array(struct Type *type)
{
	return 0;
}
_Bool type_is_an_array(struct Type *type)
{
	return type->specifier==TS_ARRAY;
}
_Bool type_is_constant(struct Type *type)
{
	switch(type->specifier)
	{
		case TS_VOID:
		case TS_CHAR:
		case TS_INT:
		case TS_FLOAT:
		case TS_DOUBLE:
			return ((struct Type_Basic*)type)->is_const;
		case TS_STRUCT:
		case TS_UNION:
			return ((struct Type_Struct_Union*)type)->is_const ||
				((struct Type_Struct_Union*)type)->struct_union->has_constant_member;
		case TS_ENUM:
			return ((struct Type_Enum*)type)->is_const;
		case TS_POINTER:
			return ((struct Type_Pointer*)type)->is_const;
	}
	return 0;
}
_Bool type_is_volatile(struct Type *type)
{
	switch(type->specifier)
	{
		case TS_VOID:
		case TS_CHAR:
		case TS_INT:
		case TS_FLOAT:
		case TS_DOUBLE:
			return ((struct Type_Basic*)type)->is_volatile;
		case TS_STRUCT:
		case TS_UNION:
			/*
			return ((struct Type_Struct_Union*)type)->is_const ||
				((struct Type_Struct_Union*)type)->struct_union->has_volatile_member;
			*/
			return ((struct Type_Struct_Union*)type)->is_volatile;
		case TS_ENUM:
			return ((struct Type_Enum*)type)->is_const;
		case TS_POINTER:
			return ((struct Type_Pointer*)type)->is_const;
	}
	return 0;
}
#endif