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);
49 if(qualifiers & TYPE_QUALIFIER_INLINE) fputs("inline ", out);
53 void print_atomic_type(const atomic_type_t *type)
55 print_type_qualifiers(type->type.qualifiers);
59 case ATOMIC_TYPE_INVALID: s = "INVALIDATOMIC"; break;
60 case ATOMIC_TYPE_VOID: s = "void"; break;
61 case ATOMIC_TYPE_BOOL: s = "_Bool"; break;
62 case ATOMIC_TYPE_CHAR: s = "char"; break;
63 case ATOMIC_TYPE_SCHAR: s = "signed char"; break;
64 case ATOMIC_TYPE_UCHAR: s = "unsigned char"; break;
65 case ATOMIC_TYPE_INT: s = "int"; break;
66 case ATOMIC_TYPE_UINT: s = "unsigned int"; break;
67 case ATOMIC_TYPE_SHORT: s = "short"; break;
68 case ATOMIC_TYPE_USHORT: s = "unsigned short"; break;
69 case ATOMIC_TYPE_LONG: s = "long"; break;
70 case ATOMIC_TYPE_ULONG: s = "unsigned long"; break;
71 case ATOMIC_TYPE_LONGLONG: s = "long long"; break;
72 case ATOMIC_TYPE_ULONGLONG: s = "unsigned long long"; break;
73 case ATOMIC_TYPE_LONG_DOUBLE: s = "long double"; break;
74 case ATOMIC_TYPE_FLOAT: s = "float"; break;
75 case ATOMIC_TYPE_DOUBLE: s = "double"; break;
76 default: s = "UNKNOWNATOMIC"; break;
81 static void print_function_type_pre(const function_type_t *type)
83 print_type_qualifiers(type->type.qualifiers);
85 intern_print_type_pre(type->result_type);
87 /* TODO: don't emit braces if we're the toplevel type... */
91 static void print_function_type_post(const function_type_t *type,
92 const context_t *context)
94 /* TODO: don't emit braces if we're the toplevel type... */
95 intern_print_type_post(type->result_type);
101 if(context == NULL) {
102 function_parameter_t *parameter = type->parameters;
103 for( ; parameter != NULL; parameter = parameter->next) {
109 print_type(parameter->type);
112 declaration_t *parameter = context->declarations;
113 for( ; parameter != NULL; parameter = parameter->next) {
119 print_type_ext(parameter->type, parameter->symbol,
120 ¶meter->context);
131 if(first && !type->unspecified_parameters) {
138 void print_pointer_type_pre(const pointer_type_t *type)
140 intern_print_type_pre(type->points_to);
142 print_type_qualifiers(type->type.qualifiers);
145 static void print_pointer_type_post(const pointer_type_t *type)
147 intern_print_type_post(type->points_to);
150 static void print_array_type_post(const array_type_t *type)
153 if(type->is_static) {
154 fputs("static ", out);
156 print_type_qualifiers(type->type.qualifiers);
157 if(type->size != NULL) {
158 print_expression(type->size);
163 void print_enum_definition(const declaration_t *declaration)
169 declaration_t *entry = declaration->next;
170 for( ; entry != NULL && entry->storage_class == STORAGE_CLASS_ENUM_ENTRY;
171 entry = entry->next) {
174 fprintf(out, "%s", entry->symbol->string);
175 if(entry->init.initializer != NULL) {
177 print_initializer(entry->init.initializer);
187 static void print_type_enum(const enum_type_t *type)
189 print_type_qualifiers(type->type.qualifiers);
192 declaration_t *declaration = type->declaration;
193 symbol_t *symbol = declaration->symbol;
195 fputs(symbol->string, out);
197 print_enum_definition(declaration);
201 void print_compound_definition(const declaration_t *declaration)
206 declaration_t *iter = declaration->context.declarations;
207 for( ; iter != NULL; iter = iter->next) {
209 print_declaration(iter);
218 static void print_compound_type(const compound_type_t *type)
220 print_type_qualifiers(type->type.qualifiers);
222 if(type->type.type == TYPE_COMPOUND_STRUCT) {
223 fputs("struct ", out);
225 assert(type->type.type == TYPE_COMPOUND_UNION);
226 fputs("union ", out);
229 declaration_t *declaration = type->declaration;
230 symbol_t *symbol = declaration->symbol;
232 fputs(symbol->string, out);
234 print_compound_definition(declaration);
238 static void print_typedef_type_pre(typedef_type_t *type)
240 fputs(type->declaration->symbol->string, out);
243 static void print_typeof_type_pre(typeof_type_t *type)
245 fputs("typeof(", out);
246 if(type->expression != NULL) {
247 assert(type->typeof_type == NULL);
248 print_expression(type->expression);
250 print_type(type->typeof_type);
255 static void intern_print_type_pre(type_t *type)
259 fputs("invalid", out);
262 print_type_enum((enum_type_t*) type);
265 print_atomic_type((atomic_type_t*) type);
267 case TYPE_COMPOUND_STRUCT:
268 case TYPE_COMPOUND_UNION:
269 print_compound_type((compound_type_t*) type);
272 fputs(((builtin_type_t*) type)->symbol->string, out);
275 print_function_type_pre((function_type_t*) type);
278 print_pointer_type_pre((pointer_type_t*) type);
283 print_typedef_type_pre((typedef_type_t*) type);
286 print_typeof_type_pre((typeof_type_t*) type);
289 fputs("unknown", out);
292 static void intern_print_type_post(type_t *type)
296 print_function_type_post((const function_type_t*) type, NULL);
299 print_pointer_type_post((const pointer_type_t*) type);
302 print_array_type_post((const array_type_t*) type);
307 case TYPE_COMPOUND_STRUCT:
308 case TYPE_COMPOUND_UNION:
316 void print_type(type_t *type)
318 print_type_ext(type, NULL, NULL);
321 void print_type_ext(type_t *type, const symbol_t *symbol,
322 const context_t *context)
325 fputs("nil type", out);
329 intern_print_type_pre(type);
332 fputs(symbol->string, out);
334 if(type->type == TYPE_FUNCTION) {
335 print_function_type_post((const function_type_t*) type, context);
337 intern_print_type_post(type);
341 bool type_valid(const type_t *type)
343 return type->type != TYPE_INVALID;
346 bool is_type_integer(const type_t *type)
348 if(type->type == TYPE_ENUM)
351 if(type->type != TYPE_ATOMIC)
354 atomic_type_t *atomic_type = (atomic_type_t*) type;
355 switch(atomic_type->atype) {
356 case ATOMIC_TYPE_BOOL:
357 case ATOMIC_TYPE_CHAR:
358 case ATOMIC_TYPE_SCHAR:
359 case ATOMIC_TYPE_UCHAR:
360 case ATOMIC_TYPE_SHORT:
361 case ATOMIC_TYPE_USHORT:
362 case ATOMIC_TYPE_INT:
363 case ATOMIC_TYPE_UINT:
364 case ATOMIC_TYPE_LONG:
365 case ATOMIC_TYPE_ULONG:
366 case ATOMIC_TYPE_LONGLONG:
367 case ATOMIC_TYPE_ULONGLONG:
374 bool is_type_floating(const type_t *type)
376 if(type->type != TYPE_ATOMIC)
379 atomic_type_t *atomic_type = (atomic_type_t*) type;
380 switch(atomic_type->atype) {
381 case ATOMIC_TYPE_FLOAT:
382 case ATOMIC_TYPE_DOUBLE:
383 case ATOMIC_TYPE_LONG_DOUBLE:
384 #ifdef PROVIDE_COMPLEX
385 case ATOMIC_TYPE_FLOAT_COMPLEX:
386 case ATOMIC_TYPE_DOUBLE_COMPLEX:
387 case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:
389 #ifdef PROVIDE_IMAGINARY
390 case ATOMIC_TYPE_FLOAT_IMAGINARY:
391 case ATOMIC_TYPE_DOUBLE_IMAGINARY:
392 case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY:
400 bool is_type_signed(const type_t *type)
402 /* enum types are int for now */
403 if(type->type == TYPE_ENUM)
406 if(type->type != TYPE_ATOMIC)
409 atomic_type_t *atomic_type = (atomic_type_t*) type;
410 switch(atomic_type->atype) {
411 case ATOMIC_TYPE_CHAR:
412 case ATOMIC_TYPE_SCHAR:
413 case ATOMIC_TYPE_SHORT:
414 case ATOMIC_TYPE_INT:
415 case ATOMIC_TYPE_LONG:
416 case ATOMIC_TYPE_LONGLONG:
417 case ATOMIC_TYPE_FLOAT:
418 case ATOMIC_TYPE_DOUBLE:
419 case ATOMIC_TYPE_LONG_DOUBLE:
420 #ifdef PROVIDE_COMPLEX
421 case ATOMIC_TYPE_FLOAT_COMPLEX:
422 case ATOMIC_TYPE_DOUBLE_COMPLEX:
423 case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:
425 #ifdef PROVIDE_IMAGINARY
426 case ATOMIC_TYPE_FLOAT_IMAGINARY:
427 case ATOMIC_TYPE_DOUBLE_IMAGINARY:
428 case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY:
432 case ATOMIC_TYPE_BOOL:
433 case ATOMIC_TYPE_UCHAR:
434 case ATOMIC_TYPE_USHORT:
435 case ATOMIC_TYPE_UINT:
436 case ATOMIC_TYPE_ULONG:
437 case ATOMIC_TYPE_ULONGLONG:
440 case ATOMIC_TYPE_INVALID:
441 case ATOMIC_TYPE_VOID:
445 panic("invalid atomic type found");
449 bool is_type_arithmetic(const type_t *type)
451 if(is_type_integer(type) || is_type_floating(type))
457 bool is_type_scalar(const type_t *type)
459 if(type->type == TYPE_POINTER)
462 return is_type_arithmetic(type);
465 bool pointers_compatible(const type_t *type1, const type_t *type2)
467 assert(type1->type == TYPE_POINTER);
468 assert(type2->type == TYPE_POINTER);
472 type_t *skip_typeref(type_t *type)
477 const typedef_type_t *typedef_type = (const typedef_type_t*) type;
478 type = typedef_type->declaration->type;
482 const typeof_type_t *typeof_type = (const typeof_type_t *) type;
483 if(typeof_type->typeof_type != NULL) {
484 type = typeof_type->typeof_type;
486 type = typeof_type->expression->datatype;
491 const builtin_type_t *builtin_type = (const builtin_type_t*) type;
492 type = builtin_type->real_type;
506 static type_t *identify_new_type(type_t *type)
508 type_t *result = typehash_insert(type);
510 obstack_free(type_obst, type);
515 type_t *make_atomic_type(atomic_type_type_t type, type_qualifier_t qualifiers)
517 atomic_type_t *atomic_type
518 = obstack_alloc(type_obst, sizeof(atomic_type[0]));
519 memset(atomic_type, 0, sizeof(atomic_type[0]));
520 atomic_type->type.type = TYPE_ATOMIC;
521 atomic_type->type.qualifiers = qualifiers;
522 atomic_type->atype = type;
524 return identify_new_type((type_t*) atomic_type);
527 type_t *make_pointer_type(type_t *points_to, type_qualifier_t qualifiers)
529 pointer_type_t *pointer_type
530 = obstack_alloc(type_obst, sizeof(pointer_type[0]));
531 memset(pointer_type, 0, sizeof(pointer_type[0]));
532 pointer_type->type.type = TYPE_POINTER;
533 pointer_type->type.qualifiers = qualifiers;
534 pointer_type->points_to = points_to;
536 return identify_new_type((type_t*) pointer_type);
539 static __attribute__((unused))
540 void dbg_type(type_t *type)