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;
82 void print_method_type_pre(const method_type_t *type)
84 print_type_qualifiers(type->type.qualifiers);
86 intern_print_type_pre(type->result_type);
88 /* TODO: don't emit braces if we're the toplevel type... */
93 void print_method_type_post(const method_type_t *type, const context_t *context)
95 /* TODO: don't emit braces if we're the toplevel type... */
96 intern_print_type_post(type->result_type);
102 if(context == NULL) {
103 method_parameter_t *parameter = type->parameters;
104 for( ; parameter != NULL; parameter = parameter->next) {
110 print_type(parameter->type);
113 declaration_t *parameter = context->declarations;
114 for( ; parameter != NULL; parameter = parameter->context_next) {
120 print_type_ext(parameter->type, parameter->symbol,
121 ¶meter->context);
132 if(first && !type->unspecified_parameters) {
139 void print_pointer_type_pre(const pointer_type_t *type)
141 intern_print_type_pre(type->points_to);
143 print_type_qualifiers(type->type.qualifiers);
146 static void print_pointer_type_post(const pointer_type_t *type)
148 intern_print_type_post(type->points_to);
151 static void print_array_type_post(const array_type_t *type)
154 if(type->is_static) {
155 fputs("static ", out);
157 print_type_qualifiers(type->type.qualifiers);
158 if(type->size != NULL) {
159 print_expression(type->size);
164 void print_enum_definition(const declaration_t *declaration)
170 declaration_t *entry = declaration->context_next;
171 for( ; entry != NULL && entry->storage_class == STORAGE_CLASS_ENUM_ENTRY;
172 entry = entry->context_next) {
175 fprintf(out, "%s", entry->symbol->string);
176 if(entry->init.initializer != NULL) {
178 print_initializer(entry->init.initializer);
188 static void print_type_enum(const enum_type_t *type)
190 print_type_qualifiers(type->type.qualifiers);
193 declaration_t *declaration = type->declaration;
194 symbol_t *symbol = declaration->symbol;
196 fputs(symbol->string, out);
198 print_enum_definition(declaration);
202 void print_compound_definition(const declaration_t *declaration)
207 declaration_t *iter = declaration->context.declarations;
208 for( ; iter != NULL; iter = iter->context_next) {
210 print_declaration(iter);
219 static void print_compound_type(const compound_type_t *type)
221 print_type_qualifiers(type->type.qualifiers);
223 if(type->type.type == TYPE_COMPOUND_STRUCT) {
224 fputs("struct ", out);
226 assert(type->type.type == TYPE_COMPOUND_UNION);
227 fputs("union ", out);
230 declaration_t *declaration = type->declaration;
231 symbol_t *symbol = declaration->symbol;
233 fputs(symbol->string, out);
235 print_compound_definition(declaration);
239 static void print_typedef_type_pre(typedef_type_t *type)
241 fputs(type->declaration->symbol->string, out);
244 static void print_typeof_type_pre(typeof_type_t *type)
246 fputs("typeof(", out);
247 if(type->expression != NULL) {
248 assert(type->typeof_type == NULL);
249 print_expression(type->expression);
251 print_type(type->typeof_type);
256 static void intern_print_type_pre(type_t *type)
260 fputs("invalid", out);
263 print_type_enum((enum_type_t*) type);
266 print_atomic_type((atomic_type_t*) type);
268 case TYPE_COMPOUND_STRUCT:
269 case TYPE_COMPOUND_UNION:
270 print_compound_type((compound_type_t*) type);
273 fputs(((builtin_type_t*) type)->symbol->string, out);
276 print_method_type_pre((method_type_t*) type);
279 print_pointer_type_pre((pointer_type_t*) type);
284 print_typedef_type_pre((typedef_type_t*) type);
287 print_typeof_type_pre((typeof_type_t*) type);
290 fputs("unknown", out);
294 void intern_print_type_post(type_t *type)
298 print_method_type_post((const method_type_t*) type, NULL);
301 print_pointer_type_post((const pointer_type_t*) type);
304 print_array_type_post((const array_type_t*) type);
309 case TYPE_COMPOUND_STRUCT:
310 case TYPE_COMPOUND_UNION:
318 void print_type(type_t *type)
320 print_type_ext(type, NULL, NULL);
323 void print_type_ext(type_t *type, const symbol_t *symbol,
324 const context_t *context)
327 fputs("nil type", out);
331 intern_print_type_pre(type);
334 fputs(symbol->string, out);
336 if(type->type == TYPE_METHOD) {
337 print_method_type_post((const method_type_t*) type, context);
339 intern_print_type_post(type);
343 bool type_valid(const type_t *type)
345 return type->type != TYPE_INVALID;
348 bool is_type_integer(const type_t *type)
350 if(type->type == TYPE_ENUM)
353 if(type->type != TYPE_ATOMIC)
356 atomic_type_t *atomic_type = (atomic_type_t*) type;
357 switch(atomic_type->atype) {
358 case ATOMIC_TYPE_BOOL:
359 case ATOMIC_TYPE_CHAR:
360 case ATOMIC_TYPE_SCHAR:
361 case ATOMIC_TYPE_UCHAR:
362 case ATOMIC_TYPE_SHORT:
363 case ATOMIC_TYPE_USHORT:
364 case ATOMIC_TYPE_INT:
365 case ATOMIC_TYPE_UINT:
366 case ATOMIC_TYPE_LONG:
367 case ATOMIC_TYPE_ULONG:
368 case ATOMIC_TYPE_LONGLONG:
369 case ATOMIC_TYPE_ULONGLONG:
376 bool is_type_floating(const type_t *type)
378 if(type->type != TYPE_ATOMIC)
381 atomic_type_t *atomic_type = (atomic_type_t*) type;
382 switch(atomic_type->atype) {
383 case ATOMIC_TYPE_FLOAT:
384 case ATOMIC_TYPE_DOUBLE:
385 case ATOMIC_TYPE_LONG_DOUBLE:
386 #ifdef PROVIDE_COMPLEX
387 case ATOMIC_TYPE_FLOAT_COMPLEX:
388 case ATOMIC_TYPE_DOUBLE_COMPLEX:
389 case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:
391 #ifdef PROVIDE_IMAGINARY
392 case ATOMIC_TYPE_FLOAT_IMAGINARY:
393 case ATOMIC_TYPE_DOUBLE_IMAGINARY:
394 case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY:
402 bool is_type_arithmetic(const type_t *type)
404 if(is_type_integer(type) || is_type_floating(type))
410 bool is_type_scalar(const type_t *type)
412 if(type->type == TYPE_POINTER)
415 return is_type_arithmetic(type);
418 static type_t *identify_new_type(type_t *type)
420 type_t *result = typehash_insert(type);
422 obstack_free(type_obst, type);
427 type_t *make_atomic_type(atomic_type_type_t type, type_qualifier_t qualifiers)
429 atomic_type_t *atomic_type
430 = obstack_alloc(type_obst, sizeof(atomic_type[0]));
431 memset(atomic_type, 0, sizeof(atomic_type[0]));
432 atomic_type->type.type = TYPE_ATOMIC;
433 atomic_type->type.qualifiers = qualifiers;
434 atomic_type->atype = type;
436 return identify_new_type((type_t*) atomic_type);
439 type_t *make_pointer_type(type_t *points_to, type_qualifier_t qualifiers)
441 pointer_type_t *pointer_type
442 = obstack_alloc(type_obst, sizeof(pointer_type[0]));
443 memset(pointer_type, 0, sizeof(pointer_type[0]));
444 pointer_type->type.type = TYPE_POINTER;
445 pointer_type->type.qualifiers = qualifiers;
446 pointer_type->points_to = points_to;
448 return identify_new_type((type_t*) pointer_type);
451 static __attribute__((unused))
452 void dbg_type(type_t *type)