diff --git a/mie/dialect/arith/float.c b/mie/dialect/arith/float.c index 5f085d0..367be89 100644 --- a/mie/dialect/arith/float.c +++ b/mie/dialect/arith/float.c @@ -3,6 +3,7 @@ #include #include #include +#include #include #include #include @@ -13,23 +14,24 @@ struct float_type { }; static enum mie_status value_print( - const struct mie_type *ty, const struct mie_value *value, b_stream *out) + const struct mie_value *value, struct mie_printer *out) { - struct float_type *float_ty = (struct float_type *)ty; + struct float_type *float_ty = (struct float_type *)value->v_type; struct mie_float *float_val = (struct mie_float *)value; switch (float_ty->f_width) { case MIE_FLOAT_32: b_stream_write_fmt( - out, NULL, "%f : f%zu", float_val->f_val.v_32, + out->p_stream, NULL, "%f : f%zu", float_val->f_val.v_32, float_ty->f_width); break; case MIE_FLOAT_64: b_stream_write_fmt( - out, NULL, "%lf : f%zu", float_val->f_val.v_64, - float_ty->f_width); + out->p_stream, NULL, "%lf : f%zu", + float_val->f_val.v_64, float_ty->f_width); break; default: - b_stream_write_fmt(out, NULL, "NaN : f%zu", float_ty->f_width); + b_stream_write_fmt( + out->p_stream, NULL, "NaN : f%zu", float_ty->f_width); break; } @@ -83,10 +85,15 @@ size_t mie_arith_float_type_get_width(const struct mie_type *type) return float_type->f_width; } -static enum mie_status print( - const struct mie_type_definition *def, const struct mie_type *ty, - b_stream *out) +static enum mie_status print(const struct mie_type *ty, struct mie_printer *out) { + const struct float_type *float_type = (const struct float_type *)ty; + b_stream_write_fmt( + out->p_stream, NULL, + (out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "f%zu" + : "arith.float<%zu>", + float_type->f_width); + return MIE_SUCCESS; } diff --git a/mie/dialect/arith/int.c b/mie/dialect/arith/int.c index 820e3ef..9929d3b 100644 --- a/mie/dialect/arith/int.c +++ b/mie/dialect/arith/int.c @@ -3,6 +3,7 @@ #include #include #include +#include #include #include #include @@ -13,16 +14,17 @@ struct int_type { }; static enum mie_status value_print( - const struct mie_type *ty, const struct mie_value *value, b_stream *out) + const struct mie_value *value, struct mie_printer *out) { - struct int_type *int_ty = (struct int_type *)ty; + struct int_type *int_ty = (struct int_type *)value->v_type; struct mie_int *int_val = (struct mie_int *)value; if (int_ty->i_width <= 64) { b_stream_write_fmt( - out, NULL, "%zu : i%zu", int_val->i_val.v_small, - int_ty->i_width); + out->p_stream, NULL, "%zu : i%zu", + int_val->i_val.v_small, int_ty->i_width); } else { - b_stream_write_fmt(out, NULL, "INF : i%zu", int_ty->i_width); + b_stream_write_fmt( + out->p_stream, NULL, "INF : i%zu", int_ty->i_width); } return MIE_SUCCESS; @@ -75,10 +77,14 @@ size_t mie_arith_int_type_get_width(const struct mie_type *type) return int_type->i_width; } -static enum mie_status print( - const struct mie_type_definition *def, const struct mie_type *ty, - b_stream *out) +static enum mie_status print(const struct mie_type *ty, struct mie_printer *out) { + const struct int_type *int_type = (const struct int_type *)ty; + b_stream_write_fmt( + out->p_stream, NULL, + (out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "i%zu" : "arith.int<%zu>", + int_type->i_width); + return MIE_SUCCESS; } diff --git a/mie/dialect/builtin/string.c b/mie/dialect/builtin/string.c index 72e1c22..f1cdfd2 100644 --- a/mie/dialect/builtin/string.c +++ b/mie/dialect/builtin/string.c @@ -3,15 +3,16 @@ #include #include #include +#include #include #include #include static enum mie_status value_print( - const struct mie_type *ty, const struct mie_value *value, b_stream *out) + const struct mie_value *value, struct mie_printer *out) { const struct mie_string *str = (const struct mie_string *)value; - b_stream_write_fmt(out, NULL, "\"%s\"", str->str_val); + b_stream_write_fmt(out->p_stream, NULL, "\"%s\"", str->str_val); return MIE_SUCCESS; } @@ -21,9 +22,7 @@ static void type_init( type->ty_instance_size = sizeof(struct mie_string); } -static enum mie_status print( - const struct mie_type_definition *def, const struct mie_type *ty, - b_stream *out) +static enum mie_status print(const struct mie_type *ty, struct mie_printer *out) { return MIE_SUCCESS; } diff --git a/mie/dialect/index/index.c b/mie/dialect/index/index.c index 8607de8..079a041 100644 --- a/mie/dialect/index/index.c +++ b/mie/dialect/index/index.c @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -10,12 +11,12 @@ struct index_type { }; static enum mie_status value_print( - const struct mie_type *ty, const struct mie_value *value, b_stream *out) + const struct mie_value *value, struct mie_printer *out) { - struct index_type *index_ty = (struct index_type *)ty; + struct index_type *index_ty = (struct index_type *)value->v_type; struct mie_index *index_val = (struct mie_index *)value; b_stream_write_fmt( - out, NULL, "%zu : %s", index_val->i_value, + out->p_stream, NULL, "%zu : %s", index_val->i_value, index_ty->i_base.ty_def->ty_name); return MIE_SUCCESS; } @@ -26,10 +27,12 @@ static void type_init( type->ty_instance_size = sizeof(struct mie_index); } -static enum mie_status print( - const struct mie_type_definition *def, const struct mie_type *ty, - b_stream *out) +static enum mie_status print(const struct mie_type *ty, struct mie_printer *out) { + b_stream_write_string( + out->p_stream, + (out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "index" : "index.index", + NULL); return MIE_SUCCESS; } diff --git a/mie/dialect/ptr/ptr.c b/mie/dialect/ptr/ptr.c index f52289d..107e1bf 100644 --- a/mie/dialect/ptr/ptr.c +++ b/mie/dialect/ptr/ptr.c @@ -6,9 +6,7 @@ struct ptr_type { struct mie_type_definition ptr_base; }; -static enum mie_status print( - const struct mie_type_definition *def, const struct mie_type *ty, - b_stream *out) +static enum mie_status print(const struct mie_type *ty, struct mie_printer *out) { return MIE_SUCCESS; } diff --git a/mie/include/mie/ir/module.h b/mie/include/mie/ir/module.h index 4ccff9a..3dbeaa1 100644 --- a/mie/include/mie/ir/module.h +++ b/mie/include/mie/ir/module.h @@ -1,6 +1,7 @@ #ifndef MIE_IR_MODULE_H_ #define MIE_IR_MODULE_H_ +#include #include #include #include diff --git a/mie/include/mie/print/printer.h b/mie/include/mie/print/printer.h new file mode 100644 index 0000000..72be348 --- /dev/null +++ b/mie/include/mie/print/printer.h @@ -0,0 +1,47 @@ +#ifndef MIE_PRINT_PRINTER_H_ +#define MIE_PRINT_PRINTER_H_ + +#include +#include +#include + +struct mie_ctx; +struct mie_module; +struct mie_op; +struct mie_region; +struct mie_block; +struct mie_type; +struct mie_value; +struct mie_register; + +enum mie_print_flags { + MIE_PRINT_F_GENERIC = 0x01u, + MIE_PRINT_F_ABBREVIATED = 0x02u, +}; + +struct mie_printer { + enum mie_print_flags p_flags; + struct mie_ctx *p_mie; + b_stream *p_stream; +}; + +MIE_API enum mie_status mie_printer_init( + struct mie_printer *printer, struct mie_ctx *ctx, b_stream *out, + enum mie_print_flags flags); + +MIE_API void mie_printer_print_module( + struct mie_printer *printer, const struct mie_module *mod); +MIE_API void mie_printer_print_op( + struct mie_printer *printer, const struct mie_op *op); +MIE_API void mie_printer_print_region( + struct mie_printer *printer, const struct mie_region *region); +MIE_API void mie_printer_print_block( + struct mie_printer *printer, const struct mie_block *block); +MIE_API void mie_printer_print_type( + struct mie_printer *printer, const struct mie_type *type); +MIE_API void mie_printer_print_value( + struct mie_printer *printer, const struct mie_value *value); +MIE_API void mie_printer_print_register( + struct mie_printer *printer, const struct mie_register *reg); + +#endif diff --git a/mie/include/mie/status.h b/mie/include/mie/status.h index 02b960d..f937b74 100644 --- a/mie/include/mie/status.h +++ b/mie/include/mie/status.h @@ -14,6 +14,7 @@ enum mie_status { MIE_ERR_BAD_FORMAT, MIE_ERR_NOT_SUPPORTED, MIE_ERR_INVALID_VALUE, + MIE_ERR_INVALID_ARGUMENT, MIE_ERR_INTERNAL_FAILURE, MIE_ERR_NO_MEMORY, MIE_ERR_NO_ENTRY, diff --git a/mie/include/mie/type/function.h b/mie/include/mie/type/function.h index 16cd5a5..cf0b91b 100644 --- a/mie/include/mie/type/function.h +++ b/mie/include/mie/type/function.h @@ -18,8 +18,6 @@ MIE_API void mie_function_type_add_in_part( MIE_API void mie_function_type_add_out_part( struct mie_function_type *ty, const struct mie_type *part); -MIE_API void mie_function_type_print( - const struct mie_function_type *type, b_stream *out); MIE_API void mie_function_type_build_id( struct mie_id_builder *builder, const struct mie_type **in_types, size_t nr_in_types, const struct mie_type **out_types, diff --git a/mie/include/mie/type/storage.h b/mie/include/mie/type/storage.h index e40283b..db29e3b 100644 --- a/mie/include/mie/type/storage.h +++ b/mie/include/mie/type/storage.h @@ -15,8 +15,6 @@ MIE_API struct mie_storage_type *mie_storage_type_create(void); MIE_API void mie_storage_type_add_part( struct mie_storage_type *ty, const struct mie_type *part); -MIE_API void mie_storage_type_print( - const struct mie_storage_type *type, b_stream *out); MIE_API void mie_storage_type_build_id( struct mie_id_builder *builder, const struct mie_type **parts, size_t nr_parts); diff --git a/mie/include/mie/type/type-definition.h b/mie/include/mie/type/type-definition.h index 564a5c5..611d71f 100644 --- a/mie/include/mie/type/type-definition.h +++ b/mie/include/mie/type/type-definition.h @@ -6,6 +6,7 @@ struct mie_value; struct mie_type; struct mie_parser; +struct mie_printer; /* a static struct that defines the properties, traits, and callbacks for a type. */ struct mie_type_definition { @@ -19,11 +20,9 @@ struct mie_type_definition { void (*ty_init)(const struct mie_type_definition *, struct mie_type *); void (*ty_cleanup)(const struct mie_type_definition *, struct mie_type *); void (*ty_instance_cleanup)(const struct mie_type *, struct mie_value *); - enum mie_status (*ty_print)( - const struct mie_type_definition *, const struct mie_type *, - b_stream *); + enum mie_status (*ty_print)(const struct mie_type *, struct mie_printer *); enum mie_status (*ty_value_print)( - const struct mie_type *, const struct mie_value *, b_stream *); + const struct mie_value *, struct mie_printer *); enum mie_status (*ty_parse)( const struct mie_type_definition *, struct mie_parser *, struct mie_type **); diff --git a/mie/include/mie/type/type.h b/mie/include/mie/type/type.h index 7a33fca..2c1d0f8 100644 --- a/mie/include/mie/type/type.h +++ b/mie/include/mie/type/type.h @@ -42,7 +42,6 @@ struct mie_type { }; MIE_API struct mie_type *mie_type_create(struct mie_type_definition *type); -MIE_API void mie_type_print(const struct mie_type *type, b_stream *out); MIE_API void mie_type_build_id( const struct mie_type *type, struct mie_id_builder *ctx); MIE_API void mie_type_generate_id( diff --git a/mie/include/mie/value.h b/mie/include/mie/value.h index 7ebb64b..f5aab2d 100644 --- a/mie/include/mie/value.h +++ b/mie/include/mie/value.h @@ -1,7 +1,6 @@ #ifndef MIE_VALUE_VALUE_H_ #define MIE_VALUE_VALUE_H_ -#include #include struct mie_type; @@ -10,6 +9,4 @@ struct mie_value { struct mie_type *v_type; }; -MIE_API void mie_value_print(const struct mie_value *value, b_stream *dest); - #endif diff --git a/mie/print/block.c b/mie/print/block.c new file mode 100644 index 0000000..886b582 --- /dev/null +++ b/mie/print/block.c @@ -0,0 +1,61 @@ +#include +#include +#include +#include + +static void print_block_header_params( + struct mie_printer *printer, const struct mie_block *block) +{ + if (!MIE_VECTOR_COUNT(block->b_params)) { + return; + } + + b_stream_write_char(printer->p_stream, '('); + + for (size_t i = 0; i < MIE_VECTOR_COUNT(block->b_params); i++) { + if (i > 0) { + b_stream_write_string(printer->p_stream, ", ", NULL); + } + + mie_printer_print_register(printer, block->b_params.items[i]); + + b_stream_write_string(printer->p_stream, ": ", NULL); + + mie_printer_print_type(printer, block->b_params.items[i]->reg_type); + } + + b_stream_write_char(printer->p_stream, ')'); +} + +static void print_block_header( + struct mie_printer *printer, const struct mie_block *block) +{ + if (!block->b_name.n_str && !MIE_VECTOR_COUNT(block->b_params)) { + return; + } + + b_stream_write_char(printer->p_stream, '^'); + + if (block->b_name.n_str) { + b_stream_write_string(printer->p_stream, block->b_name.n_str, NULL); + } + + print_block_header_params(printer, block); + + b_stream_write_string(printer->p_stream, ":\n", NULL); +} + +void mie_printer_print_block( + struct mie_printer *printer, const struct mie_block *block) +{ + print_block_header(printer, block); + b_stream_push_indent(printer->p_stream, 4); + + for (size_t i = 0; i < MIE_VECTOR_COUNT(block->b_ops); i++) { + const struct mie_op *op = &block->b_ops.items[i]; + mie_printer_print_op(printer, op); + b_stream_write_char(printer->p_stream, '\n'); + } + + b_stream_pop_indent(printer->p_stream); +} diff --git a/mie/print/module.c b/mie/print/module.c new file mode 100644 index 0000000..e37056a --- /dev/null +++ b/mie/print/module.c @@ -0,0 +1,12 @@ +#include +#include +#include + +void mie_printer_print_module( + struct mie_printer *printer, const struct mie_module *mod) +{ + for (size_t i = 0; i < MIE_VECTOR_COUNT(mod->m_ops); i++) { + mie_printer_print_op(printer, &mod->m_ops.items[i]); + b_stream_write_char(printer->p_stream, '\n'); + } +} diff --git a/mie/print/op.c b/mie/print/op.c new file mode 100644 index 0000000..c0ee908 --- /dev/null +++ b/mie/print/op.c @@ -0,0 +1,220 @@ +#include +#include +#include +#include +#include +#include + +static void print_op_arg( + struct mie_printer *printer, const struct mie_op_arg *arg, bool include_type) +{ + enum mie_register_flags arg_flags = 0; + const char *arg_name = NULL; + const struct mie_type *arg_type = NULL; + + if (MIE_TEST_FLAGS(arg->arg_flags, MIE_OP_F_ARG_RESOLVED)) { + arg_flags = arg->arg_value->reg_flags; + arg_name = arg->arg_value->reg_name.n_str; + arg_type = arg->arg_value->reg_type; + } else { + arg_flags = arg->arg_unresolved.reg_flags; + arg_name = arg->arg_unresolved.reg_name; + arg_type = arg->arg_unresolved.reg_type; + } + + if (arg_flags & MIE_REGISTER_F_MACHINE) { + b_stream_write_char(printer->p_stream, '$'); + } else { + b_stream_write_char(printer->p_stream, '%'); + } + + b_stream_write_string(printer->p_stream, arg_name, NULL); + + if (!include_type) { + return; + } + + b_stream_write_string(printer->p_stream, ": ", NULL); + + mie_printer_print_type(printer, arg_type); +} + +static void print_successor( + struct mie_printer *printer, const struct mie_op_successor *successor) +{ + b_stream_write_char(printer->p_stream, '^'); + if (successor->s_flags & MIE_OP_F_SUCCESSOR_RESOLVED) { + b_stream_write_string( + printer->p_stream, successor->s_block->b_name.n_str, NULL); + } else { + b_stream_write_string( + printer->p_stream, successor->s_block_name, NULL); + } + + if (MIE_VECTOR_COUNT(successor->s_args) == 0) { + return; + } + + b_stream_write_string(printer->p_stream, ":(", NULL); + + for (size_t i = 0; i < MIE_VECTOR_COUNT(successor->s_args); i++) { + if (i > 0) { + b_stream_write_string(printer->p_stream, ", ", NULL); + } + + print_op_arg(printer, &successor->s_args.items[i], true); + } + + b_stream_write_char(printer->p_stream, ')'); +} + +static void print_successor_list( + struct mie_printer *printer, const struct mie_op *op) +{ + if (!MIE_VECTOR_COUNT(op->op_successors)) { + return; + } + + b_stream_write_string(printer->p_stream, " [ ", NULL); + + for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_successors); i++) { + if (i > 0) { + b_stream_write_string(printer->p_stream, ", ", NULL); + } + + print_successor(printer, &op->op_successors.items[i]); + } + + b_stream_write_string(printer->p_stream, " ]", NULL); +} + +static void print_region_list(struct mie_printer *printer, const struct mie_op *op) +{ + if (!MIE_VECTOR_COUNT(op->op_regions)) { + return; + } + + b_stream_write_string(printer->p_stream, " (", NULL); + + for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_regions); i++) { + if (i > 0) { + b_stream_write_string(printer->p_stream, ", ", NULL); + } + + mie_printer_print_region(printer, &op->op_regions.items[i]); + } + + b_stream_write_string(printer->p_stream, ")", NULL); +} + +static void print_attribute( + struct mie_printer *printer, const struct mie_op_attribute *attrib) +{ + b_stream_write_fmt(printer->p_stream, NULL, "%s = ", attrib->attrib_name); + mie_printer_print_value(printer, attrib->attrib_value); +} + +static void print_attribute_list( + struct mie_printer *printer, const struct mie_op *op) +{ + if (!MIE_VECTOR_COUNT(op->op_attrib)) { + return; + } + + b_stream_write_string(printer->p_stream, " { ", NULL); + + for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_attrib); i++) { + if (i > 0) { + b_stream_write_string(printer->p_stream, ", ", NULL); + } + + print_attribute(printer, &op->op_attrib.items[i]); + } + + b_stream_write_string(printer->p_stream, " }", NULL); +} + +static void print_type_signature( + struct mie_printer *printer, const struct mie_op *op) +{ + const struct mie_type *type = NULL; + b_stream_write_string(printer->p_stream, " : (", NULL); + + for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) { + if (i > 0) { + b_stream_write_string(printer->p_stream, ", ", NULL); + } + + const struct mie_op_arg *arg = &op->op_args.items[i]; + if (arg->arg_flags & MIE_OP_F_ARG_RESOLVED) { + type = arg->arg_value->reg_type; + } else { + type = arg->arg_unresolved.reg_type; + } + + mie_printer_print_type(printer, type); + } + + b_stream_write_string(printer->p_stream, ") -> ", NULL); + + if (MIE_VECTOR_COUNT(op->op_result) != 1) { + b_stream_write_char(printer->p_stream, '('); + } + + for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) { + if (i > 0) { + b_stream_write_string(printer->p_stream, ", ", NULL); + } + + type = op->op_result.items[i]->reg_type; + mie_printer_print_type(printer, type); + } + + if (MIE_VECTOR_COUNT(op->op_result) != 1) { + b_stream_write_char(printer->p_stream, ')'); + } +} + +void mie_printer_print_op(struct mie_printer *printer, const struct mie_op *op) +{ + for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) { + if (i > 0) { + b_stream_write_string(printer->p_stream, ", ", NULL); + } + + mie_printer_print_register(printer, op->op_result.items[i]); + } + + if (MIE_VECTOR_COUNT(op->op_result) > 0) { + b_stream_write_string(printer->p_stream, " = ", NULL); + } + + if (printer->p_flags & MIE_PRINT_F_GENERIC) { + b_stream_write_char(printer->p_stream, '~'); + } + + if (op->op_flags & MIE_OP_F_OP_RESOLVED) { + b_stream_write_fmt( + printer->p_stream, NULL, "%s.%s", + op->op_dialect->d_name, op->op_info->op_name); + } else { + b_stream_write_string(printer->p_stream, op->op_name, NULL); + } + + b_stream_write_char(printer->p_stream, '('); + + for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) { + if (i > 0) { + b_stream_write_string(printer->p_stream, ", ", NULL); + } + + print_op_arg(printer, &op->op_args.items[i], false); + } + + b_stream_write_char(printer->p_stream, ')'); + + print_successor_list(printer, op); + print_region_list(printer, op); + print_attribute_list(printer, op); + print_type_signature(printer, op); +} diff --git a/mie/print/printer.c b/mie/print/printer.c new file mode 100644 index 0000000..9391658 --- /dev/null +++ b/mie/print/printer.c @@ -0,0 +1,18 @@ +#include + +enum mie_status mie_printer_init( + struct mie_printer *printer, struct mie_ctx *ctx, b_stream *out, + enum mie_print_flags flags) +{ + memset(printer, 0x0, sizeof *printer); + + if (!(flags & MIE_PRINT_F_GENERIC) && !ctx) { + return MIE_ERR_INVALID_ARGUMENT; + } + + printer->p_mie = ctx; + printer->p_stream = out; + printer->p_flags = flags; + + return MIE_SUCCESS; +} diff --git a/mie/print/region.c b/mie/print/region.c new file mode 100644 index 0000000..86329f5 --- /dev/null +++ b/mie/print/region.c @@ -0,0 +1,16 @@ +#include +#include +#include + +void mie_printer_print_region( + struct mie_printer *printer, const struct mie_region *region) +{ + b_stream_write_string(printer->p_stream, "{\n", NULL); + + for (size_t i = 0; i < MIE_VECTOR_COUNT(region->r_blocks); i++) { + const struct mie_block *block = region->r_blocks.items[i]; + mie_printer_print_block(printer, block); + } + + b_stream_write_string(printer->p_stream, "}", NULL); +} diff --git a/mie/print/register.c b/mie/print/register.c new file mode 100644 index 0000000..09fc1b1 --- /dev/null +++ b/mie/print/register.c @@ -0,0 +1,17 @@ +#include +#include + +void mie_printer_print_register( + struct mie_printer *printer, const struct mie_register *reg) +{ + if (reg->reg_flags & MIE_REGISTER_F_VIRTUAL) { + b_stream_write_fmt( + printer->p_stream, NULL, "%%%s", reg->reg_name.n_str); + } else if (reg->reg_flags & MIE_REGISTER_F_MACHINE) { + // TODO this shouldnt use reg_name + b_stream_write_fmt( + printer->p_stream, NULL, "$%s", reg->reg_name.n_str); + } else { + b_stream_write_string(printer->p_stream, "?REG", NULL); + } +} diff --git a/mie/print/type.c b/mie/print/type.c new file mode 100644 index 0000000..444e019 --- /dev/null +++ b/mie/print/type.c @@ -0,0 +1,17 @@ +#include +#include +#include + +void mie_printer_print_type(struct mie_printer *printer, const struct mie_type *type) +{ + if (type->ty_def && type->ty_def->ty_print) { + type->ty_def->ty_print(type, printer); + } else if (type->ty_name) { + b_stream_write_string(printer->p_stream, type->ty_name, NULL); + } else if (type->ty_def && type->ty_def->ty_name) { + b_stream_write_string( + printer->p_stream, type->ty_def->ty_name, NULL); + } else { + b_stream_write_string(printer->p_stream, "", NULL); + } +} diff --git a/mie/value.c b/mie/print/value.c similarity index 51% rename from mie/value.c rename to mie/print/value.c index 4fc96eb..06ba4b3 100644 --- a/mie/value.c +++ b/mie/print/value.c @@ -2,9 +2,10 @@ #include #include -void mie_value_print(const struct mie_value *value, b_stream *dest) +void mie_printer_print_value( + struct mie_printer *printer, const struct mie_value *value) { if (value->v_type && value->v_type->ty_def->ty_value_print) { - value->v_type->ty_def->ty_value_print(value->v_type, value, dest); + value->v_type->ty_def->ty_value_print(value, printer); } } diff --git a/mie/type/function.c b/mie/type/function.c index 89f8cb0..fbc651d 100644 --- a/mie/type/function.c +++ b/mie/type/function.c @@ -1,3 +1,4 @@ +#include #include #include #include @@ -13,10 +14,39 @@ static void build_id(const struct mie_type *type, struct mie_id_builder *ctx) } static enum mie_status type_print( - const struct mie_type_definition *type_info, - const struct mie_type *type, b_stream *out) + const struct mie_type *type, struct mie_printer *out) { - mie_function_type_print((const struct mie_function_type *)type, out); + const struct mie_function_type *func + = (const struct mie_function_type *)type; + + b_stream_write_char(out->p_stream, '('); + + for (size_t i = 0; i < MIE_VECTOR_COUNT(func->func_in); i++) { + if (i > 0) { + b_stream_write_string(out->p_stream, ", ", NULL); + } + + mie_printer_print_type(out, MIE_VECTOR_ITEM(func->func_in, i)); + } + + b_stream_write_string(out->p_stream, ") -> ", NULL); + + if (MIE_VECTOR_COUNT(func->func_out) == 1) { + mie_printer_print_type(out, MIE_VECTOR_ITEM(func->func_out, 0)); + return MIE_SUCCESS; + } + + b_stream_write_char(out->p_stream, '('); + + for (size_t i = 0; i < MIE_VECTOR_COUNT(func->func_out); i++) { + if (i > 0) { + b_stream_write_string(out->p_stream, ", ", NULL); + } + + mie_printer_print_type(out, MIE_VECTOR_ITEM(func->func_out, i)); + } + + b_stream_write_char(out->p_stream, ')'); return MIE_SUCCESS; } @@ -53,36 +83,9 @@ void mie_function_type_add_out_part( mie_vector_push_back(ty->func_out, &part); } -void mie_function_type_print(const struct mie_function_type *type, b_stream *out) +void mie_function_type_print( + const struct mie_function_type *type, struct mie_printer *out) { - b_stream_write_char(out, '('); - - for (size_t i = 0; i < MIE_VECTOR_COUNT(type->func_in); i++) { - if (i > 0) { - b_stream_write_string(out, ", ", NULL); - } - - mie_type_print(MIE_VECTOR_ITEM(type->func_in, i), out); - } - - b_stream_write_string(out, ") -> ", NULL); - - if (MIE_VECTOR_COUNT(type->func_out) == 1) { - mie_type_print(MIE_VECTOR_ITEM(type->func_out, 0), out); - return; - } - - b_stream_write_char(out, '('); - - for (size_t i = 0; i < MIE_VECTOR_COUNT(type->func_out); i++) { - if (i > 0) { - b_stream_write_string(out, ", ", NULL); - } - - mie_type_print(MIE_VECTOR_ITEM(type->func_out, i), out); - } - - b_stream_write_char(out, ')'); } void mie_function_type_build_id( diff --git a/mie/type/storage.c b/mie/type/storage.c index 5630b81..6afbc72 100644 --- a/mie/type/storage.c +++ b/mie/type/storage.c @@ -1,3 +1,4 @@ +#include #include #include #include @@ -12,10 +13,22 @@ static void build_id(const struct mie_type *type, struct mie_id_builder *ctx) } static enum mie_status type_print( - const struct mie_type_definition *type_info, - const struct mie_type *type, b_stream *out) + + const struct mie_type *type, struct mie_printer *out) { - mie_storage_type_print((const struct mie_storage_type *)type, out); + const struct mie_storage_type *storage + = (const struct mie_storage_type *)type; + b_stream_write_char(out->p_stream, '('); + + for (size_t i = 0; i < MIE_VECTOR_COUNT(storage->st_parts); i++) { + if (i > 0) { + b_stream_write_string(out->p_stream, ", ", NULL); + } + + mie_printer_print_type(out, storage->st_parts.items[i]); + } + + b_stream_write_char(out->p_stream, ')'); return MIE_SUCCESS; } @@ -46,21 +59,6 @@ void mie_storage_type_add_part( mie_vector_push_back(ty->st_parts, &part); } -void mie_storage_type_print(const struct mie_storage_type *type, b_stream *out) -{ - b_stream_write_char(out, '('); - - for (size_t i = 0; i < MIE_VECTOR_COUNT(type->st_parts); i++) { - if (i > 0) { - b_stream_write_string(out, ", ", NULL); - } - - mie_type_print(MIE_VECTOR_ITEM(type->st_parts, i), out); - } - - b_stream_write_char(out, ')'); -} - void mie_storage_type_build_id( struct mie_id_builder *ctx, const struct mie_type **parts, size_t nr_parts) { diff --git a/mie/type/type.c b/mie/type/type.c index e617230..abb6a11 100644 --- a/mie/type/type.c +++ b/mie/type/type.c @@ -20,19 +20,6 @@ struct mie_type *mie_type_create(struct mie_type_definition *type) return out; } -void mie_type_print(const struct mie_type *type, b_stream *out) -{ - if (type->ty_name) { - b_stream_write_string(out, type->ty_name, NULL); - } else if (type->ty_def && type->ty_def->ty_print) { - type->ty_def->ty_print(type->ty_def, type, out); - } else if (type->ty_def->ty_name) { - b_stream_write_string(out, type->ty_def->ty_name, NULL); - } else { - b_stream_write_string(out, "", NULL); - } -} - void mie_type_build_id(const struct mie_type *type, struct mie_id_builder *ctx) { if (type->ty_def->ty_build_id) {