9 static struct obstack _type_obst;
10 struct obstack *type_obst = &_type_obst;
12 static int type_visited = 0;
13 static bool print_compound_entries;
15 static void intern_print_type_pre(type_t *type);
16 static void intern_print_type_post(type_t *type);
20 obstack_init(type_obst);
25 obstack_free(type_obst, NULL);
28 void type_set_output(FILE *stream)
33 void set_print_compound_entries(bool enabled)
35 print_compound_entries = enabled;
38 void inc_type_visited(void)
44 void print_type_qualifiers(unsigned qualifiers)
46 if(qualifiers & TYPE_QUALIFIER_CONST) fputs("const ", out);
47 if(qualifiers & TYPE_QUALIFIER_VOLATILE) fputs("volatile ", out);
48 if(qualifiers & TYPE_QUALIFIER_RESTRICT) fputs("restrict ", out);
52 void print_atomic_type(const atomic_type_t *type)
54 print_type_qualifiers(type->type.qualifiers);
58 case ATOMIC_TYPE_INVALID: s = "INVALIDATOMIC"; break;
59 case ATOMIC_TYPE_VOID: s = "void"; break;
60 case ATOMIC_TYPE_BOOL: s = "_Bool"; break;
61 case ATOMIC_TYPE_CHAR: s = "char"; break;
62 case ATOMIC_TYPE_SCHAR: s = "signed char"; break;
63 case ATOMIC_TYPE_UCHAR: s = "unsigned char"; break;
64 case ATOMIC_TYPE_INT: s = "int"; break;
65 case ATOMIC_TYPE_UINT: s = "unsigned int"; break;
66 case ATOMIC_TYPE_SHORT: s = "short"; break;
67 case ATOMIC_TYPE_USHORT: s = "unsigned short"; break;
68 case ATOMIC_TYPE_LONG: s = "long"; break;
69 case ATOMIC_TYPE_ULONG: s = "unsigned long"; break;
70 case ATOMIC_TYPE_LONGLONG: s = "long long"; break;
71 case ATOMIC_TYPE_ULONGLONG: s = "unsigned long long"; break;
72 case ATOMIC_TYPE_LONG_DOUBLE: s = "long double"; break;
73 case ATOMIC_TYPE_FLOAT: s = "float"; break;
74 case ATOMIC_TYPE_DOUBLE: s = "double"; break;
75 default: s = "UNKNOWNATOMIC"; break;
80 static void print_function_type_pre(const function_type_t *type)
82 print_type_qualifiers(type->type.qualifiers);
84 intern_print_type_pre(type->result_type);
86 /* TODO: don't emit braces if we're the toplevel type... */
90 static void print_function_type_post(const function_type_t *type,
91 const context_t *context)
93 /* TODO: don't emit braces if we're the toplevel type... */
94 intern_print_type_post(type->result_type);
100 if(context == NULL) {
101 function_parameter_t *parameter = type->parameters;
102 for( ; parameter != NULL; parameter = parameter->next) {
108 print_type(parameter->type);
111 declaration_t *parameter = context->declarations;
112 for( ; parameter != NULL; parameter = parameter->next) {
118 print_type_ext(parameter->type, parameter->symbol,
119 ¶meter->context);
130 if(first && !type->unspecified_parameters) {
137 void print_pointer_type_pre(const pointer_type_t *type)
139 intern_print_type_pre(type->points_to);
141 print_type_qualifiers(type->type.qualifiers);
144 static void print_pointer_type_post(const pointer_type_t *type)
146 intern_print_type_post(type->points_to);
149 static void print_array_type_post(const array_type_t *type)
152 if(type->is_static) {
153 fputs("static ", out);
155 print_type_qualifiers(type->type.qualifiers);
156 if(type->size != NULL) {
157 print_expression(type->size);
162 void print_enum_definition(const declaration_t *declaration)
168 declaration_t *entry = declaration->next;
169 for( ; entry != NULL && entry->storage_class == STORAGE_CLASS_ENUM_ENTRY;
170 entry = entry->next) {
173 fprintf(out, "%s", entry->symbol->string);
174 if(entry->init.initializer != NULL) {
176 print_expression(entry->init.enum_value);
186 static void print_type_enum(const enum_type_t *type)
188 print_type_qualifiers(type->type.qualifiers);
191 declaration_t *declaration = type->declaration;
192 symbol_t *symbol = declaration->symbol;
194 fputs(symbol->string, out);
196 print_enum_definition(declaration);
200 void print_compound_definition(const declaration_t *declaration)
205 declaration_t *iter = declaration->context.declarations;
206 for( ; iter != NULL; iter = iter->next) {
208 print_declaration(iter);
217 static void print_compound_type(const compound_type_t *type)
219 print_type_qualifiers(type->type.qualifiers);
221 if(type->type.type == TYPE_COMPOUND_STRUCT) {
222 fputs("struct ", out);
224 assert(type->type.type == TYPE_COMPOUND_UNION);
225 fputs("union ", out);
228 declaration_t *declaration = type->declaration;
229 symbol_t *symbol = declaration->symbol;
231 fputs(symbol->string, out);
233 print_compound_definition(declaration);
237 static void print_typedef_type_pre(typedef_type_t *type)
239 fputs(type->declaration->symbol->string, out);
242 static void print_typeof_type_pre(typeof_type_t *type)
244 fputs("typeof(", out);
245 if(type->expression != NULL) {
246 assert(type->typeof_type == NULL);
247 print_expression(type->expression);
249 print_type(type->typeof_type);
254 static void intern_print_type_pre(type_t *type)
258 fputs("invalid", out);
261 print_type_enum((enum_type_t*) type);
264 print_atomic_type((atomic_type_t*) type);
266 case TYPE_COMPOUND_STRUCT:
267 case TYPE_COMPOUND_UNION:
268 print_compound_type((compound_type_t*) type);
271 fputs(((builtin_type_t*) type)->symbol->string, out);
274 print_function_type_pre((function_type_t*) type);
277 print_pointer_type_pre((pointer_type_t*) type);
282 print_typedef_type_pre((typedef_type_t*) type);
285 print_typeof_type_pre((typeof_type_t*) type);
288 fputs("unknown", out);
291 static void intern_print_type_post(type_t *type)
295 print_function_type_post((const function_type_t*) type, NULL);
298 print_pointer_type_post((const pointer_type_t*) type);
301 print_array_type_post((const array_type_t*) type);
306 case TYPE_COMPOUND_STRUCT:
307 case TYPE_COMPOUND_UNION:
315 void print_type(type_t *type)
317 print_type_ext(type, NULL, NULL);
320 void print_type_ext(type_t *type, const symbol_t *symbol,
321 const context_t *context)
324 fputs("nil type", out);
328 intern_print_type_pre(type);
331 fputs(symbol->string, out);
333 if(type->type == TYPE_FUNCTION) {
334 print_function_type_post((const function_type_t*) type, context);
336 intern_print_type_post(type);
340 bool type_valid(const type_t *type)
342 return type->type != TYPE_INVALID;
345 bool is_type_integer(const type_t *type)
347 if(type->type == TYPE_ENUM)
350 if(type->type != TYPE_ATOMIC)
353 atomic_type_t *atomic_type = (atomic_type_t*) type;
354 switch(atomic_type->atype) {
355 case ATOMIC_TYPE_BOOL:
356 case ATOMIC_TYPE_CHAR:
357 case ATOMIC_TYPE_SCHAR:
358 case ATOMIC_TYPE_UCHAR:
359 case ATOMIC_TYPE_SHORT:
360 case ATOMIC_TYPE_USHORT:
361 case ATOMIC_TYPE_INT:
362 case ATOMIC_TYPE_UINT:
363 case ATOMIC_TYPE_LONG:
364 case ATOMIC_TYPE_ULONG:
365 case ATOMIC_TYPE_LONGLONG:
366 case ATOMIC_TYPE_ULONGLONG:
373 bool is_type_floating(const type_t *type)
375 if(type->type != TYPE_ATOMIC)
378 atomic_type_t *atomic_type = (atomic_type_t*) type;
379 switch(atomic_type->atype) {
380 case ATOMIC_TYPE_FLOAT:
381 case ATOMIC_TYPE_DOUBLE:
382 case ATOMIC_TYPE_LONG_DOUBLE:
383 #ifdef PROVIDE_COMPLEX
384 case ATOMIC_TYPE_FLOAT_COMPLEX:
385 case ATOMIC_TYPE_DOUBLE_COMPLEX:
386 case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:
387 case ATOMIC_TYPE_FLOAT_IMAGINARY:
388 case ATOMIC_TYPE_DOUBLE_IMAGINARY:
389 case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY:
397 bool is_type_signed(const type_t *type)
399 /* enum types are int for now */
400 if(type->type == TYPE_ENUM)
403 if(type->type != TYPE_ATOMIC)
406 atomic_type_t *atomic_type = (atomic_type_t*) type;
407 switch(atomic_type->atype) {
408 case ATOMIC_TYPE_CHAR:
409 case ATOMIC_TYPE_SCHAR:
410 case ATOMIC_TYPE_SHORT:
411 case ATOMIC_TYPE_INT:
412 case ATOMIC_TYPE_LONG:
413 case ATOMIC_TYPE_LONGLONG:
414 case ATOMIC_TYPE_FLOAT:
415 case ATOMIC_TYPE_DOUBLE:
416 case ATOMIC_TYPE_LONG_DOUBLE:
417 #ifdef PROVIDE_COMPLEX
418 case ATOMIC_TYPE_FLOAT_COMPLEX:
419 case ATOMIC_TYPE_DOUBLE_COMPLEX:
420 case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:
421 case ATOMIC_TYPE_FLOAT_IMAGINARY:
422 case ATOMIC_TYPE_DOUBLE_IMAGINARY:
423 case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY:
427 case ATOMIC_TYPE_BOOL:
428 case ATOMIC_TYPE_UCHAR:
429 case ATOMIC_TYPE_USHORT:
430 case ATOMIC_TYPE_UINT:
431 case ATOMIC_TYPE_ULONG:
432 case ATOMIC_TYPE_ULONGLONG:
435 case ATOMIC_TYPE_INVALID:
436 case ATOMIC_TYPE_VOID:
440 panic("invalid atomic type found");
444 bool is_type_arithmetic(const type_t *type)
446 if(is_type_integer(type) || is_type_floating(type))
452 bool is_type_scalar(const type_t *type)
454 if(type->type == TYPE_POINTER)
457 return is_type_arithmetic(type);
460 bool is_type_incomplete(const type_t *type)
463 case TYPE_COMPOUND_STRUCT:
464 case TYPE_COMPOUND_UNION: {
465 const compound_type_t *compound_type
466 = (const compound_type_t*) type;
467 declaration_t *declaration = compound_type->declaration;
468 return !declaration->init.is_defined;
482 panic("is_type_incomplete called without typerefs skipped");
487 panic("invalid type found");
490 bool types_compatible(const type_t *type1, const type_t *type2)
497 bool pointers_compatible(const type_t *type1, const type_t *type2)
499 assert(type1->type == TYPE_POINTER);
500 assert(type2->type == TYPE_POINTER);
501 pointer_type_t *pointer_type1 = (pointer_type_t*) type1;
502 pointer_type_t *pointer_type2 = (pointer_type_t*) type2;
503 return types_compatible(pointer_type1->points_to,
504 pointer_type2->points_to);
507 type_t *skip_typeref(type_t *type)
512 const typedef_type_t *typedef_type = (const typedef_type_t*) type;
513 type = typedef_type->declaration->type;
517 const typeof_type_t *typeof_type = (const typeof_type_t *) type;
518 if(typeof_type->typeof_type != NULL) {
519 type = typeof_type->typeof_type;
521 type = typeof_type->expression->datatype;
526 const builtin_type_t *builtin_type = (const builtin_type_t*) type;
527 type = builtin_type->real_type;
541 static type_t *identify_new_type(type_t *type)
543 type_t *result = typehash_insert(type);
545 obstack_free(type_obst, type);
550 type_t *make_atomic_type(atomic_type_type_t type, type_qualifier_t qualifiers)
552 atomic_type_t *atomic_type
553 = obstack_alloc(type_obst, sizeof(atomic_type[0]));
554 memset(atomic_type, 0, sizeof(atomic_type[0]));
555 atomic_type->type.type = TYPE_ATOMIC;
556 atomic_type->type.qualifiers = qualifiers;
557 atomic_type->atype = type;
559 return identify_new_type((type_t*) atomic_type);
562 type_t *make_pointer_type(type_t *points_to, type_qualifier_t qualifiers)
564 pointer_type_t *pointer_type
565 = obstack_alloc(type_obst, sizeof(pointer_type[0]));
566 memset(pointer_type, 0, sizeof(pointer_type[0]));
567 pointer_type->type.type = TYPE_POINTER;
568 pointer_type->type.qualifiers = qualifiers;
569 pointer_type->points_to = points_to;
571 return identify_new_type((type_t*) pointer_type);
574 static __attribute__((unused))
575 void dbg_type(type_t *type)